Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:45
📄 __init__.py from .repository import Repository	35 B	2025-08-24 21:48
📁 __pycache__	-	2026-03-21 15:56
📄 base.py import os import tuned.logs from tuned.utils.commands import commands log = tuned.logs.get() class Function(object): """ Built-in function """ def __init__(self, name, nargs_max, nargs_min = None): self._name = name self._nargs_max = nargs_max self._nargs_min = nargs_min self._cmd = commands() # checks arguments # nargs_max - maximal number of arguments, there mustn't be more arguments, # if nargs_max is 0, number of arguments is unlimited # nargs_min - minimal number of arguments, if not None there must # be the same number of arguments or more @classmethod def _check_args(cls, args, nargs_max, nargs_min = None): if args is None or nargs_max is None: return False la = len(args) return (nargs_max == 0 or nargs_max >= la) and (nargs_min is None or nargs_min <= la) def execute(self, args): if self._check_args(args, self._nargs_max, self._nargs_min): return True else: log.error("invalid number of arguments for builtin function '%s'" % self._name) return False	1.02 KB	2025-08-24 21:48
📄 function_assertion.py import os import tuned.logs from . import base from tuned.utils.commands import commands from tuned.profiles.exceptions import InvalidProfileException log = tuned.logs.get() class assertion(base.Function): """ Assertion: compares argument 2 with argument 3. If they don't match it logs text from argument 1 and throws InvalidProfileException. This exception will abort profile loading. """ def __init__(self): # 3 arguments super(assertion, self).__init__("assertion", 3, 3) def execute(self, args): if not super(assertion, self).execute(args): return None if args[1] != args[2]: log.error("assertion '%s' failed: '%s' != '%s'" % (args[0], args[1], args[2])) raise InvalidProfileException("Assertion '%s' failed." % args[0]) return None	767 B	2025-08-24 21:48
📄 function_assertion_non_equal.py import os import tuned.logs from . import base from tuned.utils.commands import commands from tuned.profiles.exceptions import InvalidProfileException log = tuned.logs.get() class assertion_non_equal(base.Function): """ Assertion non equal: compares argument 2 with argument 3. If they match it logs text from argument 1 and throws InvalidProfileException. This exception will abort profile loading. """ def __init__(self): # 3 arguments super(assertion_non_equal, self).__init__("assertion_non_equal", 3, 3) def execute(self, args): if not super(assertion_non_equal, self).execute(args): return None if args[1] == args[2]: log.error("assertion '%s' failed: '%s' == '%s'" % (args[0], args[1], args[2])) raise InvalidProfileException("Assertion '%s' failed." % args[0]) return None	811 B	2025-08-24 21:48
📄 function_calc_isolated_cores.py import os import glob import tuned.logs from . import base import tuned.consts as consts from tuned.utils.commands import commands log = tuned.logs.get() cmd = commands() class calc_isolated_cores(base.Function): """ Calculates and returns isolated cores. The argument specifies how many cores per socket reserve for housekeeping. If not specified, 1 core per socket is reserved for housekeeping and the rest is isolated. """ def __init__(self): # max 1 argument super(calc_isolated_cores, self).__init__("calc_isolated_cores", 1) def execute(self, args): if not super(calc_isolated_cores, self).execute(args): return None cpus_reserve = 1 if len(args) > 0: if not args[0].isdecimal() or int(args[0]) < 0: log.error("invalid argument '%s' for builtin function '%s', it must be non-negative integer" % (args[0], self._name)) return None else: cpus_reserve = int(args[0]) topo = {} for cpu in glob.iglob(os.path.join(consts.SYSFS_CPUS_PATH, "cpu*")): cpuid = os.path.basename(cpu)[3:] if cpuid.isdecimal(): physical_package_id = os.path.join(cpu, "topology/physical_package_id") # Show no errors when the physical_package_id file does not exist -- the CPU may be offline. if not os.path.exists(physical_package_id): log.debug("file '%s' does not exist, cpu%s offline?" % (physical_package_id, cpuid)) continue socket = self._cmd.read_file(physical_package_id).strip() if socket.isdecimal(): topo[socket] = topo.get(socket, []) + [cpuid] isol_cpus = [] for cpus in topo.values(): cpus.sort(key = int) isol_cpus = isol_cpus + cpus[cpus_reserve:] isol_cpus.sort(key = int) return ",".join(cmd.cpulist_pack(isol_cpus))	1.68 KB	2025-08-24 21:48
📄 function_check_net_queue_count.py import tuned.logs from . import base log = tuned.logs.get() class check_net_queue_count(base.Function): """ Checks whether the user has specified a queue count for net devices. If not, return the number of housekeeping CPUs. """ def __init__(self): # 1 argument super(check_net_queue_count, self).__init__("check_net_queue_count", 1, 1) def execute(self, args): if not super(check_net_queue_count, self).execute(args): return None if args[0].isdigit(): return args[0] (ret, out) = self._cmd.execute(["nproc"]) log.warning("net-dev queue count is not correctly specified, setting it to HK CPUs %s" % (out)) return out	653 B	2025-08-24 21:48
📄 function_cpuinfo_check.py import re import tuned.logs from . import base log = tuned.logs.get() class cpuinfo_check(base.Function): """ Checks regexes against /proc/cpuinfo. Accepts arguments in the following form: REGEX1, STR1, REGEX2, STR2, ...[, STR_FALLBACK] If REGEX1 matches something in /proc/cpuinfo it expands to STR1, if REGEX2 matches it expands to STR2. It stops on the first match, i.e. if REGEX1 matches, no more regexes are processed. If none regex matches it expands to STR_FALLBACK. If there is no fallback, it expands to empty string. """ def __init__(self): # unlimited number of arguments, min 2 arguments super(cpuinfo_check, self).__init__("cpuinfo_check", 0, 2) def execute(self, args): if not super(cpuinfo_check, self).execute(args): return None cpuinfo = self._cmd.read_file("/proc/cpuinfo") for i in range(0, len(args), 2): if i + 1 < len(args): if re.search(args[i], cpuinfo, re.MULTILINE): return args[i + 1] if len(args) % 2: return args[-1] else: return ""	1011 B	2025-08-24 21:48
📄 function_cpulist2devs.py import tuned.logs from . import base log = tuned.logs.get() class cpulist2devs(base.Function): """ Conversion function: converts CPU list to device strings """ def __init__(self): # arbitrary number of arguments super(cpulist2devs, self).__init__("cpulist2devs", 0) def execute(self, args): if not super(cpulist2devs, self).execute(args): return None return self._cmd.cpulist2string(self._cmd.cpulist_unpack(",".join(args)), prefix = "cpu")	460 B	2025-08-24 21:48
📄 function_cpulist2hex.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist2hex(base.Function): """ Conversion function: converts CPU list to hexadecimal CPU mask """ def __init__(self): # arbitrary number of arguments super(cpulist2hex, self).__init__("cpulist2hex", 0) def execute(self, args): if not super(cpulist2hex, self).execute(args): return None return self._cmd.cpulist2hex(",,".join(args))	470 B	2025-08-24 21:48
📄 function_cpulist2hex_invert.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist2hex_invert(base.Function): """ Converts CPU list to hexadecimal CPU mask and inverts it """ def __init__(self): # arbitrary number of arguments super(cpulist2hex_invert, self).__init__("cpulist2hex_invert", 0) def execute(self, args): if not super(cpulist2hex_invert, self).execute(args): return None # current implementation inverts the CPU list and then converts it to hexmask return self._cmd.cpulist2hex(",".join(str(v) for v in self._cmd.cpulist_invert(",,".join(args))))	624 B	2025-08-24 21:48
📄 function_cpulist_invert.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist_invert(base.Function): """ Inverts list of CPUs (makes its complement). For the complement it gets number of online CPUs from the /sys/devices/system/cpu/online, e.g. system with 4 CPUs (0-3), the inversion of list "0,2,3" will be "1" """ def __init__(self): # arbitrary number of arguments super(cpulist_invert, self).__init__("cpulist_invert", 0) def execute(self, args): if not super(cpulist_invert, self).execute(args): return None return ",".join(str(v) for v in self._cmd.cpulist_invert(",,".join(args)))	659 B	2025-08-24 21:48
📄 function_cpulist_online.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist_online(base.Function): """ Checks whether CPUs from list are online, returns list containing only online CPUs """ def __init__(self): # arbitrary number of arguments super(cpulist_online, self).__init__("cpulist_online", 0) def execute(self, args): if not super(cpulist_online, self).execute(args): return None cpus = self._cmd.cpulist_unpack(",".join(args)) online = self._cmd.cpulist_unpack(self._cmd.read_file("/sys/devices/system/cpu/online")) return ",".join(str(v) for v in cpus if v in online)	651 B	2025-08-24 21:48
📄 function_cpulist_pack.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist_pack(base.Function): """ Conversion function: packs CPU list in form 1,2,3,5 to 1-3,5. The cpulist_unpack is used as a preprocessor, so it always returns optimal results. For details about input syntax see cpulist_unpack. """ def __init__(self): # arbitrary number of arguments super(cpulist_pack, self).__init__("cpulist_pack", 0) def execute(self, args): if not super(cpulist_pack, self).execute(args): return None return ",".join(str(v) for v in self._cmd.cpulist_pack(",,".join(args)))	637 B	2025-08-24 21:48
📄 function_cpulist_present.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist_present(base.Function): """ Checks whether CPUs from list are present, returns list containing only present CPUs """ def __init__(self): # arbitrary number of arguments super(cpulist_present, self).__init__("cpulist_present", 0) def execute(self, args): if not super(cpulist_present, self).execute(args): return None cpus = self._cmd.cpulist_unpack(",,".join(args)) present = self._cmd.cpulist_unpack(self._cmd.read_file("/sys/devices/system/cpu/present")) return ",".join(str(v) for v in sorted(list(set(cpus).intersection(set(present)))))	691 B	2025-08-24 21:48
📄 function_cpulist_unpack.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class cpulist_unpack(base.Function): """ Conversion function: unpacks CPU list in form 1-3,4 to 1,2,3,4 """ def __init__(self): # arbitrary number of arguments super(cpulist_unpack, self).__init__("cpulist_unpack", 0) def execute(self, args): if not super(cpulist_unpack, self).execute(args): return None return ",".join(str(v) for v in self._cmd.cpulist_unpack(",,".join(args)))	511 B	2025-08-24 21:48
📄 function_exec.py import os import tuned.logs from . import base from tuned.utils.commands import commands class execute(base.Function): """ Executes process and substitutes its output. """ def __init__(self): # unlimited number of arguments, min 1 argument (the name of executable) super(execute, self).__init__("exec", 0, 1) def execute(self, args): if not super(execute, self).execute(args): return None (ret, out) = self._cmd.execute(args) if ret == 0: return out return None	487 B	2025-08-24 21:48
📄 function_hex2cpulist.py import os import tuned.logs from . import base from tuned.utils.commands import commands log = tuned.logs.get() class hex2cpulist(base.Function): """ Conversion function: converts hexadecimal CPU mask to CPU list """ def __init__(self): # 1 argument super(hex2cpulist, self).__init__("hex2cpulist", 1, 1) def execute(self, args): if not super(hex2cpulist, self).execute(args): return None return ",".join(str(v) for v in self._cmd.hex2cpulist(args[0]))	472 B	2025-08-24 21:48
📄 function_intel_recommended_pstate.py from . import base PROCESSOR_NAME = ("sandybridge", "ivybridge", "haswell", "broadwell", "skylake") PMU_PATH = "/sys/devices/cpu/caps/pmu_name" ACTIVE = "active" DISABLE = "disable" class intel_recommended_pstate(base.Function): """ Checks the processor code name and return the recommended intel_pstate CPUFreq driver mode. Active is returned for the newer generation of processors not in the PROCESSOR_NAME list. Intel recommends to use the intel_pstate CPUFreq driver in active mode with HWP enabled on Ice Lake and later generations processors. This function allows dynamically setting intel_pstate based on the processor's model. For pre-IceLake processors setting pstate to active can introduce jitters which were historically seen around and tested with RHEL-7.4. From IceLake generation, intel has fixed these issues. """ def __init__(self): super(intel_recommended_pstate, self).__init__("intel_recommended_pstate", 0) def execute(self, args): if not super(intel_recommended_pstate, self).execute(args): return None current_processor_name = self._cmd.read_file(PMU_PATH).strip() if current_processor_name == "" or current_processor_name in PROCESSOR_NAME: return DISABLE return ACTIVE	1.33 KB	2025-08-24 21:48
📄 function_kb2s.py import os import tuned.logs from . import base from tuned.utils.commands import commands class kb2s(base.Function): """ Conversion function: kbytes to sectors """ def __init__(self): # 1 argument super(kb2s, self).__init__("kb2s", 1, 1) def execute(self, args): if not super(kb2s, self).execute(args): return None try: return str(int(args[0]) * 2) except ValueError: return None	405 B	2025-08-24 21:48
📄 function_log.py import tuned.logs from . import base log = tuned.logs.get() class execute(base.Function): """ Expands to concatenation of arguments and logs the result, useful for debugging. """ def __init__(self): # unlimited number of arguments, min 1 argument (the value to log) super(execute, self).__init__("log", 0, 1) def execute(self, args): if not super(execute, self).execute(args): return None s = "".join(args) log.info(s) return s	451 B	2025-08-24 21:48
📄 function_lscpu_check.py import re import tuned.logs from . import base log = tuned.logs.get() class lscpu_check(base.Function): """ Checks regexes against the output of lscpu. Accepts arguments in the following form: REGEX1, STR1, REGEX2, STR2, ...[, STR_FALLBACK] If REGEX1 matches something in the output it expands to STR1, if REGEX2 matches it expands to STR2. It stops on the first match, i.e. if REGEX1 matches, no more regexes are processed. If none regex matches it expands to STR_FALLBACK. If there is no fallback, it expands to empty string. """ def __init__(self): # unlimited number of arguments, min 2 arguments super(lscpu_check, self).__init__("lscpu_check", 0, 2) def execute(self, args): if not super(lscpu_check, self).execute(args): return None # Stdout is the 2nd result from the execute call _, lscpu = self._cmd.execute("lscpu") for i in range(0, len(args), 2): if i + 1 < len(args): if re.search(args[i], lscpu, re.MULTILINE): return args[i + 1] if len(args) % 2: return args[-1] else: return ""	1.02 KB	2025-08-24 21:48
📄 function_package2cpus.py import os import fnmatch from . import base from tuned.utils.commands import commands from tuned import logs log = logs.get() cmd = commands() SYSFS_DIR = "/sys/devices/system/cpu/" class package2cpus(base.Function): """ Provides cpu device list for a package (socket) """ def __init__(self): super(package2cpus, self).__init__("package2cpus", 0) def execute(self, args): if not super(package2cpus, self).execute(args): return None if len(args) <= 0: return None try: all_cpus = fnmatch.filter(os.listdir(SYSFS_DIR), "cpu[0-9]*") except OSError: return None devices = [] for cpu in all_cpus: f = SYSFS_DIR + cpu + "/topology/physical_package_id" if not os.path.exists(f): log.warning("File '%s' does not exist" % f) continue value = cmd.read_file(f) try: package_id = int(value) except ValueError: log.warning("Invalid package id '%s' for cpu '%s'" % (value, cpu)) continue for package_pattern in args: try: this_package_id = int(package_pattern) except ValueError: if fnmatch.fnmatch(value, package_pattern): devices.append(cpu) else: if package_id == this_package_id: devices.append(cpu) return ",".join(devices) if len(devices) > 0 else None	1.24 KB	2025-08-24 21:48
📄 function_package2uncores.py import os import fnmatch from . import base from tuned.utils.commands import commands from tuned import logs log = logs.get() cmd = commands() SYSFS_DIR = "/sys/devices/system/cpu/intel_uncore_frequency/" class package2uncores(base.Function): """ Provides uncore device list for a package (socket) """ def __init__(self): super(package2uncores, self).__init__("package2uncores", 0) def execute(self, args): if not super(package2uncores, self).execute(args): return None if len(args) <= 0: return None try: all_uncores = os.listdir(SYSFS_DIR) except OSError: return None # For new TPMI interface use only uncore devices tpmi_devices = fnmatch.filter(all_uncores, 'uncore*') if len(tpmi_devices) > 0: is_tpmi = True all_uncores = tpmi_devices else: is_tpmi = False devices = [] for uncore in all_uncores: if is_tpmi: f = SYSFS_DIR + uncore + "/package_id" if not os.path.exists(f): log.warning("File '%s' does not exist" % f) continue value = cmd.read_file(f) else: # uncore string is in form: package_NN_die_MM, do not expect more than 99 packages value = uncore[8:10] try: package_id = int(value) except ValueError: log.warning("Invalid package id '%s' for uncore '%s'" % (value, uncore)) continue for package_pattern in args: try: this_package_id = int(package_pattern) except ValueError: if fnmatch.fnmatch(value, package_pattern): devices.append(uncore) else: if package_id == this_package_id: devices.append(uncore) return ",".join(devices) if len(devices) > 0 else None	1.6 KB	2025-08-24 21:48
📄 function_regex_search_ternary.py import re from . import base class regex_search_ternary(base.Function): """ Ternary regex operator, it takes arguments in the following form STR1, REGEX, STR2, STR3 If REGEX matches STR1 (re.search is used), STR2 is returned, otherwise STR3 is returned """ def __init__(self): # 4 arguments super(regex_search_ternary, self).__init__("regex_search_ternary", 4, 4) def execute(self, args): if not super(regex_search_ternary, self).execute(args): return None if re.search(args[1], args[0]): return args[2] else: return args[3]	554 B	2025-08-24 21:48
📄 function_s2kb.py import os import tuned.logs from . import base from tuned.utils.commands import commands class s2kb(base.Function): """ Conversion function: sectors to kbytes """ def __init__(self): # 1 argument super(s2kb, self).__init__("s2kb", 1, 1) def execute(self, args): if not super(s2kb, self).execute(args): return None try: return str(int(round(int(args[0]) / 2))) except ValueError: return None	417 B	2025-08-24 21:48
📄 function_strip.py import os import tuned.logs from . import base from tuned.utils.commands import commands class strip(base.Function): """ Makes string from all arguments and strip it """ def __init__(self): # unlimited number of arguments, min 1 argument super(strip, self).__init__("strip", 0, 1) def execute(self, args): if not super(strip, self).execute(args): return None return "".join(args).strip()	406 B	2025-08-24 21:48
📄 function_virt_check.py import os import tuned.logs from . import base from tuned.utils.commands import commands class virt_check(base.Function): """ Checks whether running inside virtual machine (VM) or on bare metal. If running inside VM expands to argument 1, otherwise expands to argument 2 (even on error). """ def __init__(self): # 2 arguments super(virt_check, self).__init__("virt_check", 2, 2) def execute(self, args): if not super(virt_check, self).execute(args): return None (ret, out) = self._cmd.execute(["virt-what"]) if ret == 0 and len(out) > 0: return args[0] return args[1]	595 B	2025-08-24 21:48
📄 parser.py import re import tuned.logs from tuned.utils.commands import commands log = tuned.logs.get() cmd = commands() class Parser(): """ Parser used for expanding strings containing functions. """ def __init__(self, repository): self._repository = repository def _parse_init(self, s = ""): self._cnt = 0 self._str = s self._len = len(s) self._stack = [] self._esc = False def _curr_char(self): return self._str[self._cnt] if self._cnt < self._len else "" def _curr_substr(self, _len): return self._str[self._cnt:self._cnt + _len] def _push_pos(self, esc): self._stack.append((esc, self._cnt)) def _sub(self, a, b, s): self._str = self._str[:a] + s + self._str[b + 1:] self._len = len(self._str) self._cnt += len(s) - (b - a + 1) if self._cnt < 0: self._cnt = 0 def _process_func(self, _from): sl = re.split(r'(?<!\\):', self._str[_from:self._cnt]) if sl[0] != "${f": return sl = [str(v).replace(r"\:", ":") for v in sl] if not re.match(r'\w+$', sl[1]): log.error("invalid function name '%s'" % sl[1]) return try: f = self._repository.load_func(sl[1]) except ImportError: log.error("function '%s' not implemented" % sl[1]) return s = f.execute(sl[2:]) log.debug("${f:%s} expands to: '%s'" % (":".join(sl[1:]), s)) if s is None: return self._sub(_from, self._cnt, s) def _process(self, s): self._parse_init(s) while self._cnt < self._len: if self._curr_char() == "}": try: si = self._stack.pop() except IndexError: log.error("invalid variable syntax, non pair '}' in: '%s'" % s) return self._str # if not escaped if not si[0]: self._process_func(si[1]) elif self._curr_substr(2) == "${": self._push_pos(self._esc) if self._curr_char() == "\\": self._esc = True else: self._esc = False self._cnt += 1 if len(self._stack): log.error("invalid variable syntax, non pair '{' in: '%s'" % s) return self._str def expand(self, s): if s is None or s == "": return s # expand functions and convert all \${f:} to ${f:} (unescape) return re.sub(r'\\(\${f:.*})', r'\1', self._process(s))	2.09 KB	2025-08-24 21:48
📄 repository.py from tuned.utils.class_loader import ClassLoader from tuned.profiles.functions.parser import Parser from tuned.profiles.functions.base import Function import tuned.logs import tuned.consts as consts log = tuned.logs.get() class Repository(ClassLoader): """ Repository of functions used within TuneD profiles. The functions are loaded lazily (when first used). """ def __init__(self): super(Repository, self).__init__() self._functions = {} @property def functions(self): return self._functions def _set_loader_parameters(self): self._namespace = "tuned.profiles.functions" self._prefix = consts.FUNCTION_PREFIX self._interface = Function def create(self, function_name): log.debug("creating function %s" % function_name) function_cls = self.load_class(function_name) function_instance = function_cls() self._functions[function_name] = function_instance return function_instance # load a function from its file and return it # if it is already loaded, just return it, it is not loaded again def load_func(self, function_name): if not function_name in self._functions: return self.create(function_name) return self._functions[function_name] def delete(self, function): assert isinstance(function, self._interface) log.debug("removing function %s" % function) for k, v in list(self._functions.items()): if v == function: del self._functions[k] def expand(self, s): return Parser(self).expand(s)	1.42 KB	2025-08-24 21:48

Edit File:

Terminal