Wala shell

Advanced PHP File Manager

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

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📁 __pycache__	-	2026-03-21 15:45
📄 config.py from tuned.utils.config_parser import ConfigParser, Error from tuned.exceptions import TunedException import os PPD_POWER_SAVER = "power-saver" PPD_BALANCED = "balanced" PPD_PERFORMANCE = "performance" MAIN_SECTION = "main" PROFILES_SECTION = "profiles" BATTERY_SECTION = "battery" DEFAULT_PROFILE_OPTION = "default" BATTERY_DETECTION_OPTION = "battery_detection" SYSFS_ACPI_MONITOR_OPTION = "sysfs_acpi_monitor" class ProfileMap: """ Mapping of PPD profiles to TuneD profiles or vice versa. """ def __init__(self, ac_map, dc_map): self._ac_map = ac_map self._dc_map = dc_map def get(self, profile, on_battery): """ Returns a TuneD profile corresponding to the given PPD profile and power supply status (or vice versa). """ profile_map = self._dc_map if on_battery else self._ac_map return profile_map[profile] def keys(self, on_battery): """ Returns the supported PPD or TuneD profiles. """ profile_map = self._dc_map if on_battery else self._ac_map return profile_map.keys() class PPDConfig: """ Configuration for the tuned-ppd daemon. """ def __init__(self, config_file, tuned_interface): self._tuned_interface = tuned_interface self.load_from_file(config_file) @property def battery_detection(self): """ Whether battery detection is enabled. """ return self._battery_detection @property def default_profile(self): """ Default PPD profile to set during initialization. """ return self._default_profile @property def ppd_to_tuned(self): """ Mapping of PPD profiles to TuneD profiles. """ return self._ppd_to_tuned @property def tuned_to_ppd(self): """ Mapping of TuneD profiles to PPD profiles. """ return self._tuned_to_ppd @property def sysfs_acpi_monitor(self): """ Whether to react to changes of ACPI platform profile done via function keys (e.g., Fn-L) on newer Thinkpad machines. Experimental feature. """ return self._sysfs_acpi_monitor def load_from_file(self, config_file): """ Loads the configuration from the provided file. """ cfg = ConfigParser() if not os.path.isfile(config_file): raise TunedException("Configuration file '%s' does not exist" % config_file) try: cfg.read(config_file) except Error: raise TunedException("Error parsing the configuration file '%s'" % config_file) if PROFILES_SECTION not in cfg: raise TunedException("Missing profiles section in the configuration file '%s'" % config_file) profile_dict_ac = dict(cfg[PROFILES_SECTION]) if PPD_POWER_SAVER not in profile_dict_ac: raise TunedException("Missing power-saver profile in the configuration file '%s'" % config_file) if PPD_BALANCED not in profile_dict_ac: raise TunedException("Missing balanced profile in the configuration file '%s'" % config_file) if PPD_PERFORMANCE not in profile_dict_ac: raise TunedException("Missing performance profile in the configuration file '%s'" % config_file) if MAIN_SECTION not in cfg or DEFAULT_PROFILE_OPTION not in cfg[MAIN_SECTION]: self._default_profile = PPD_BALANCED else: self._default_profile = cfg[MAIN_SECTION][DEFAULT_PROFILE_OPTION] if self._default_profile not in profile_dict_ac: raise TunedException("Default profile '%s' missing in the profile mapping" % self._default_profile) self._battery_detection = cfg.getboolean(MAIN_SECTION, BATTERY_DETECTION_OPTION, fallback=BATTERY_SECTION in cfg) if self._battery_detection and BATTERY_SECTION not in cfg: raise TunedException("Missing battery section in the configuration file '%s'" % config_file) profile_dict_dc = profile_dict_ac \| dict(cfg[BATTERY_SECTION]) if self._battery_detection else profile_dict_ac # Make sure all of the TuneD profiles specified in the configuration file actually exist unknown_tuned_profiles = (set(profile_dict_ac.values()) \| set(profile_dict_dc.values())) - set(self._tuned_interface.profiles()) if unknown_tuned_profiles: raise TunedException("Unknown TuneD profiles in the configuration file: " + ", ".join(unknown_tuned_profiles)) # Make sure there are no PPD profiles appearing in the battery section which are not defined before unknown_battery_profiles = set(profile_dict_dc.keys()) - set(profile_dict_ac.keys()) if unknown_battery_profiles: raise TunedException("Unknown PPD profiles in the battery section: " + ", ".join(unknown_battery_profiles)) # Make sure the profile mapping is injective so it can be reverted if len(set(profile_dict_ac.values())) != len(profile_dict_ac) or len(set(profile_dict_dc.values())) != len(profile_dict_dc): raise TunedException("Duplicate profile mapping in the configuration file '%s'" % config_file) self._ppd_to_tuned = ProfileMap(profile_dict_ac, profile_dict_dc) self._tuned_to_ppd = ProfileMap({v: k for k, v in profile_dict_ac.items()}, {v: k for k, v in profile_dict_dc.items()}) self._sysfs_acpi_monitor = cfg.getboolean(MAIN_SECTION, SYSFS_ACPI_MONITOR_OPTION, fallback=True)	5.42 KB	2025-08-24 21:48
📄 controller.py from tuned import exports, logs from tuned.utils.commands import commands from tuned.consts import PPD_CONFIG_FILE, PPD_BASE_PROFILE_FILE, PPD_API_COMPATIBILITY from tuned.ppd.config import PPDConfig, PPD_PERFORMANCE, PPD_BALANCED, PPD_POWER_SAVER from enum import Enum from random import Random import pyinotify import threading import dbus import os import time log = logs.get() DRIVER = "tuned" NO_TURBO_PATH = "/sys/devices/system/cpu/intel_pstate/no_turbo" LAP_MODE_PATH = "/sys/bus/platform/devices/thinkpad_acpi/dytc_lapmode" UNKNOWN_PROFILE = "unknown" UPOWER_DBUS_NAME = "org.freedesktop.UPower" UPOWER_DBUS_PATH = "/org/freedesktop/UPower" UPOWER_DBUS_INTERFACE = "org.freedesktop.UPower" PLATFORM_PROFILE_PATH = "/sys/firmware/acpi/platform_profile" PLATFORM_PROFILE_MAPPING = { "low-power": PPD_POWER_SAVER, "balanced": PPD_BALANCED, "performance": PPD_PERFORMANCE } class PerformanceDegraded(Enum): """ Possible reasons for performance degradation. """ NONE = "" LAP_DETECTED = "lap-detected" HIGH_OPERATING_TEMPERATURE = "high-operating-temperature" class PerformanceDegradedEventHandler(pyinotify.ProcessEvent): """ Event handler for checking performance degradation. """ def __init__(self, controller, path): super(PerformanceDegradedEventHandler, self).__init__() self._controller = controller self._path = path def process_IN_MODIFY(self, event): if event.pathname != self._path: return self._controller.check_performance_degraded() class PlatformProfileEventHandler(pyinotify.ProcessEvent): """ Event handler for switching PPD profiles based on the ACPI platform profile This handler should only invoke a PPD profile change if the change of the file at PLATFORM_PROFILE_PATH comes from within the kernel (e.g., when the user presses Fn-L on a Thinkpad laptop). This is currently detected as the file being modified without being opened before. """ CLOSE_MODIFY_BUFFER = 0.1 def __init__(self, controller): super(PlatformProfileEventHandler, self).__init__() self._controller = controller self._file_open = False self._last_close = 0 def process_IN_OPEN(self, event): if event.pathname != PLATFORM_PROFILE_PATH: return self._file_open = True self._last_close = 0 def process_IN_CLOSE_WRITE(self, event): if event.pathname != PLATFORM_PROFILE_PATH: return self._file_open = False self._last_close = time.time() def process_IN_CLOSE_NOWRITE(self, event): if event.pathname != PLATFORM_PROFILE_PATH: return self._file_open = False def process_IN_MODIFY(self, event): if event.pathname != PLATFORM_PROFILE_PATH or self._file_open or self._last_close + self.CLOSE_MODIFY_BUFFER > time.time(): # Do not invoke a profile change if a modify event comes: # 1. when the file is open, # 2. directly after the file is closed (the events may sometimes come in the wrong order). return self._controller.check_platform_profile() class ProfileHold(object): """ Class holding information about a single profile hold, i.e., a temporary profile switch requested by a process. """ def __init__(self, profile, reason, app_id, caller, watch): self.profile = profile self.reason = reason self.app_id = app_id self.caller = caller self.watch = watch def as_dict(self): """ Returns the hold information as a Python dictionary. """ return { "Profile": self.profile, "Reason": self.reason, "ApplicationId": self.app_id, } class ProfileHoldManager(object): """ Manager of profile holds responsible for their creation/deletion and for choosing the effective one. Holds are identified using integer cookies which are distributed to the hold-requesting processes. """ def __init__(self, controller): self._holds = {} self._cookie_generator = Random() self._controller = controller def _removal_callback(self, cookie, app_id): """ Returns the callback to invoke when the process with the given ID (which requested a hold with the given cookie) disappears. """ def callback(name): if name == "": log.info("Application '%s' disappeared, releasing hold '%s'" % (app_id, cookie)) self.remove(cookie) return callback def _effective_hold_profile(self): """ Returns the hold to use from the set of all active ones. """ if any(hold.profile == PPD_POWER_SAVER for hold in self._holds.values()): return PPD_POWER_SAVER return PPD_PERFORMANCE def _cancel(self, cookie): """ Cancels the hold saved under the provided cookie. """ if cookie not in self._holds: return hold = self._holds.pop(cookie) hold.watch.cancel() exports.send_signal("ProfileReleased", cookie) exports.property_changed("ActiveProfileHolds", self.as_dbus_array()) log.info("Releasing hold '%s': profile '%s' by application '%s'" % (cookie, hold.profile, hold.app_id)) def as_dbus_array(self): """ Returns the information about current holds as a DBus-compatible array. """ return dbus.Array([hold.as_dict() for hold in self._holds.values()], signature="a{sv}") def add(self, profile, reason, app_id, caller): """ Adds a new profile hold. """ cookie = 0 while cookie == 0 or cookie in self._holds: cookie = self._cookie_generator.randint(0, 2**32-1) watch = self._controller.bus.watch_name_owner(caller, self._removal_callback(cookie, app_id)) log.info("Adding hold '%s': profile '%s' by application '%s'" % (cookie, profile, app_id)) self._holds[cookie] = ProfileHold(profile, reason, app_id, caller, watch) exports.property_changed("ActiveProfileHolds", self.as_dbus_array()) self._controller.switch_profile(self._effective_hold_profile()) return cookie def has(self, cookie): """ Returns True if there is a hold under the given cookie. """ return cookie in self._holds def remove(self, cookie): """ Releases the hold saved under the provided cookie and sets the next profile. """ self._cancel(cookie) if len(self._holds) != 0: new_profile = self._effective_hold_profile() else: new_profile = self._controller.base_profile self._controller.switch_profile(new_profile) def clear(self): """ Releases all profile holds. """ for cookie in list(self._holds.keys()): self._cancel(cookie) def check_caller(self, cookie, caller): return cookie in self._holds and self._holds[cookie].caller == caller class Controller(exports.interfaces.ExportableInterface): """ The main tuned-ppd controller, exporting its DBus interface. """ def __init__(self, bus, tuned_interface): super(Controller, self).__init__() self._bus = bus self._tuned_interface = tuned_interface self._cmd = commands() self._terminate = threading.Event() self._battery_handler = None self._on_battery = False self._watch_manager = pyinotify.WatchManager() self._notifier = pyinotify.ThreadedNotifier(self._watch_manager) self._inotify_watches = {} self._pinned_virtual_files = [] self._platform_profile_supported = os.path.isfile(PLATFORM_PROFILE_PATH) self._no_turbo_supported = os.path.isfile(NO_TURBO_PATH) self._lap_mode_supported = os.path.isfile(LAP_MODE_PATH) self._tuned_interface.connect_to_signal("profile_changed", self._tuned_profile_changed) self.initialize() def _upower_changed(self, interface, changed, invalidated): """ The callback to invoke when the power supply changes. """ self._on_battery = bool(self._upower_properties.Get(UPOWER_DBUS_INTERFACE, "OnBattery")) log.info("Battery status changed: " + ("DC (battery)" if self._on_battery else "AC (charging)")) self.switch_profile(self._active_profile) def _tuned_profile_changed(self, tuned_profile, result, errstr): """ The callback to invoke when TuneD signals a profile change. """ if not result: return if tuned_profile != self._tuned_interface.active_profile(): log.debug("Received a profile change signal from TuneD, but it is not relevant anymore.") return try: ppd_profile = self._config.tuned_to_ppd.get(tuned_profile, self._on_battery) except KeyError: ppd_profile = UNKNOWN_PROFILE log.warning("TuneD profile changed to an unknown profile '%s'" % tuned_profile) if self._active_profile != ppd_profile: log.info("Profile changed to '%s'" % ppd_profile) self._profile_holds.clear() self._active_profile = ppd_profile exports.property_changed("ActiveProfile", self._active_profile) if ppd_profile != UNKNOWN_PROFILE: self._base_profile = ppd_profile self._save_base_profile(ppd_profile) def _setup_battery_signaling(self): """ Sets up handling of power supply changes. """ self._on_battery = False if not self._config.battery_detection: if self._battery_handler is not None: self._battery_handler.remove() self._battery_handler = None return try: if self._battery_handler is None: upower_proxy = self._bus.get_object(UPOWER_DBUS_NAME, UPOWER_DBUS_PATH) self._upower_properties = dbus.Interface(upower_proxy, dbus.PROPERTIES_IFACE) self._battery_handler = upower_proxy.connect_to_signal("PropertiesChanged", self._upower_changed) self._on_battery = bool(self._upower_properties.Get(UPOWER_DBUS_INTERFACE, "OnBattery")) except dbus.exceptions.DBusException as error: log.debug(error) def _setup_inotify(self): """ Sets up inotify file watches. """ for f in self._pinned_virtual_files: f.close() self._pinned_virtual_files.clear() self._watch_manager.rm_watch(list(self._inotify_watches.values())) if self._no_turbo_supported: self._pinned_virtual_files.append(open(NO_TURBO_PATH, "r")) self._inotify_watches \|= self._watch_manager.add_watch(path=os.path.dirname(NO_TURBO_PATH), mask=pyinotify.IN_MODIFY, proc_fun=PerformanceDegradedEventHandler(self, NO_TURBO_PATH)) if self._lap_mode_supported: self._pinned_virtual_files.append(open(LAP_MODE_PATH, "r")) self._inotify_watches \|= self._watch_manager.add_watch(path=os.path.dirname(LAP_MODE_PATH), mask=pyinotify.IN_MODIFY, proc_fun=PerformanceDegradedEventHandler(self, LAP_MODE_PATH)) if self._platform_profile_supported and self._config.sysfs_acpi_monitor: self._pinned_virtual_files.append(open(PLATFORM_PROFILE_PATH, "r")) self._inotify_watches \|= self._watch_manager.add_watch(path=os.path.dirname(PLATFORM_PROFILE_PATH), mask=pyinotify.IN_OPEN \| pyinotify.IN_MODIFY \| pyinotify.IN_CLOSE_WRITE \| pyinotify.IN_CLOSE_NOWRITE, proc_fun=PlatformProfileEventHandler(self)) def check_performance_degraded(self): """ Checks the current performance degradation status and sends a signal if it changed. """ performance_degraded = PerformanceDegraded.NONE if os.path.exists(NO_TURBO_PATH) and self._cmd.read_file(NO_TURBO_PATH).strip() == "1": performance_degraded = PerformanceDegraded.HIGH_OPERATING_TEMPERATURE if os.path.exists(LAP_MODE_PATH) and self._cmd.read_file(LAP_MODE_PATH).strip() == "1": performance_degraded = PerformanceDegraded.LAP_DETECTED if performance_degraded != self._performance_degraded: log.info("Performance degraded: %s" % performance_degraded.value) self._performance_degraded = performance_degraded exports.property_changed("PerformanceDegraded", performance_degraded.value) def check_platform_profile(self): """ Sets the active PPD profile based on the content of the ACPI platform profile. """ platform_profile = self._cmd.read_file(PLATFORM_PROFILE_PATH).strip() if platform_profile not in PLATFORM_PROFILE_MAPPING: return log.debug("Platform profile changed: %s" % platform_profile) new_profile = PLATFORM_PROFILE_MAPPING[platform_profile] self._profile_holds.clear() self.switch_profile(new_profile) self._base_profile = new_profile self._save_base_profile(new_profile) def _load_base_profile(self): """ Loads and returns the saved PPD base profile. """ return self._cmd.read_file(PPD_BASE_PROFILE_FILE, no_error=True).strip() or None def _save_base_profile(self, profile): """ Saves the given PPD profile into the base profile file. """ self._cmd.write_to_file(PPD_BASE_PROFILE_FILE, profile + "\n") def _set_tuned_profile(self, tuned_profile): """ Sets the TuneD profile to the given one if not already set. """ active_tuned_profile = self._tuned_interface.active_profile() if active_tuned_profile == tuned_profile: return True log.info("Setting TuneD profile to '%s'" % tuned_profile) ok, error_msg = self._tuned_interface.switch_profile(tuned_profile) if not ok: log.error(str(error_msg)) return bool(ok) def initialize(self): """ Initializes the controller. """ self._active_profile = None self._profile_holds = ProfileHoldManager(self) self._performance_degraded = PerformanceDegraded.NONE self.check_performance_degraded() self._config = PPDConfig(PPD_CONFIG_FILE, self._tuned_interface) self._setup_battery_signaling() self._base_profile = self._load_base_profile() or self._config.default_profile self.switch_profile(self._base_profile) self._save_base_profile(self._base_profile) self._setup_inotify() def run(self): """ Exports the DBus interface and runs the main daemon loop. """ exports.start() self._notifier.start() while not self._cmd.wait(self._terminate, 1): pass for f in self._pinned_virtual_files: f.close() self._pinned_virtual_files.clear() self._watch_manager.rm_watch(list(self._inotify_watches.values())) self._notifier.stop() exports.stop() @property def bus(self): """ DBus interface for communication with other services. """ return self._bus @property def base_profile(self): """ The base PPD profile. This is the profile to restore when all profile holds are released or when tuned-ppd is restarted. It may not be equal to the currently active profile. """ return self._base_profile def terminate(self): """ Stops the main loop of the daemon. """ self._terminate.set() def switch_profile(self, profile): """ Sets the currently active profile to the given one, if not already set. Does not change the base profile. """ if not self._set_tuned_profile(self._config.ppd_to_tuned.get(profile, self._on_battery)): return False if self._active_profile != profile: exports.property_changed("ActiveProfile", profile) self._active_profile = profile return True @exports.export("sss", "u", "hold-profile") def HoldProfile(self, profile, reason, app_id, caller): """ Initiates a profile hold and returns a cookie for referring to it. """ if profile != PPD_POWER_SAVER and profile != PPD_PERFORMANCE: raise dbus.exceptions.DBusException( "Only '%s' and '%s' profiles may be held" % (PPD_POWER_SAVER, PPD_PERFORMANCE) ) return self._profile_holds.add(profile, reason, app_id, caller) @exports.export("u", "", "release-profile") def ReleaseProfile(self, cookie, caller): """ Releases a held profile with the given cookie. """ if not self._profile_holds.has(cookie): raise dbus.exceptions.DBusException("No active hold for cookie '%s'" % cookie) if not self._profile_holds.check_caller(cookie, caller): raise dbus.exceptions.DBusException("Cannot release a profile hold inititated by another process.") self._profile_holds.remove(cookie) @exports.signal("u") def ProfileReleased(self, cookie): """ The DBus signal sent when a held profile is released. """ pass @exports.property_setter("ActiveProfile", "switch-profile") def set_active_profile(self, profile, caller): """ Sets the base profile to the given one and also makes it active. If there are any active profile holds, these are cancelled. """ if profile not in self._config.ppd_to_tuned.keys(self._on_battery): raise dbus.exceptions.DBusException("Invalid profile '%s'" % profile) log.debug("Setting base profile to %s" % profile) self._profile_holds.clear() if not self.switch_profile(profile): raise dbus.exceptions.DBusException("Error setting profile %s'" % profile) self._base_profile = profile self._save_base_profile(profile) @exports.property_getter("ActiveProfile") def get_active_profile(self, caller): """ Returns the currently active PPD profile. """ return self._active_profile @exports.property_getter("Profiles") def get_profiles(self, caller): """ Returns a DBus array of all available PPD profiles. """ return dbus.Array( [{"Profile": profile, "Driver": DRIVER} for profile in self._config.ppd_to_tuned.keys(self._on_battery)], signature="a{sv}", ) @exports.property_getter("Actions") def get_actions(self, caller): """ Returns a DBus array of all available actions (currently there are none). """ return dbus.Array([], signature="s") @exports.property_getter("PerformanceDegraded") def get_performance_degraded(self, caller): """ Returns the current performance degradation status. """ return self._performance_degraded.value @exports.property_getter("ActiveProfileHolds") def get_active_profile_holds(self, caller): """ Returns a DBus array of active profile holds. """ return self._profile_holds.as_dbus_array() @exports.property_getter("Version") def version(self, caller): return PPD_API_COMPATIBILITY	19.57 KB	2025-08-24 21:48
📄 dbus.conf <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd"> <busconfig> <policy user="root"> <allow own="?name?"/> </policy> <policy context="default"> <allow send_destination="?name?" send_interface="?name?"/> <allow send_destination="?name?" send_interface="org.freedesktop.DBus.Introspectable"/> <allow send_destination="?name?" send_interface="org.freedesktop.DBus.Properties"/> <allow send_destination="?name?" send_interface="org.freedesktop.DBus.Peer"/> </policy> </busconfig>	639 B	2025-08-24 21:48
📄 ppd.conf [main] # The default PPD profile default=balanced battery_detection=true sysfs_acpi_monitor=true [profiles] # PPD = TuneD power-saver=powersave balanced=balanced performance=throughput-performance [battery] # PPD = TuneD balanced=balanced-battery	249 B	2025-08-24 21:48
📄 tuned-ppd.dbus.service [D-BUS Service] Name=?name? Exec=/bin/false User=root SystemdService=tuned-ppd.service	87 B	2025-08-24 21:48
📄 tuned-ppd.policy <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE policyconfig PUBLIC "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN" "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd"> <policyconfig> <vendor>TuneD</vendor> <vendor_url>https://tuned-project.org/</vendor_url> <action id="?name?.switch-profile"> <description>Switch power profile</description> <message>Authentication is required to switch power profiles.</message> <defaults> <allow_any>no</allow_any> <allow_inactive>no</allow_inactive> <allow_active>yes</allow_active> </defaults> </action> <action id="?name?.hold-profile"> <description>Hold power profile</description> <message>Authentication is required to hold power profiles.</message> <defaults> <allow_any>no</allow_any> <allow_inactive>no</allow_inactive> <allow_active>yes</allow_active> </defaults> </action> <action id="?name?.release-profile"> <description>Release power profile</description> <message>Authentication is required to release power profiles.</message> <defaults> <allow_any>no</allow_any> <allow_inactive>no</allow_inactive> <allow_active>yes</allow_active> </defaults> </action> </policyconfig>	1.25 KB	2025-08-24 21:48
📄 tuned-ppd.service [Unit] Description=PPD-to-TuneD API Translation Daemon Requires=tuned.service After=tuned.service Before=multi-user.target display-manager.target [Service] Type=dbus BusName=org.freedesktop.UPower.PowerProfiles BusName=net.hadess.PowerProfiles ExecStart=/usr/sbin/tuned-ppd -l [Install] WantedBy=graphical.target	315 B	2025-08-24 21:48

Terminal