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-27 02:38
📄 __init__.py # -- coding: utf-8 -- # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """psutil is a cross-platform library for retrieving information on running processes and system utilization (CPU, memory, disks, network, sensors) in Python. Supported platforms: - Linux - Windows - macOS - FreeBSD - OpenBSD - NetBSD - Sun Solaris - AIX Works with Python versions 2.7 and 3.4+. """ from __future__ import division import collections import contextlib import datetime import functools import os import signal import subprocess import sys import threading import time try: import pwd except ImportError: pwd = None from . import _common from ._common import AIX from ._common import BSD from ._common import CONN_CLOSE from ._common import CONN_CLOSE_WAIT from ._common import CONN_CLOSING from ._common import CONN_ESTABLISHED from ._common import CONN_FIN_WAIT1 from ._common import CONN_FIN_WAIT2 from ._common import CONN_LAST_ACK from ._common import CONN_LISTEN from ._common import CONN_NONE from ._common import CONN_SYN_RECV from ._common import CONN_SYN_SENT from ._common import CONN_TIME_WAIT from ._common import FREEBSD # NOQA from ._common import LINUX from ._common import MACOS from ._common import NETBSD # NOQA from ._common import NIC_DUPLEX_FULL from ._common import NIC_DUPLEX_HALF from ._common import NIC_DUPLEX_UNKNOWN from ._common import OPENBSD # NOQA from ._common import OSX # deprecated alias from ._common import POSIX # NOQA from ._common import POWER_TIME_UNKNOWN from ._common import POWER_TIME_UNLIMITED from ._common import STATUS_DEAD from ._common import STATUS_DISK_SLEEP from ._common import STATUS_IDLE from ._common import STATUS_LOCKED from ._common import STATUS_PARKED from ._common import STATUS_RUNNING from ._common import STATUS_SLEEPING from ._common import STATUS_STOPPED from ._common import STATUS_TRACING_STOP from ._common import STATUS_WAITING from ._common import STATUS_WAKING from ._common import STATUS_ZOMBIE from ._common import SUNOS from ._common import WINDOWS from ._common import AccessDenied from ._common import Error from ._common import NoSuchProcess from ._common import TimeoutExpired from ._common import ZombieProcess from ._common import memoize_when_activated from ._common import wrap_numbers as _wrap_numbers from ._compat import PY3 as _PY3 from ._compat import PermissionError from ._compat import ProcessLookupError from ._compat import SubprocessTimeoutExpired as _SubprocessTimeoutExpired from ._compat import long if LINUX: # This is public API and it will be retrieved from _pslinux.py # via sys.modules. PROCFS_PATH = "/proc" from . import _pslinux as _psplatform from ._pslinux import IOPRIO_CLASS_BE # NOQA from ._pslinux import IOPRIO_CLASS_IDLE # NOQA from ._pslinux import IOPRIO_CLASS_NONE # NOQA from ._pslinux import IOPRIO_CLASS_RT # NOQA elif WINDOWS: from . import _pswindows as _psplatform from ._psutil_windows import ABOVE_NORMAL_PRIORITY_CLASS # NOQA from ._psutil_windows import BELOW_NORMAL_PRIORITY_CLASS # NOQA from ._psutil_windows import HIGH_PRIORITY_CLASS # NOQA from ._psutil_windows import IDLE_PRIORITY_CLASS # NOQA from ._psutil_windows import NORMAL_PRIORITY_CLASS # NOQA from ._psutil_windows import REALTIME_PRIORITY_CLASS # NOQA from ._pswindows import CONN_DELETE_TCB # NOQA from ._pswindows import IOPRIO_HIGH # NOQA from ._pswindows import IOPRIO_LOW # NOQA from ._pswindows import IOPRIO_NORMAL # NOQA from ._pswindows import IOPRIO_VERYLOW # NOQA elif MACOS: from . import _psosx as _psplatform elif BSD: from . import _psbsd as _psplatform elif SUNOS: from . import _pssunos as _psplatform from ._pssunos import CONN_BOUND # NOQA from ._pssunos import CONN_IDLE # NOQA # This is public writable API which is read from _pslinux.py and # _pssunos.py via sys.modules. PROCFS_PATH = "/proc" elif AIX: from . import _psaix as _psplatform # This is public API and it will be retrieved from _pslinux.py # via sys.modules. PROCFS_PATH = "/proc" else: # pragma: no cover raise NotImplementedError('platform %s is not supported' % sys.platform) __all__ = [ # exceptions "Error", "NoSuchProcess", "ZombieProcess", "AccessDenied", "TimeoutExpired", # constants "version_info", "__version__", "STATUS_RUNNING", "STATUS_IDLE", "STATUS_SLEEPING", "STATUS_DISK_SLEEP", "STATUS_STOPPED", "STATUS_TRACING_STOP", "STATUS_ZOMBIE", "STATUS_DEAD", "STATUS_WAKING", "STATUS_LOCKED", "STATUS_WAITING", "STATUS_LOCKED", "STATUS_PARKED", "CONN_ESTABLISHED", "CONN_SYN_SENT", "CONN_SYN_RECV", "CONN_FIN_WAIT1", "CONN_FIN_WAIT2", "CONN_TIME_WAIT", "CONN_CLOSE", "CONN_CLOSE_WAIT", "CONN_LAST_ACK", "CONN_LISTEN", "CONN_CLOSING", "CONN_NONE", # "CONN_IDLE", "CONN_BOUND", "AF_LINK", "NIC_DUPLEX_FULL", "NIC_DUPLEX_HALF", "NIC_DUPLEX_UNKNOWN", "POWER_TIME_UNKNOWN", "POWER_TIME_UNLIMITED", "BSD", "FREEBSD", "LINUX", "NETBSD", "OPENBSD", "MACOS", "OSX", "POSIX", "SUNOS", "WINDOWS", "AIX", # "RLIM_INFINITY", "RLIMIT_AS", "RLIMIT_CORE", "RLIMIT_CPU", "RLIMIT_DATA", # "RLIMIT_FSIZE", "RLIMIT_LOCKS", "RLIMIT_MEMLOCK", "RLIMIT_NOFILE", # "RLIMIT_NPROC", "RLIMIT_RSS", "RLIMIT_STACK", "RLIMIT_MSGQUEUE", # "RLIMIT_NICE", "RLIMIT_RTPRIO", "RLIMIT_RTTIME", "RLIMIT_SIGPENDING", # classes "Process", "Popen", # functions "pid_exists", "pids", "process_iter", "wait_procs", # proc "virtual_memory", "swap_memory", # memory "cpu_times", "cpu_percent", "cpu_times_percent", "cpu_count", # cpu "cpu_stats", # "cpu_freq", "getloadavg" "net_io_counters", "net_connections", "net_if_addrs", # network "net_if_stats", "disk_io_counters", "disk_partitions", "disk_usage", # disk # "sensors_temperatures", "sensors_battery", "sensors_fans" # sensors "users", "boot_time", # others ] __all__.extend(_psplatform.__extra__all__) # Linux, FreeBSD if hasattr(_psplatform.Process, "rlimit"): # Populate global namespace with RLIM* constants. from . import _psutil_posix _globals = globals() _name = None for _name in dir(_psutil_posix): if _name.startswith('RLIM') and _name.isupper(): _globals[_name] = getattr(_psutil_posix, _name) __all__.append(_name) del _globals, _name AF_LINK = _psplatform.AF_LINK __author__ = "Giampaolo Rodola'" __version__ = "5.9.5" version_info = tuple([int(num) for num in __version__.split('.')]) _timer = getattr(time, 'monotonic', time.time) _TOTAL_PHYMEM = None _LOWEST_PID = None _SENTINEL = object() # Sanity check in case the user messed up with psutil installation # or did something weird with sys.path. In this case we might end # up importing a python module using a C extension module which # was compiled for a different version of psutil. # We want to prevent that by failing sooner rather than later. # See: https://github.com/giampaolo/psutil/issues/564 if (int(__version__.replace('.', '')) != getattr(_psplatform.cext, 'version', None)): msg = "version conflict: %r C extension module was built for another " \ "version of psutil" % _psplatform.cext.__file__ if hasattr(_psplatform.cext, 'version'): msg += " (%s instead of %s)" % ( '.'.join([x for x in str(_psplatform.cext.version)]), __version__) else: msg += " (different than %s)" % __version__ msg += "; you may try to 'pip uninstall psutil', manually remove %s" % ( getattr(_psplatform.cext, "__file__", "the existing psutil install directory")) msg += " or clean the virtual env somehow, then reinstall" raise ImportError(msg) # ===================================================================== # --- Utils # ===================================================================== if hasattr(_psplatform, 'ppid_map'): # Faster version (Windows and Linux). _ppid_map = _psplatform.ppid_map else: # pragma: no cover def _ppid_map(): """Return a {pid: ppid, ...} dict for all running processes in one shot. Used to speed up Process.children(). """ ret = {} for pid in pids(): try: ret[pid] = _psplatform.Process(pid).ppid() except (NoSuchProcess, ZombieProcess): pass return ret def _assert_pid_not_reused(fun): """Decorator which raises NoSuchProcess in case a process is no longer running or its PID has been reused. """ @functools.wraps(fun) def wrapper(self, args, kwargs): if not self.is_running(): if self._pid_reused: msg = "process no longer exists and its PID has been reused" else: msg = None raise NoSuchProcess(self.pid, self._name, msg=msg) return fun(self, args, *kwargs) return wrapper def _pprint_secs(secs): """Format seconds in a human readable form.""" now = time.time() secs_ago = int(now - secs) if secs_ago < 60 60 * 24: fmt = "%H:%M:%S" else: fmt = "%Y-%m-%d %H:%M:%S" return datetime.datetime.fromtimestamp(secs).strftime(fmt) # ===================================================================== # --- Process class # ===================================================================== class Process(object): """Represents an OS process with the given PID. If PID is omitted current process PID (os.getpid()) is used. Raise NoSuchProcess if PID does not exist. Note that most of the methods of this class do not make sure the PID of the process being queried has been reused over time. That means you might end up retrieving an information referring to another process in case the original one this instance refers to is gone in the meantime. The only exceptions for which process identity is pre-emptively checked and guaranteed are: - parent() - children() - nice() (set) - ionice() (set) - rlimit() (set) - cpu_affinity (set) - suspend() - resume() - send_signal() - terminate() - kill() To prevent this problem for all other methods you can: - use is_running() before querying the process - if you're continuously iterating over a set of Process instances use process_iter() which pre-emptively checks process identity for every yielded instance """ def __init__(self, pid=None): self._init(pid) def _init(self, pid, _ignore_nsp=False): if pid is None: pid = os.getpid() else: if not _PY3 and not isinstance(pid, (int, long)): raise TypeError('pid must be an integer (got %r)' % pid) if pid < 0: raise ValueError('pid must be a positive integer (got %s)' % pid) self._pid = pid self._name = None self._exe = None self._create_time = None self._gone = False self._pid_reused = False self._hash = None self._lock = threading.RLock() # used for caching on Windows only (on POSIX ppid may change) self._ppid = None # platform-specific modules define an _psplatform.Process # implementation class self._proc = _psplatform.Process(pid) self._last_sys_cpu_times = None self._last_proc_cpu_times = None self._exitcode = _SENTINEL # cache creation time for later use in is_running() method try: self.create_time() except AccessDenied: # We should never get here as AFAIK we're able to get # process creation time on all platforms even as a # limited user. pass except ZombieProcess: # Zombies can still be queried by this class (although # not always) and pids() return them so just go on. pass except NoSuchProcess: if not _ignore_nsp: raise NoSuchProcess(pid, msg='process PID not found') else: self._gone = True # This pair is supposed to identify a Process instance # univocally over time (the PID alone is not enough as # it might refer to a process whose PID has been reused). # This will be used later in __eq__() and is_running(). self._ident = (self.pid, self._create_time) def __str__(self): info = collections.OrderedDict() info["pid"] = self.pid if self._name: info['name'] = self._name with self.oneshot(): try: info["name"] = self.name() info["status"] = self.status() except ZombieProcess: info["status"] = "zombie" except NoSuchProcess: info["status"] = "terminated" except AccessDenied: pass if self._exitcode not in (_SENTINEL, None): info["exitcode"] = self._exitcode if self._create_time: info['started'] = _pprint_secs(self._create_time) return "%s.%s(%s)" % ( self.__class__.__module__, self.__class__.__name__, ", ".join(["%s=%r" % (k, v) for k, v in info.items()])) __repr__ = __str__ def __eq__(self, other): # Test for equality with another Process object based # on PID and creation time. if not isinstance(other, Process): return NotImplemented return self._ident == other._ident def __ne__(self, other): return not self == other def __hash__(self): if self._hash is None: self._hash = hash(self._ident) return self._hash @property def pid(self): """The process PID.""" return self._pid # --- utility methods @contextlib.contextmanager def oneshot(self): """Utility context manager which considerably speeds up the retrieval of multiple process information at the same time. Internally different process info (e.g. name, ppid, uids, gids, ...) may be fetched by using the same routine, but only one information is returned and the others are discarded. When using this context manager the internal routine is executed once (in the example below on name()) and the other info are cached. The cache is cleared when exiting the context manager block. The advice is to use this every time you retrieve more than one information about the process. If you're lucky, you'll get a hell of a speedup. >>> import psutil >>> p = psutil.Process() >>> with p.oneshot(): ... p.name() # collect multiple info ... p.cpu_times() # return cached value ... p.cpu_percent() # return cached value ... p.create_time() # return cached value ... >>> """ with self._lock: if hasattr(self, "_cache"): # NOOP: this covers the use case where the user enters the # context twice: # # >>> with p.oneshot(): # ... with p.oneshot(): # ... # # Also, since as_dict() internally uses oneshot() # I expect that the code below will be a pretty common # "mistake" that the user will make, so let's guard # against that: # # >>> with p.oneshot(): # ... p.as_dict() # ... yield else: try: # cached in case cpu_percent() is used self.cpu_times.cache_activate(self) # cached in case memory_percent() is used self.memory_info.cache_activate(self) # cached in case parent() is used self.ppid.cache_activate(self) # cached in case username() is used if POSIX: self.uids.cache_activate(self) # specific implementation cache self._proc.oneshot_enter() yield finally: self.cpu_times.cache_deactivate(self) self.memory_info.cache_deactivate(self) self.ppid.cache_deactivate(self) if POSIX: self.uids.cache_deactivate(self) self._proc.oneshot_exit() def as_dict(self, attrs=None, ad_value=None): """Utility method returning process information as a hashable dictionary. If attrs is specified it must be a list of strings reflecting available Process class' attribute names (e.g. ['cpu_times', 'name']) else all public (read only) attributes are assumed. ad_value is the value which gets assigned in case AccessDenied or ZombieProcess exception is raised when retrieving that particular process information. """ valid_names = _as_dict_attrnames if attrs is not None: if not isinstance(attrs, (list, tuple, set, frozenset)): raise TypeError("invalid attrs type %s" % type(attrs)) attrs = set(attrs) invalid_names = attrs - valid_names if invalid_names: raise ValueError("invalid attr name%s %s" % ( "s" if len(invalid_names) > 1 else "", ", ".join(map(repr, invalid_names)))) retdict = {} ls = attrs or valid_names with self.oneshot(): for name in ls: try: if name == 'pid': ret = self.pid else: meth = getattr(self, name) ret = meth() except (AccessDenied, ZombieProcess): ret = ad_value except NotImplementedError: # in case of not implemented functionality (may happen # on old or exotic systems) we want to crash only if # the user explicitly asked for that particular attr if attrs: raise continue retdict[name] = ret return retdict def parent(self): """Return the parent process as a Process object pre-emptively checking whether PID has been reused. If no parent is known return None. """ lowest_pid = _LOWEST_PID if _LOWEST_PID is not None else pids()[0] if self.pid == lowest_pid: return None ppid = self.ppid() if ppid is not None: ctime = self.create_time() try: parent = Process(ppid) if parent.create_time() <= ctime: return parent # ...else ppid has been reused by another process except NoSuchProcess: pass def parents(self): """Return the parents of this process as a list of Process instances. If no parents are known return an empty list. """ parents = [] proc = self.parent() while proc is not None: parents.append(proc) proc = proc.parent() return parents def is_running(self): """Return whether this process is running. It also checks if PID has been reused by another process in which case return False. """ if self._gone or self._pid_reused: return False try: # Checking if PID is alive is not enough as the PID might # have been reused by another process: we also want to # verify process identity. # Process identity / uniqueness over time is guaranteed by # (PID + creation time) and that is verified in __eq__. self._pid_reused = self != Process(self.pid) return not self._pid_reused except ZombieProcess: # We should never get here as it's already handled in # Process.__init__; here just for extra safety. return True except NoSuchProcess: self._gone = True return False # --- actual API @memoize_when_activated def ppid(self): """The process parent PID. On Windows the return value is cached after first call. """ # On POSIX we don't want to cache the ppid as it may unexpectedly # change to 1 (init) in case this process turns into a zombie: # https://github.com/giampaolo/psutil/issues/321 # http://stackoverflow.com/questions/356722/ # XXX should we check creation time here rather than in # Process.parent()? if POSIX: return self._proc.ppid() else: # pragma: no cover self._ppid = self._ppid or self._proc.ppid() return self._ppid def name(self): """The process name. The return value is cached after first call.""" # Process name is only cached on Windows as on POSIX it may # change, see: # https://github.com/giampaolo/psutil/issues/692 if WINDOWS and self._name is not None: return self._name name = self._proc.name() if POSIX and len(name) >= 15: # On UNIX the name gets truncated to the first 15 characters. # If it matches the first part of the cmdline we return that # one instead because it's usually more explicative. # Examples are "gnome-keyring-d" vs. "gnome-keyring-daemon". try: cmdline = self.cmdline() except (AccessDenied, ZombieProcess): # Just pass and return the truncated name: it's better # than nothing. Note: there are actual cases where a # zombie process can return a name() but not a # cmdline(), see: # https://github.com/giampaolo/psutil/issues/2239 pass else: if cmdline: extended_name = os.path.basename(cmdline[0]) if extended_name.startswith(name): name = extended_name self._name = name self._proc._name = name return name def exe(self): """The process executable as an absolute path. May also be an empty string. The return value is cached after first call. """ def guess_it(fallback): # try to guess exe from cmdline[0] in absence of a native # exe representation cmdline = self.cmdline() if cmdline and hasattr(os, 'access') and hasattr(os, 'X_OK'): exe = cmdline[0] # the possible exe # Attempt to guess only in case of an absolute path. # It is not safe otherwise as the process might have # changed cwd. if (os.path.isabs(exe) and os.path.isfile(exe) and os.access(exe, os.X_OK)): return exe if isinstance(fallback, AccessDenied): raise fallback return fallback if self._exe is None: try: exe = self._proc.exe() except AccessDenied as err: return guess_it(fallback=err) else: if not exe: # underlying implementation can legitimately return an # empty string; if that's the case we don't want to # raise AD while guessing from the cmdline try: exe = guess_it(fallback=exe) except AccessDenied: pass self._exe = exe return self._exe def cmdline(self): """The command line this process has been called with.""" return self._proc.cmdline() def status(self): """The process current status as a STATUS_* constant.""" try: return self._proc.status() except ZombieProcess: return STATUS_ZOMBIE def username(self): """The name of the user that owns the process. On UNIX this is calculated by using real process uid. """ if POSIX: if pwd is None: # might happen if python was installed from sources raise ImportError( "requires pwd module shipped with standard python") real_uid = self.uids().real try: return pwd.getpwuid(real_uid).pw_name except KeyError: # the uid can't be resolved by the system return str(real_uid) else: return self._proc.username() def create_time(self): """The process creation time as a floating point number expressed in seconds since the epoch. The return value is cached after first call. """ if self._create_time is None: self._create_time = self._proc.create_time() return self._create_time def cwd(self): """Process current working directory as an absolute path.""" return self._proc.cwd() def nice(self, value=None): """Get or set process niceness (priority).""" if value is None: return self._proc.nice_get() else: if not self.is_running(): raise NoSuchProcess(self.pid, self._name) self._proc.nice_set(value) if POSIX: @memoize_when_activated def uids(self): """Return process UIDs as a (real, effective, saved) namedtuple. """ return self._proc.uids() def gids(self): """Return process GIDs as a (real, effective, saved) namedtuple. """ return self._proc.gids() def terminal(self): """The terminal associated with this process, if any, else None. """ return self._proc.terminal() def num_fds(self): """Return the number of file descriptors opened by this process (POSIX only). """ return self._proc.num_fds() # Linux, BSD, AIX and Windows only if hasattr(_psplatform.Process, "io_counters"): def io_counters(self): """Return process I/O statistics as a (read_count, write_count, read_bytes, write_bytes) namedtuple. Those are the number of read/write calls performed and the amount of bytes read and written by the process. """ return self._proc.io_counters() # Linux and Windows if hasattr(_psplatform.Process, "ionice_get"): def ionice(self, ioclass=None, value=None): """Get or set process I/O niceness (priority). On Linux ioclass is one of the IOPRIO_CLASS_* constants. value is a number which goes from 0 to 7. The higher the value, the lower the I/O priority of the process. On Windows only ioclass is used and it can be set to 2 (normal), 1 (low) or 0 (very low). Available on Linux and Windows > Vista only. """ if ioclass is None: if value is not None: raise ValueError("'ioclass' argument must be specified") return self._proc.ionice_get() else: return self._proc.ionice_set(ioclass, value) # Linux / FreeBSD only if hasattr(_psplatform.Process, "rlimit"): def rlimit(self, resource, limits=None): """Get or set process resource limits as a (soft, hard) tuple. resource is one of the RLIMIT_* constants. limits is supposed to be a (soft, hard) tuple. See "man prlimit" for further info. Available on Linux and FreeBSD only. """ return self._proc.rlimit(resource, limits) # Windows, Linux and FreeBSD only if hasattr(_psplatform.Process, "cpu_affinity_get"): def cpu_affinity(self, cpus=None): """Get or set process CPU affinity. If specified, cpus must be a list of CPUs for which you want to set the affinity (e.g. [0, 1]). If an empty list is passed, all egible CPUs are assumed (and set). (Windows, Linux and BSD only). """ if cpus is None: return sorted(set(self._proc.cpu_affinity_get())) else: if not cpus: if hasattr(self._proc, "_get_eligible_cpus"): cpus = self._proc._get_eligible_cpus() else: cpus = tuple(range(len(cpu_times(percpu=True)))) self._proc.cpu_affinity_set(list(set(cpus))) # Linux, FreeBSD, SunOS if hasattr(_psplatform.Process, "cpu_num"): def cpu_num(self): """Return what CPU this process is currently running on. The returned number should be <= psutil.cpu_count() and <= len(psutil.cpu_percent(percpu=True)). It may be used in conjunction with psutil.cpu_percent(percpu=True) to observe the system workload distributed across CPUs. """ return self._proc.cpu_num() # All platforms has it, but maybe not in the future. if hasattr(_psplatform.Process, "environ"): def environ(self): """The environment variables of the process as a dict. Note: this might not reflect changes made after the process started. """ return self._proc.environ() if WINDOWS: def num_handles(self): """Return the number of handles opened by this process (Windows only). """ return self._proc.num_handles() def num_ctx_switches(self): """Return the number of voluntary and involuntary context switches performed by this process. """ return self._proc.num_ctx_switches() def num_threads(self): """Return the number of threads used by this process.""" return self._proc.num_threads() if hasattr(_psplatform.Process, "threads"): def threads(self): """Return threads opened by process as a list of (id, user_time, system_time) namedtuples representing thread id and thread CPU times (user/system). On OpenBSD this method requires root access. """ return self._proc.threads() @_assert_pid_not_reused def children(self, recursive=False): """Return the children of this process as a list of Process instances, pre-emptively checking whether PID has been reused. If recursive is True return all the parent descendants. Example (A == this process): A ─┐ │ ├─ B (child) ─┐ │ └─ X (grandchild) ─┐ │ └─ Y (great grandchild) ├─ C (child) └─ D (child) >>> import psutil >>> p = psutil.Process() >>> p.children() B, C, D >>> p.children(recursive=True) B, X, Y, C, D Note that in the example above if process X disappears process Y won't be listed as the reference to process A is lost. """ ppid_map = _ppid_map() ret = [] if not recursive: for pid, ppid in ppid_map.items(): if ppid == self.pid: try: child = Process(pid) # if child happens to be older than its parent # (self) it means child's PID has been reused if self.create_time() <= child.create_time(): ret.append(child) except (NoSuchProcess, ZombieProcess): pass else: # Construct a {pid: [child pids]} dict reverse_ppid_map = collections.defaultdict(list) for pid, ppid in ppid_map.items(): reverse_ppid_map[ppid].append(pid) # Recursively traverse that dict, starting from self.pid, # such that we only call Process() on actual children seen = set() stack = [self.pid] while stack: pid = stack.pop() if pid in seen: # Since pids can be reused while the ppid_map is # constructed, there may be rare instances where # there's a cycle in the recorded process "tree". continue seen.add(pid) for child_pid in reverse_ppid_map[pid]: try: child = Process(child_pid) # if child happens to be older than its parent # (self) it means child's PID has been reused intime = self.create_time() <= child.create_time() if intime: ret.append(child) stack.append(child_pid) except (NoSuchProcess, ZombieProcess): pass return ret def cpu_percent(self, interval=None): """Return a float representing the current process CPU utilization as a percentage. When interval is 0.0 or None (default) compares process times to system CPU times elapsed since last call, returning immediately (non-blocking). That means that the first time this is called it will return a meaningful 0.0 value. When interval is > 0.0 compares process times to system CPU times elapsed before and after the interval (blocking). In this case is recommended for accuracy that this function be called with at least 0.1 seconds between calls. A value > 100.0 can be returned in case of processes running multiple threads on different CPU cores. The returned value is explicitly NOT split evenly between all available logical CPUs. This means that a busy loop process running on a system with 2 logical CPUs will be reported as having 100% CPU utilization instead of 50%. Examples: >>> import psutil >>> p = psutil.Process(os.getpid()) >>> # blocking >>> p.cpu_percent(interval=1) 2.0 >>> # non-blocking (percentage since last call) >>> p.cpu_percent(interval=None) 2.9 >>> """ blocking = interval is not None and interval > 0.0 if interval is not None and interval < 0: raise ValueError("interval is not positive (got %r)" % interval) num_cpus = cpu_count() or 1 def timer(): return _timer() * num_cpus if blocking: st1 = timer() pt1 = self._proc.cpu_times() time.sleep(interval) st2 = timer() pt2 = self._proc.cpu_times() else: st1 = self._last_sys_cpu_times pt1 = self._last_proc_cpu_times st2 = timer() pt2 = self._proc.cpu_times() if st1 is None or pt1 is None: self._last_sys_cpu_times = st2 self._last_proc_cpu_times = pt2 return 0.0 delta_proc = (pt2.user - pt1.user) + (pt2.system - pt1.system) delta_time = st2 - st1 # reset values for next call in case of interval == None self._last_sys_cpu_times = st2 self._last_proc_cpu_times = pt2 try: # This is the utilization split evenly between all CPUs. # E.g. a busy loop process on a 2-CPU-cores system at this # point is reported as 50% instead of 100%. overall_cpus_percent = ((delta_proc / delta_time) * 100) except ZeroDivisionError: # interval was too low return 0.0 else: # Note 1: # in order to emulate "top" we multiply the value for the num # of CPU cores. This way the busy process will be reported as # having 100% (or more) usage. # # Note 2: # taskmgr.exe on Windows differs in that it will show 50% # instead. # # Note 3: # a percentage > 100 is legitimate as it can result from a # process with multiple threads running on different CPU # cores (top does the same), see: # http://stackoverflow.com/questions/1032357 # https://github.com/giampaolo/psutil/issues/474 single_cpu_percent = overall_cpus_percent * num_cpus return round(single_cpu_percent, 1) @memoize_when_activated def cpu_times(self): """Return a (user, system, children_user, children_system) namedtuple representing the accumulated process time, in seconds. This is similar to os.times() but per-process. On macOS and Windows children_user and children_system are always set to 0. """ return self._proc.cpu_times() @memoize_when_activated def memory_info(self): """Return a namedtuple with variable fields depending on the platform, representing memory information about the process. The "portable" fields available on all platforms are `rss` and `vms`. All numbers are expressed in bytes. """ return self._proc.memory_info() @_common.deprecated_method(replacement="memory_info") def memory_info_ex(self): return self.memory_info() def memory_full_info(self): """This method returns the same information as memory_info(), plus, on some platform (Linux, macOS, Windows), also provides additional metrics (USS, PSS and swap). The additional metrics provide a better representation of actual process memory usage. Namely USS is the memory which is unique to a process and which would be freed if the process was terminated right now. It does so by passing through the whole process address. As such it usually requires higher user privileges than memory_info() and is considerably slower. """ return self._proc.memory_full_info() def memory_percent(self, memtype="rss"): """Compare process memory to total physical system memory and calculate process memory utilization as a percentage. memtype argument is a string that dictates what type of process memory you want to compare against (defaults to "rss"). The list of available strings can be obtained like this: >>> psutil.Process().memory_info()._fields ('rss', 'vms', 'shared', 'text', 'lib', 'data', 'dirty', 'uss', 'pss') """ valid_types = list(_psplatform.pfullmem._fields) if memtype not in valid_types: raise ValueError("invalid memtype %r; valid types are %r" % ( memtype, tuple(valid_types))) fun = self.memory_info if memtype in _psplatform.pmem._fields else \ self.memory_full_info metrics = fun() value = getattr(metrics, memtype) # use cached value if available total_phymem = _TOTAL_PHYMEM or virtual_memory().total if not total_phymem > 0: # we should never get here raise ValueError( "can't calculate process memory percent because " "total physical system memory is not positive (%r)" % total_phymem) return (value / float(total_phymem)) * 100 if hasattr(_psplatform.Process, "memory_maps"): def memory_maps(self, grouped=True): """Return process' mapped memory regions as a list of namedtuples whose fields are variable depending on the platform. If grouped is True the mapped regions with the same 'path' are grouped together and the different memory fields are summed. If grouped is False every mapped region is shown as a single entity and the namedtuple will also include the mapped region's address space ('addr') and permission set ('perms'). """ it = self._proc.memory_maps() if grouped: d = {} for tupl in it: path = tupl[2] nums = tupl[3:] try: d[path] = map(lambda x, y: x + y, d[path], nums) except KeyError: d[path] = nums nt = _psplatform.pmmap_grouped return [nt(path, d[path]) for path in d] # NOQA else: nt = _psplatform.pmmap_ext return [nt(x) for x in it] def open_files(self): """Return files opened by process as a list of (path, fd) namedtuples including the absolute file name and file descriptor number. """ return self._proc.open_files() def connections(self, kind='inet'): """Return socket connections opened by process as a list of (fd, family, type, laddr, raddr, status) namedtuples. The kind parameter filters for connections that match the following criteria: +------------+----------------------------------------------------+ \| Kind Value \| Connections using \| +------------+----------------------------------------------------+ \| inet \| IPv4 and IPv6 \| \| inet4 \| IPv4 \| \| inet6 \| IPv6 \| \| tcp \| TCP \| \| tcp4 \| TCP over IPv4 \| \| tcp6 \| TCP over IPv6 \| \| udp \| UDP \| \| udp4 \| UDP over IPv4 \| \| udp6 \| UDP over IPv6 \| \| unix \| UNIX socket (both UDP and TCP protocols) \| \| all \| the sum of all the possible families and protocols \| +------------+----------------------------------------------------+ """ return self._proc.connections(kind) # --- signals if POSIX: def _send_signal(self, sig): assert not self.pid < 0, self.pid if self.pid == 0: # see "man 2 kill" raise ValueError( "preventing sending signal to process with PID 0 as it " "would affect every process in the process group of the " "calling process (os.getpid()) instead of PID 0") try: os.kill(self.pid, sig) except ProcessLookupError: if OPENBSD and pid_exists(self.pid): # We do this because os.kill() lies in case of # zombie processes. raise ZombieProcess(self.pid, self._name, self._ppid) else: self._gone = True raise NoSuchProcess(self.pid, self._name) except PermissionError: raise AccessDenied(self.pid, self._name) @_assert_pid_not_reused def send_signal(self, sig): """Send a signal sig to process pre-emptively checking whether PID has been reused (see signal module constants) . On Windows only SIGTERM is valid and is treated as an alias for kill(). """ if POSIX: self._send_signal(sig) else: # pragma: no cover self._proc.send_signal(sig) @_assert_pid_not_reused def suspend(self): """Suspend process execution with SIGSTOP pre-emptively checking whether PID has been reused. On Windows this has the effect of suspending all process threads. """ if POSIX: self._send_signal(signal.SIGSTOP) else: # pragma: no cover self._proc.suspend() @_assert_pid_not_reused def resume(self): """Resume process execution with SIGCONT pre-emptively checking whether PID has been reused. On Windows this has the effect of resuming all process threads. """ if POSIX: self._send_signal(signal.SIGCONT) else: # pragma: no cover self._proc.resume() @_assert_pid_not_reused def terminate(self): """Terminate the process with SIGTERM pre-emptively checking whether PID has been reused. On Windows this is an alias for kill(). """ if POSIX: self._send_signal(signal.SIGTERM) else: # pragma: no cover self._proc.kill() @_assert_pid_not_reused def kill(self): """Kill the current process with SIGKILL pre-emptively checking whether PID has been reused. """ if POSIX: self._send_signal(signal.SIGKILL) else: # pragma: no cover self._proc.kill() def wait(self, timeout=None): """Wait for process to terminate and, if process is a children of os.getpid(), also return its exit code, else None. On Windows there's no such limitation (exit code is always returned). If the process is already terminated immediately return None instead of raising NoSuchProcess. If timeout (in seconds) is specified and process is still alive raise TimeoutExpired. To wait for multiple Process(es) use psutil.wait_procs(). """ if timeout is not None and not timeout >= 0: raise ValueError("timeout must be a positive integer") if self._exitcode is not _SENTINEL: return self._exitcode self._exitcode = self._proc.wait(timeout) return self._exitcode # The valid attr names which can be processed by Process.as_dict(). _as_dict_attrnames = set( [x for x in dir(Process) if not x.startswith('_') and x not in ['send_signal', 'suspend', 'resume', 'terminate', 'kill', 'wait', 'is_running', 'as_dict', 'parent', 'parents', 'children', 'rlimit', 'memory_info_ex', 'oneshot']]) # ===================================================================== # --- Popen class # ===================================================================== class Popen(Process): """Same as subprocess.Popen, but in addition it provides all psutil.Process methods in a single class. For the following methods which are common to both classes, psutil implementation takes precedence: * send_signal() * terminate() * kill() This is done in order to avoid killing another process in case its PID has been reused, fixing BPO-6973. >>> import psutil >>> from subprocess import PIPE >>> p = psutil.Popen(["python", "-c", "print 'hi'"], stdout=PIPE) >>> p.name() 'python' >>> p.uids() user(real=1000, effective=1000, saved=1000) >>> p.username() 'giampaolo' >>> p.communicate() ('hi\n', None) >>> p.terminate() >>> p.wait(timeout=2) 0 >>> """ def __init__(self, args, kwargs): # Explicitly avoid to raise NoSuchProcess in case the process # spawned by subprocess.Popen terminates too quickly, see: # https://github.com/giampaolo/psutil/issues/193 self.__subproc = subprocess.Popen(args, *kwargs) self._init(self.__subproc.pid, _ignore_nsp=True) def __dir__(self): return sorted(set(dir(Popen) + dir(subprocess.Popen))) def __enter__(self): if hasattr(self.__subproc, '__enter__'): self.__subproc.__enter__() return self def __exit__(self, args, *kwargs): if hasattr(self.__subproc, '__exit__'): return self.__subproc.__exit__(args, *kwargs) else: if self.stdout: self.stdout.close() if self.stderr: self.stderr.close() try: # Flushing a BufferedWriter may raise an error. if self.stdin: self.stdin.close() finally: # Wait for the process to terminate, to avoid zombies. self.wait() def __getattribute__(self, name): try: return object.__getattribute__(self, name) except AttributeError: try: return object.__getattribute__(self.__subproc, name) except AttributeError: raise AttributeError("%s instance has no attribute '%s'" % (self.__class__.__name__, name)) def wait(self, timeout=None): if self.__subproc.returncode is not None: return self.__subproc.returncode ret = super(Popen, self).wait(timeout) self.__subproc.returncode = ret return ret # ===================================================================== # --- system processes related functions # ===================================================================== def pids(): """Return a list of current running PIDs.""" global _LOWEST_PID ret = sorted(_psplatform.pids()) _LOWEST_PID = ret[0] return ret def pid_exists(pid): """Return True if given PID exists in the current process list. This is faster than doing "pid in psutil.pids()" and should be preferred. """ if pid < 0: return False elif pid == 0 and POSIX: # On POSIX we use os.kill() to determine PID existence. # According to "man 2 kill" PID 0 has a special meaning # though: it refers to <<every process in the process # group of the calling process>> and that is not we want # to do here. return pid in pids() else: return _psplatform.pid_exists(pid) _pmap = {} def process_iter(attrs=None, ad_value=None): """Return a generator yielding a Process instance for all running processes. Every new Process instance is only created once and then cached into an internal table which is updated every time this is used. Cached Process instances are checked for identity so that you're safe in case a PID has been reused by another process, in which case the cached instance is updated. The sorting order in which processes are yielded is based on their PIDs. attrs* and ad_value have the same meaning as in Process.as_dict(). If attrs is specified as_dict() is called and the resulting dict is stored as a 'info' attribute attached to returned Process instance. If attrs is an empty list it will retrieve all process info (slow). """ global _pmap def add(pid): proc = Process(pid) if attrs is not None: proc.info = proc.as_dict(attrs=attrs, ad_value=ad_value) pmap[proc.pid] = proc return proc def remove(pid): pmap.pop(pid, None) pmap = _pmap.copy() a = set(pids()) b = set(pmap.keys()) new_pids = a - b gone_pids = b - a for pid in gone_pids: remove(pid) try: ls = sorted(list(pmap.items()) + list(dict.fromkeys(new_pids).items())) for pid, proc in ls: try: if proc is None: # new process yield add(pid) else: # use is_running() to check whether PID has been # reused by another process in which case yield a # new Process instance if proc.is_running(): if attrs is not None: proc.info = proc.as_dict( attrs=attrs, ad_value=ad_value) yield proc else: yield add(pid) except NoSuchProcess: remove(pid) except AccessDenied: # Process creation time can't be determined hence there's # no way to tell whether the pid of the cached process # has been reused. Just return the cached version. if proc is None and pid in pmap: try: yield pmap[pid] except KeyError: # If we get here it is likely that 2 threads were # using process_iter(). pass else: raise finally: _pmap = pmap def wait_procs(procs, timeout=None, callback=None): """Convenience function which waits for a list of processes to terminate. Return a (gone, alive) tuple indicating which processes are gone and which ones are still alive. The gone ones will have a new returncode attribute indicating process exit status (may be None). callback is a function which gets called every time a process terminates (a Process instance is passed as callback argument). Function will return as soon as all processes terminate or when timeout occurs. Differently from Process.wait() it will not raise TimeoutExpired if timeout occurs. Typical use case is: - send SIGTERM to a list of processes - give them some time to terminate - send SIGKILL to those ones which are still alive Example: >>> def on_terminate(proc): ... print("process {} terminated".format(proc)) ... >>> for p in procs: ... p.terminate() ... >>> gone, alive = wait_procs(procs, timeout=3, callback=on_terminate) >>> for p in alive: ... p.kill() """ def check_gone(proc, timeout): try: returncode = proc.wait(timeout=timeout) except TimeoutExpired: pass except _SubprocessTimeoutExpired: pass else: if returncode is not None or not proc.is_running(): # Set new Process instance attribute. proc.returncode = returncode gone.add(proc) if callback is not None: callback(proc) if timeout is not None and not timeout >= 0: msg = "timeout must be a positive integer, got %s" % timeout raise ValueError(msg) gone = set() alive = set(procs) if callback is not None and not callable(callback): raise TypeError("callback %r is not a callable" % callable) if timeout is not None: deadline = _timer() + timeout while alive: if timeout is not None and timeout <= 0: break for proc in alive: # Make sure that every complete iteration (all processes) # will last max 1 sec. # We do this because we don't want to wait too long on a # single process: in case it terminates too late other # processes may disappear in the meantime and their PID # reused. max_timeout = 1.0 / len(alive) if timeout is not None: timeout = min((deadline - _timer()), max_timeout) if timeout <= 0: break check_gone(proc, timeout) else: check_gone(proc, max_timeout) alive = alive - gone if alive: # Last attempt over processes survived so far. # timeout == 0 won't make this function wait any further. for proc in alive: check_gone(proc, 0) alive = alive - gone return (list(gone), list(alive)) # ===================================================================== # --- CPU related functions # ===================================================================== def cpu_count(logical=True): """Return the number of logical CPUs in the system (same as os.cpu_count() in Python 3.4). If logical is False return the number of physical cores only (e.g. hyper thread CPUs are excluded). Return None if undetermined. The return value is cached after first call. If desired cache can be cleared like this: >>> psutil.cpu_count.cache_clear() """ if logical: ret = _psplatform.cpu_count_logical() else: ret = _psplatform.cpu_count_cores() if ret is not None and ret < 1: ret = None return ret def cpu_times(percpu=False): """Return system-wide CPU times as a namedtuple. Every CPU time represents the seconds the CPU has spent in the given mode. The namedtuple's fields availability varies depending on the platform: - user - system - idle - nice (UNIX) - iowait (Linux) - irq (Linux, FreeBSD) - softirq (Linux) - steal (Linux >= 2.6.11) - guest (Linux >= 2.6.24) - guest_nice (Linux >= 3.2.0) When percpu is True return a list of namedtuples for each CPU. First element of the list refers to first CPU, second element to second CPU and so on. The order of the list is consistent across calls. """ if not percpu: return _psplatform.cpu_times() else: return _psplatform.per_cpu_times() try: _last_cpu_times = cpu_times() except Exception: # Don't want to crash at import time. _last_cpu_times = None try: _last_per_cpu_times = cpu_times(percpu=True) except Exception: # Don't want to crash at import time. _last_per_cpu_times = None def _cpu_tot_time(times): """Given a cpu_time() ntuple calculates the total CPU time (including idle time). """ tot = sum(times) if LINUX: # On Linux guest times are already accounted in "user" or # "nice" times, so we subtract them from total. # Htop does the same. References: # https://github.com/giampaolo/psutil/pull/940 # http://unix.stackexchange.com/questions/178045 # https://github.com/torvalds/linux/blob/ # 447976ef4fd09b1be88b316d1a81553f1aa7cd07/kernel/sched/ # cputime.c#L158 tot -= getattr(times, "guest", 0) # Linux 2.6.24+ tot -= getattr(times, "guest_nice", 0) # Linux 3.2.0+ return tot def _cpu_busy_time(times): """Given a cpu_time() ntuple calculates the busy CPU time. We do so by subtracting all idle CPU times. """ busy = _cpu_tot_time(times) busy -= times.idle # Linux: "iowait" is time during which the CPU does not do anything # (waits for IO to complete). On Linux IO wait is not accounted # in "idle" time so we subtract it. Htop does the same. # References: # https://github.com/torvalds/linux/blob/ # 447976ef4fd09b1be88b316d1a81553f1aa7cd07/kernel/sched/cputime.c#L244 busy -= getattr(times, "iowait", 0) return busy def _cpu_times_deltas(t1, t2): assert t1._fields == t2._fields, (t1, t2) field_deltas = [] for field in _psplatform.scputimes._fields: field_delta = getattr(t2, field) - getattr(t1, field) # CPU times are always supposed to increase over time # or at least remain the same and that's because time # cannot go backwards. # Surprisingly sometimes this might not be the case (at # least on Windows and Linux), see: # https://github.com/giampaolo/psutil/issues/392 # https://github.com/giampaolo/psutil/issues/645 # https://github.com/giampaolo/psutil/issues/1210 # Trim negative deltas to zero to ignore decreasing fields. # top does the same. Reference: # https://gitlab.com/procps-ng/procps/blob/v3.3.12/top/top.c#L5063 field_delta = max(0, field_delta) field_deltas.append(field_delta) return _psplatform.scputimes(field_deltas) def cpu_percent(interval=None, percpu=False): """Return a float representing the current system-wide CPU utilization as a percentage. When interval* is > 0.0 compares system CPU times elapsed before and after the interval (blocking). When interval is 0.0 or None compares system CPU times elapsed since last call or module import, returning immediately (non blocking). That means the first time this is called it will return a meaningless 0.0 value which you should ignore. In this case is recommended for accuracy that this function be called with at least 0.1 seconds between calls. When percpu is True returns a list of floats representing the utilization as a percentage for each CPU. First element of the list refers to first CPU, second element to second CPU and so on. The order of the list is consistent across calls. Examples: >>> # blocking, system-wide >>> psutil.cpu_percent(interval=1) 2.0 >>> >>> # blocking, per-cpu >>> psutil.cpu_percent(interval=1, percpu=True) [2.0, 1.0] >>> >>> # non-blocking (percentage since last call) >>> psutil.cpu_percent(interval=None) 2.9 >>> """ global _last_cpu_times global _last_per_cpu_times blocking = interval is not None and interval > 0.0 if interval is not None and interval < 0: raise ValueError("interval is not positive (got %r)" % interval) def calculate(t1, t2): times_delta = _cpu_times_deltas(t1, t2) all_delta = _cpu_tot_time(times_delta) busy_delta = _cpu_busy_time(times_delta) try: busy_perc = (busy_delta / all_delta) * 100 except ZeroDivisionError: return 0.0 else: return round(busy_perc, 1) # system-wide usage if not percpu: if blocking: t1 = cpu_times() time.sleep(interval) else: t1 = _last_cpu_times if t1 is None: # Something bad happened at import time. We'll # get a meaningful result on the next call. See: # https://github.com/giampaolo/psutil/pull/715 t1 = cpu_times() _last_cpu_times = cpu_times() return calculate(t1, _last_cpu_times) # per-cpu usage else: ret = [] if blocking: tot1 = cpu_times(percpu=True) time.sleep(interval) else: tot1 = _last_per_cpu_times if tot1 is None: # Something bad happened at import time. We'll # get a meaningful result on the next call. See: # https://github.com/giampaolo/psutil/pull/715 tot1 = cpu_times(percpu=True) _last_per_cpu_times = cpu_times(percpu=True) for t1, t2 in zip(tot1, _last_per_cpu_times): ret.append(calculate(t1, t2)) return ret # Use separate global vars for cpu_times_percent() so that it's # independent from cpu_percent() and they can both be used within # the same program. _last_cpu_times_2 = _last_cpu_times _last_per_cpu_times_2 = _last_per_cpu_times def cpu_times_percent(interval=None, percpu=False): """Same as cpu_percent() but provides utilization percentages for each specific CPU time as is returned by cpu_times(). For instance, on Linux we'll get: >>> cpu_times_percent() cpupercent(user=4.8, nice=0.0, system=4.8, idle=90.5, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0) >>> interval and percpu arguments have the same meaning as in cpu_percent(). """ global _last_cpu_times_2 global _last_per_cpu_times_2 blocking = interval is not None and interval > 0.0 if interval is not None and interval < 0: raise ValueError("interval is not positive (got %r)" % interval) def calculate(t1, t2): nums = [] times_delta = _cpu_times_deltas(t1, t2) all_delta = _cpu_tot_time(times_delta) # "scale" is the value to multiply each delta with to get percentages. # We use "max" to avoid division by zero (if all_delta is 0, then all # fields are 0 so percentages will be 0 too. all_delta cannot be a # fraction because cpu times are integers) scale = 100.0 / max(1, all_delta) for field_delta in times_delta: field_perc = field_delta * scale field_perc = round(field_perc, 1) # make sure we don't return negative values or values over 100% field_perc = min(max(0.0, field_perc), 100.0) nums.append(field_perc) return _psplatform.scputimes(nums) # system-wide usage if not percpu: if blocking: t1 = cpu_times() time.sleep(interval) else: t1 = _last_cpu_times_2 if t1 is None: # Something bad happened at import time. We'll # get a meaningful result on the next call. See: # https://github.com/giampaolo/psutil/pull/715 t1 = cpu_times() _last_cpu_times_2 = cpu_times() return calculate(t1, _last_cpu_times_2) # per-cpu usage else: ret = [] if blocking: tot1 = cpu_times(percpu=True) time.sleep(interval) else: tot1 = _last_per_cpu_times_2 if tot1 is None: # Something bad happened at import time. We'll # get a meaningful result on the next call. See: # https://github.com/giampaolo/psutil/pull/715 tot1 = cpu_times(percpu=True) _last_per_cpu_times_2 = cpu_times(percpu=True) for t1, t2 in zip(tot1, _last_per_cpu_times_2): ret.append(calculate(t1, t2)) return ret def cpu_stats(): """Return CPU statistics.""" return _psplatform.cpu_stats() if hasattr(_psplatform, "cpu_freq"): def cpu_freq(percpu=False): """Return CPU frequency as a namedtuple including current, min and max frequency expressed in Mhz. If percpu* is True and the system supports per-cpu frequency retrieval (Linux only) a list of frequencies is returned for each CPU. If not a list with one element is returned. """ ret = _psplatform.cpu_freq() if percpu: return ret else: num_cpus = float(len(ret)) if num_cpus == 0: return None elif num_cpus == 1: return ret[0] else: currs, mins, maxs = 0.0, 0.0, 0.0 set_none = False for cpu in ret: currs += cpu.current # On Linux if /proc/cpuinfo is used min/max are set # to None. if LINUX and cpu.min is None: set_none = True continue mins += cpu.min maxs += cpu.max current = currs / num_cpus if set_none: min_ = max_ = None else: min_ = mins / num_cpus max_ = maxs / num_cpus return _common.scpufreq(current, min_, max_) __all__.append("cpu_freq") if hasattr(os, "getloadavg") or hasattr(_psplatform, "getloadavg"): # Perform this hasattr check once on import time to either use the # platform based code or proxy straight from the os module. if hasattr(os, "getloadavg"): getloadavg = os.getloadavg else: getloadavg = _psplatform.getloadavg __all__.append("getloadavg") # ===================================================================== # --- system memory related functions # ===================================================================== def virtual_memory(): """Return statistics about system memory usage as a namedtuple including the following fields, expressed in bytes: - total: total physical memory available. - available: the memory that can be given instantly to processes without the system going into swap. This is calculated by summing different memory values depending on the platform and it is supposed to be used to monitor actual memory usage in a cross platform fashion. - percent: the percentage usage calculated as (total - available) / total * 100 - used: memory used, calculated differently depending on the platform and designed for informational purposes only: macOS: active + wired BSD: active + wired + cached Linux: total - free - free: memory not being used at all (zeroed) that is readily available; note that this doesn't reflect the actual memory available (use 'available' instead) Platform-specific fields: - active (UNIX): memory currently in use or very recently used, and so it is in RAM. - inactive (UNIX): memory that is marked as not used. - buffers (BSD, Linux): cache for things like file system metadata. - cached (BSD, macOS): cache for various things. - wired (macOS, BSD): memory that is marked to always stay in RAM. It is never moved to disk. - shared (BSD): memory that may be simultaneously accessed by multiple processes. The sum of 'used' and 'available' does not necessarily equal total. On Windows 'available' and 'free' are the same. """ global _TOTAL_PHYMEM ret = _psplatform.virtual_memory() # cached for later use in Process.memory_percent() _TOTAL_PHYMEM = ret.total return ret def swap_memory(): """Return system swap memory statistics as a namedtuple including the following fields: - total: total swap memory in bytes - used: used swap memory in bytes - free: free swap memory in bytes - percent: the percentage usage - sin: no. of bytes the system has swapped in from disk (cumulative) - sout: no. of bytes the system has swapped out from disk (cumulative) 'sin' and 'sout' on Windows are meaningless and always set to 0. """ return _psplatform.swap_memory() # ===================================================================== # --- disks/paritions related functions # ===================================================================== def disk_usage(path): """Return disk usage statistics about the given path as a namedtuple including total, used and free space expressed in bytes plus the percentage usage. """ return _psplatform.disk_usage(path) def disk_partitions(all=False): """Return mounted partitions as a list of (device, mountpoint, fstype, opts) namedtuple. 'opts' field is a raw string separated by commas indicating mount options which may vary depending on the platform. If all parameter is False return physical devices only and ignore all others. """ def pathconf(path, name): try: return os.pathconf(path, name) except (OSError, AttributeError): pass ret = _psplatform.disk_partitions(all) if POSIX: new = [] for item in ret: nt = item._replace( maxfile=pathconf(item.mountpoint, 'PC_NAME_MAX'), maxpath=pathconf(item.mountpoint, 'PC_PATH_MAX')) new.append(nt) return new else: return ret def disk_io_counters(perdisk=False, nowrap=True): """Return system disk I/O statistics as a namedtuple including the following fields: - read_count: number of reads - write_count: number of writes - read_bytes: number of bytes read - write_bytes: number of bytes written - read_time: time spent reading from disk (in ms) - write_time: time spent writing to disk (in ms) Platform specific: - busy_time: (Linux, FreeBSD) time spent doing actual I/Os (in ms) - read_merged_count (Linux): number of merged reads - write_merged_count (Linux): number of merged writes If perdisk is True return the same information for every physical disk installed on the system as a dictionary with partition names as the keys and the namedtuple described above as the values. If nowrap is True it detects and adjust the numbers which overflow and wrap (restart from 0) and add "old value" to "new value" so that the returned numbers will always be increasing or remain the same, but never decrease. "disk_io_counters.cache_clear()" can be used to invalidate the cache. On recent Windows versions 'diskperf -y' command may need to be executed first otherwise this function won't find any disk. """ kwargs = dict(perdisk=perdisk) if LINUX else {} rawdict = _psplatform.disk_io_counters(*kwargs) if not rawdict: return {} if perdisk else None if nowrap: rawdict = _wrap_numbers(rawdict, 'psutil.disk_io_counters') nt = getattr(_psplatform, "sdiskio", _common.sdiskio) if perdisk: for disk, fields in rawdict.items(): rawdict[disk] = nt(fields) return rawdict else: return nt((sum(x) for x in zip(rawdict.values()))) disk_io_counters.cache_clear = functools.partial( _wrap_numbers.cache_clear, 'psutil.disk_io_counters') disk_io_counters.cache_clear.__doc__ = "Clears nowrap argument cache" # ===================================================================== # --- network related functions # ===================================================================== def net_io_counters(pernic=False, nowrap=True): """Return network I/O statistics as a namedtuple including the following fields: - bytes_sent: number of bytes sent - bytes_recv: number of bytes received - packets_sent: number of packets sent - packets_recv: number of packets received - errin: total number of errors while receiving - errout: total number of errors while sending - dropin: total number of incoming packets which were dropped - dropout: total number of outgoing packets which were dropped (always 0 on macOS and BSD) If pernic is True return the same information for every network interface installed on the system as a dictionary with network interface names as the keys and the namedtuple described above as the values. If nowrap is True it detects and adjust the numbers which overflow and wrap (restart from 0) and add "old value" to "new value" so that the returned numbers will always be increasing or remain the same, but never decrease. "disk_io_counters.cache_clear()" can be used to invalidate the cache. """ rawdict = _psplatform.net_io_counters() if not rawdict: return {} if pernic else None if nowrap: rawdict = _wrap_numbers(rawdict, 'psutil.net_io_counters') if pernic: for nic, fields in rawdict.items(): rawdict[nic] = _common.snetio(fields) return rawdict else: return _common.snetio([sum(x) for x in zip(rawdict.values())]) net_io_counters.cache_clear = functools.partial( _wrap_numbers.cache_clear, 'psutil.net_io_counters') net_io_counters.cache_clear.__doc__ = "Clears nowrap argument cache" def net_connections(kind='inet'): """Return system-wide socket connections as a list of (fd, family, type, laddr, raddr, status, pid) namedtuples. In case of limited privileges 'fd' and 'pid' may be set to -1 and None respectively. The kind* parameter filters for connections that fit the following criteria: +------------+----------------------------------------------------+ \| Kind Value \| Connections using \| +------------+----------------------------------------------------+ \| inet \| IPv4 and IPv6 \| \| inet4 \| IPv4 \| \| inet6 \| IPv6 \| \| tcp \| TCP \| \| tcp4 \| TCP over IPv4 \| \| tcp6 \| TCP over IPv6 \| \| udp \| UDP \| \| udp4 \| UDP over IPv4 \| \| udp6 \| UDP over IPv6 \| \| unix \| UNIX socket (both UDP and TCP protocols) \| \| all \| the sum of all the possible families and protocols \| +------------+----------------------------------------------------+ On macOS this function requires root privileges. """ return _psplatform.net_connections(kind) def net_if_addrs(): """Return the addresses associated to each NIC (network interface card) installed on the system as a dictionary whose keys are the NIC names and value is a list of namedtuples for each address assigned to the NIC. Each namedtuple includes 5 fields: - family: can be either socket.AF_INET, socket.AF_INET6 or psutil.AF_LINK, which refers to a MAC address. - address: is the primary address and it is always set. - netmask: and 'broadcast' and 'ptp' may be None. - ptp: stands for "point to point" and references the destination address on a point to point interface (typically a VPN). - broadcast: and ptp are mutually exclusive. Note: you can have more than one address of the same family associated with each interface. """ has_enums = sys.version_info >= (3, 4) if has_enums: import socket rawlist = _psplatform.net_if_addrs() rawlist.sort(key=lambda x: x[1]) # sort by family ret = collections.defaultdict(list) for name, fam, addr, mask, broadcast, ptp in rawlist: if has_enums: try: fam = socket.AddressFamily(fam) except ValueError: if WINDOWS and fam == -1: fam = _psplatform.AF_LINK elif (hasattr(_psplatform, "AF_LINK") and _psplatform.AF_LINK == fam): # Linux defines AF_LINK as an alias for AF_PACKET. # We re-set the family here so that repr(family) # will show AF_LINK rather than AF_PACKET fam = _psplatform.AF_LINK if fam == _psplatform.AF_LINK: # The underlying C function may return an incomplete MAC # address in which case we fill it with null bytes, see: # https://github.com/giampaolo/psutil/issues/786 separator = ":" if POSIX else "-" while addr.count(separator) < 5: addr += "%s00" % separator ret[name].append(_common.snicaddr(fam, addr, mask, broadcast, ptp)) return dict(ret) def net_if_stats(): """Return information about each NIC (network interface card) installed on the system as a dictionary whose keys are the NIC names and value is a namedtuple with the following fields: - isup: whether the interface is up (bool) - duplex: can be either NIC_DUPLEX_FULL, NIC_DUPLEX_HALF or NIC_DUPLEX_UNKNOWN - speed: the NIC speed expressed in mega bits (MB); if it can't be determined (e.g. 'localhost') it will be set to 0. - mtu: the maximum transmission unit expressed in bytes. """ return _psplatform.net_if_stats() # ===================================================================== # --- sensors # ===================================================================== # Linux, macOS if hasattr(_psplatform, "sensors_temperatures"): def sensors_temperatures(fahrenheit=False): """Return hardware temperatures. Each entry is a namedtuple representing a certain hardware sensor (it may be a CPU, an hard disk or something else, depending on the OS and its configuration). All temperatures are expressed in celsius unless fahrenheit is set to True. """ def convert(n): if n is not None: return (float(n) * 9 / 5) + 32 if fahrenheit else n ret = collections.defaultdict(list) rawdict = _psplatform.sensors_temperatures() for name, values in rawdict.items(): while values: label, current, high, critical = values.pop(0) current = convert(current) high = convert(high) critical = convert(critical) if high and not critical: critical = high elif critical and not high: high = critical ret[name].append( _common.shwtemp(label, current, high, critical)) return dict(ret) __all__.append("sensors_temperatures") # Linux if hasattr(_psplatform, "sensors_fans"): def sensors_fans(): """Return fans speed. Each entry is a namedtuple representing a certain hardware sensor. All speed are expressed in RPM (rounds per minute). """ return _psplatform.sensors_fans() __all__.append("sensors_fans") # Linux, Windows, FreeBSD, macOS if hasattr(_psplatform, "sensors_battery"): def sensors_battery(): """Return battery information. If no battery is installed returns None. - percent: battery power left as a percentage. - secsleft: a rough approximation of how many seconds are left before the battery runs out of power. May be POWER_TIME_UNLIMITED or POWER_TIME_UNLIMITED. - power_plugged: True if the AC power cable is connected. """ return _psplatform.sensors_battery() __all__.append("sensors_battery") # ===================================================================== # --- other system related functions # ===================================================================== def boot_time(): """Return the system boot time expressed in seconds since the epoch.""" # Note: we are not caching this because it is subject to # system clock updates. return _psplatform.boot_time() def users(): """Return users currently connected on the system as a list of namedtuples including the following fields. - user: the name of the user - terminal: the tty or pseudo-tty associated with the user, if any. - host: the host name associated with the entry, if any. - started: the creation time as a floating point number expressed in seconds since the epoch. """ return _psplatform.users() # ===================================================================== # --- Windows services # ===================================================================== if WINDOWS: def win_service_iter(): """Return a generator yielding a WindowsService instance for all Windows services installed. """ return _psplatform.win_service_iter() def win_service_get(name): """Get a Windows service by name. Raise NoSuchProcess if no service with such name exists. """ return _psplatform.win_service_get(name) # ===================================================================== def _set_debug(value): """Enable or disable PSUTIL_DEBUG option, which prints debugging messages to stderr. """ import psutil._common psutil._common.PSUTIL_DEBUG = bool(value) _psplatform.cext.set_debug(bool(value)) def test(): # pragma: no cover from ._common import bytes2human from ._compat import get_terminal_size today_day = datetime.date.today() templ = "%-10s %5s %5s %7s %7s %5s %6s %6s %6s %s" attrs = ['pid', 'memory_percent', 'name', 'cmdline', 'cpu_times', 'create_time', 'memory_info', 'status', 'nice', 'username'] print(templ % ("USER", "PID", "%MEM", "VSZ", "RSS", "NICE", # NOQA "STATUS", "START", "TIME", "CMDLINE")) for p in process_iter(attrs, ad_value=None): if p.info['create_time']: ctime = datetime.datetime.fromtimestamp(p.info['create_time']) if ctime.date() == today_day: ctime = ctime.strftime("%H:%M") else: ctime = ctime.strftime("%b%d") else: ctime = '' if p.info['cpu_times']: cputime = time.strftime("%M:%S", time.localtime(sum(p.info['cpu_times']))) else: cputime = '' user = p.info['username'] or '' if not user and POSIX: try: user = p.uids()[0] except Error: pass if user and WINDOWS and '\\' in user: user = user.split('\\')[1] user = user[:9] vms = bytes2human(p.info['memory_info'].vms) if \ p.info['memory_info'] is not None else '' rss = bytes2human(p.info['memory_info'].rss) if \ p.info['memory_info'] is not None else '' memp = round(p.info['memory_percent'], 1) if \ p.info['memory_percent'] is not None else '' nice = int(p.info['nice']) if p.info['nice'] else '' if p.info['cmdline']: cmdline = ' '.join(p.info['cmdline']) else: cmdline = p.info['name'] status = p.info['status'][:5] if p.info['status'] else '' line = templ % ( user[:10], p.info['pid'], memp, vms, rss, nice, status, ctime, cputime, cmdline) print(line[:get_terminal_size()[0]]) # NOQA del memoize_when_activated, division if sys.version_info[0] < 3: del num, x if __name__ == "__main__": test()	85.6 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 _common.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Common objects shared by __init__.py and _ps.py modules.""" # Note: this module is imported by setup.py so it should not import # psutil or third-party modules. from __future__ import division from __future__ import print_function import collections import contextlib import errno import functools import os import socket import stat import sys import threading import warnings from collections import namedtuple from socket import AF_INET from socket import SOCK_DGRAM from socket import SOCK_STREAM try: from socket import AF_INET6 except ImportError: AF_INET6 = None try: from socket import AF_UNIX except ImportError: AF_UNIX = None if sys.version_info >= (3, 4): import enum else: enum = None # can't take it from _common.py as this script is imported by setup.py PY3 = sys.version_info[0] == 3 PSUTIL_DEBUG = bool(os.getenv('PSUTIL_DEBUG')) _DEFAULT = object() __all__ = [ # OS constants 'FREEBSD', 'BSD', 'LINUX', 'NETBSD', 'OPENBSD', 'MACOS', 'OSX', 'POSIX', 'SUNOS', 'WINDOWS', # connection constants 'CONN_CLOSE', 'CONN_CLOSE_WAIT', 'CONN_CLOSING', 'CONN_ESTABLISHED', 'CONN_FIN_WAIT1', 'CONN_FIN_WAIT2', 'CONN_LAST_ACK', 'CONN_LISTEN', 'CONN_NONE', 'CONN_SYN_RECV', 'CONN_SYN_SENT', 'CONN_TIME_WAIT', # net constants 'NIC_DUPLEX_FULL', 'NIC_DUPLEX_HALF', 'NIC_DUPLEX_UNKNOWN', # process status constants 'STATUS_DEAD', 'STATUS_DISK_SLEEP', 'STATUS_IDLE', 'STATUS_LOCKED', 'STATUS_RUNNING', 'STATUS_SLEEPING', 'STATUS_STOPPED', 'STATUS_SUSPENDED', 'STATUS_TRACING_STOP', 'STATUS_WAITING', 'STATUS_WAKE_KILL', 'STATUS_WAKING', 'STATUS_ZOMBIE', 'STATUS_PARKED', # other constants 'ENCODING', 'ENCODING_ERRS', 'AF_INET6', # named tuples 'pconn', 'pcputimes', 'pctxsw', 'pgids', 'pio', 'pionice', 'popenfile', 'pthread', 'puids', 'sconn', 'scpustats', 'sdiskio', 'sdiskpart', 'sdiskusage', 'snetio', 'snicaddr', 'snicstats', 'sswap', 'suser', # utility functions 'conn_tmap', 'deprecated_method', 'isfile_strict', 'memoize', 'parse_environ_block', 'path_exists_strict', 'usage_percent', 'supports_ipv6', 'sockfam_to_enum', 'socktype_to_enum', "wrap_numbers", 'open_text', 'open_binary', 'cat', 'bcat', 'bytes2human', 'conn_to_ntuple', 'debug', # shell utils 'hilite', 'term_supports_colors', 'print_color', ] # =================================================================== # --- OS constants # =================================================================== POSIX = os.name == "posix" WINDOWS = os.name == "nt" LINUX = sys.platform.startswith("linux") MACOS = sys.platform.startswith("darwin") OSX = MACOS # deprecated alias FREEBSD = sys.platform.startswith(("freebsd", "midnightbsd")) OPENBSD = sys.platform.startswith("openbsd") NETBSD = sys.platform.startswith("netbsd") BSD = FREEBSD or OPENBSD or NETBSD SUNOS = sys.platform.startswith(("sunos", "solaris")) AIX = sys.platform.startswith("aix") # =================================================================== # --- API constants # =================================================================== # Process.status() STATUS_RUNNING = "running" STATUS_SLEEPING = "sleeping" STATUS_DISK_SLEEP = "disk-sleep" STATUS_STOPPED = "stopped" STATUS_TRACING_STOP = "tracing-stop" STATUS_ZOMBIE = "zombie" STATUS_DEAD = "dead" STATUS_WAKE_KILL = "wake-kill" STATUS_WAKING = "waking" STATUS_IDLE = "idle" # Linux, macOS, FreeBSD STATUS_LOCKED = "locked" # FreeBSD STATUS_WAITING = "waiting" # FreeBSD STATUS_SUSPENDED = "suspended" # NetBSD STATUS_PARKED = "parked" # Linux # Process.connections() and psutil.net_connections() CONN_ESTABLISHED = "ESTABLISHED" CONN_SYN_SENT = "SYN_SENT" CONN_SYN_RECV = "SYN_RECV" CONN_FIN_WAIT1 = "FIN_WAIT1" CONN_FIN_WAIT2 = "FIN_WAIT2" CONN_TIME_WAIT = "TIME_WAIT" CONN_CLOSE = "CLOSE" CONN_CLOSE_WAIT = "CLOSE_WAIT" CONN_LAST_ACK = "LAST_ACK" CONN_LISTEN = "LISTEN" CONN_CLOSING = "CLOSING" CONN_NONE = "NONE" # net_if_stats() if enum is None: NIC_DUPLEX_FULL = 2 NIC_DUPLEX_HALF = 1 NIC_DUPLEX_UNKNOWN = 0 else: class NicDuplex(enum.IntEnum): NIC_DUPLEX_FULL = 2 NIC_DUPLEX_HALF = 1 NIC_DUPLEX_UNKNOWN = 0 globals().update(NicDuplex.__members__) # sensors_battery() if enum is None: POWER_TIME_UNKNOWN = -1 POWER_TIME_UNLIMITED = -2 else: class BatteryTime(enum.IntEnum): POWER_TIME_UNKNOWN = -1 POWER_TIME_UNLIMITED = -2 globals().update(BatteryTime.__members__) # --- others ENCODING = sys.getfilesystemencoding() if not PY3: ENCODING_ERRS = "replace" else: try: ENCODING_ERRS = sys.getfilesystemencodeerrors() # py 3.6 except AttributeError: ENCODING_ERRS = "surrogateescape" if POSIX else "replace" # =================================================================== # --- namedtuples # =================================================================== # --- for system functions # psutil.swap_memory() sswap = namedtuple('sswap', ['total', 'used', 'free', 'percent', 'sin', 'sout']) # psutil.disk_usage() sdiskusage = namedtuple('sdiskusage', ['total', 'used', 'free', 'percent']) # psutil.disk_io_counters() sdiskio = namedtuple('sdiskio', ['read_count', 'write_count', 'read_bytes', 'write_bytes', 'read_time', 'write_time']) # psutil.disk_partitions() sdiskpart = namedtuple('sdiskpart', ['device', 'mountpoint', 'fstype', 'opts', 'maxfile', 'maxpath']) # psutil.net_io_counters() snetio = namedtuple('snetio', ['bytes_sent', 'bytes_recv', 'packets_sent', 'packets_recv', 'errin', 'errout', 'dropin', 'dropout']) # psutil.users() suser = namedtuple('suser', ['name', 'terminal', 'host', 'started', 'pid']) # psutil.net_connections() sconn = namedtuple('sconn', ['fd', 'family', 'type', 'laddr', 'raddr', 'status', 'pid']) # psutil.net_if_addrs() snicaddr = namedtuple('snicaddr', ['family', 'address', 'netmask', 'broadcast', 'ptp']) # psutil.net_if_stats() snicstats = namedtuple('snicstats', ['isup', 'duplex', 'speed', 'mtu', 'flags']) # psutil.cpu_stats() scpustats = namedtuple( 'scpustats', ['ctx_switches', 'interrupts', 'soft_interrupts', 'syscalls']) # psutil.cpu_freq() scpufreq = namedtuple('scpufreq', ['current', 'min', 'max']) # psutil.sensors_temperatures() shwtemp = namedtuple( 'shwtemp', ['label', 'current', 'high', 'critical']) # psutil.sensors_battery() sbattery = namedtuple('sbattery', ['percent', 'secsleft', 'power_plugged']) # psutil.sensors_fans() sfan = namedtuple('sfan', ['label', 'current']) # --- for Process methods # psutil.Process.cpu_times() pcputimes = namedtuple('pcputimes', ['user', 'system', 'children_user', 'children_system']) # psutil.Process.open_files() popenfile = namedtuple('popenfile', ['path', 'fd']) # psutil.Process.threads() pthread = namedtuple('pthread', ['id', 'user_time', 'system_time']) # psutil.Process.uids() puids = namedtuple('puids', ['real', 'effective', 'saved']) # psutil.Process.gids() pgids = namedtuple('pgids', ['real', 'effective', 'saved']) # psutil.Process.io_counters() pio = namedtuple('pio', ['read_count', 'write_count', 'read_bytes', 'write_bytes']) # psutil.Process.ionice() pionice = namedtuple('pionice', ['ioclass', 'value']) # psutil.Process.ctx_switches() pctxsw = namedtuple('pctxsw', ['voluntary', 'involuntary']) # psutil.Process.connections() pconn = namedtuple('pconn', ['fd', 'family', 'type', 'laddr', 'raddr', 'status']) # psutil.connections() and psutil.Process.connections() addr = namedtuple('addr', ['ip', 'port']) # =================================================================== # --- Process.connections() 'kind' parameter mapping # =================================================================== conn_tmap = { "all": ([AF_INET, AF_INET6, AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]), "tcp": ([AF_INET, AF_INET6], [SOCK_STREAM]), "tcp4": ([AF_INET], [SOCK_STREAM]), "udp": ([AF_INET, AF_INET6], [SOCK_DGRAM]), "udp4": ([AF_INET], [SOCK_DGRAM]), "inet": ([AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM]), "inet4": ([AF_INET], [SOCK_STREAM, SOCK_DGRAM]), "inet6": ([AF_INET6], [SOCK_STREAM, SOCK_DGRAM]), } if AF_INET6 is not None: conn_tmap.update({ "tcp6": ([AF_INET6], [SOCK_STREAM]), "udp6": ([AF_INET6], [SOCK_DGRAM]), }) if AF_UNIX is not None: conn_tmap.update({ "unix": ([AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]), }) # ===================================================================== # --- Exceptions # ===================================================================== class Error(Exception): """Base exception class. All other psutil exceptions inherit from this one. """ __module__ = 'psutil' def _infodict(self, attrs): info = collections.OrderedDict() for name in attrs: value = getattr(self, name, None) if value: info[name] = value elif name == "pid" and value == 0: info[name] = value return info def __str__(self): # invoked on `raise Error` info = self._infodict(("pid", "ppid", "name")) if info: details = "(%s)" % ", ".join( ["%s=%r" % (k, v) for k, v in info.items()]) else: details = None return " ".join([x for x in (getattr(self, "msg", ""), details) if x]) def __repr__(self): # invoked on `repr(Error)` info = self._infodict(("pid", "ppid", "name", "seconds", "msg")) details = ", ".join(["%s=%r" % (k, v) for k, v in info.items()]) return "psutil.%s(%s)" % (self.__class__.__name__, details) class NoSuchProcess(Error): """Exception raised when a process with a certain PID doesn't or no longer exists. """ __module__ = 'psutil' def __init__(self, pid, name=None, msg=None): Error.__init__(self) self.pid = pid self.name = name self.msg = msg or "process no longer exists" class ZombieProcess(NoSuchProcess): """Exception raised when querying a zombie process. This is raised on macOS, BSD and Solaris only, and not always: depending on the query the OS may be able to succeed anyway. On Linux all zombie processes are querable (hence this is never raised). Windows doesn't have zombie processes. """ __module__ = 'psutil' def __init__(self, pid, name=None, ppid=None, msg=None): NoSuchProcess.__init__(self, pid, name, msg) self.ppid = ppid self.msg = msg or "PID still exists but it's a zombie" class AccessDenied(Error): """Exception raised when permission to perform an action is denied.""" __module__ = 'psutil' def __init__(self, pid=None, name=None, msg=None): Error.__init__(self) self.pid = pid self.name = name self.msg = msg or "" class TimeoutExpired(Error): """Raised on Process.wait(timeout) if timeout expires and process is still alive. """ __module__ = 'psutil' def __init__(self, seconds, pid=None, name=None): Error.__init__(self) self.seconds = seconds self.pid = pid self.name = name self.msg = "timeout after %s seconds" % seconds # =================================================================== # --- utils # =================================================================== # This should be in _compat.py rather than here, but does not work well # with setup.py importing this module via a sys.path trick. if PY3: if isinstance(__builtins__, dict): # cpython exec_ = __builtins__["exec"] else: # pypy exec_ = getattr(__builtins__, "exec") # noqa exec_("""def raise_from(value, from_value): try: raise value from from_value finally: value = None """) else: def raise_from(value, from_value): raise value def usage_percent(used, total, round_=None): """Calculate percentage usage of 'used' against 'total'.""" try: ret = (float(used) / total) 100 except ZeroDivisionError: return 0.0 else: if round_ is not None: ret = round(ret, round_) return ret def memoize(fun): """A simple memoize decorator for functions supporting (hashable) positional arguments. It also provides a cache_clear() function for clearing the cache: >>> @memoize ... def foo() ... return 1 ... >>> foo() 1 >>> foo.cache_clear() >>> It supports: - functions - classes (acts as a @singleton) - staticmethods - classmethods It does NOT support: - methods """ @functools.wraps(fun) def wrapper(args, kwargs): key = (args, frozenset(sorted(kwargs.items()))) try: return cache[key] except KeyError: try: ret = cache[key] = fun(args, *kwargs) except Exception as err: raise raise_from(err, None) return ret def cache_clear(): """Clear cache.""" cache.clear() cache = {} wrapper.cache_clear = cache_clear return wrapper def memoize_when_activated(fun): """A memoize decorator which is disabled by default. It can be activated and deactivated on request. For efficiency reasons it can be used only against class methods accepting no arguments. >>> class Foo: ... @memoize ... def foo() ... print(1) ... >>> f = Foo() >>> # deactivated (default) >>> foo() 1 >>> foo() 1 >>> >>> # activated >>> foo.cache_activate(self) >>> foo() 1 >>> foo() >>> foo() >>> """ @functools.wraps(fun) def wrapper(self): try: # case 1: we previously entered oneshot() ctx ret = self._cache[fun] except AttributeError: # case 2: we never entered oneshot() ctx try: return fun(self) except Exception as err: raise raise_from(err, None) except KeyError: # case 3: we entered oneshot() ctx but there's no cache # for this entry yet try: ret = fun(self) except Exception as err: raise raise_from(err, None) try: self._cache[fun] = ret except AttributeError: # multi-threading race condition, see: # https://github.com/giampaolo/psutil/issues/1948 pass return ret def cache_activate(proc): """Activate cache. Expects a Process instance. Cache will be stored as a "_cache" instance attribute.""" proc._cache = {} def cache_deactivate(proc): """Deactivate and clear cache.""" try: del proc._cache except AttributeError: pass wrapper.cache_activate = cache_activate wrapper.cache_deactivate = cache_deactivate return wrapper def isfile_strict(path): """Same as os.path.isfile() but does not swallow EACCES / EPERM exceptions, see: http://mail.python.org/pipermail/python-dev/2012-June/120787.html """ try: st = os.stat(path) except OSError as err: if err.errno in (errno.EPERM, errno.EACCES): raise return False else: return stat.S_ISREG(st.st_mode) def path_exists_strict(path): """Same as os.path.exists() but does not swallow EACCES / EPERM exceptions, see: http://mail.python.org/pipermail/python-dev/2012-June/120787.html """ try: os.stat(path) except OSError as err: if err.errno in (errno.EPERM, errno.EACCES): raise return False else: return True @memoize def supports_ipv6(): """Return True if IPv6 is supported on this platform.""" if not socket.has_ipv6 or AF_INET6 is None: return False try: sock = socket.socket(AF_INET6, socket.SOCK_STREAM) with contextlib.closing(sock): sock.bind(("::1", 0)) return True except socket.error: return False def parse_environ_block(data): """Parse a C environ block of environment variables into a dictionary.""" # The block is usually raw data from the target process. It might contain # trailing garbage and lines that do not look like assignments. ret = {} pos = 0 # localize global variable to speed up access. WINDOWS_ = WINDOWS while True: next_pos = data.find("\0", pos) # nul byte at the beginning or double nul byte means finish if next_pos <= pos: break # there might not be an equals sign equal_pos = data.find("=", pos, next_pos) if equal_pos > pos: key = data[pos:equal_pos] value = data[equal_pos + 1:next_pos] # Windows expects environment variables to be uppercase only if WINDOWS_: key = key.upper() ret[key] = value pos = next_pos + 1 return ret def sockfam_to_enum(num): """Convert a numeric socket family value to an IntEnum member. If it's not a known member, return the numeric value itself. """ if enum is None: return num else: # pragma: no cover try: return socket.AddressFamily(num) except ValueError: return num def socktype_to_enum(num): """Convert a numeric socket type value to an IntEnum member. If it's not a known member, return the numeric value itself. """ if enum is None: return num else: # pragma: no cover try: return socket.SocketKind(num) except ValueError: return num def conn_to_ntuple(fd, fam, type_, laddr, raddr, status, status_map, pid=None): """Convert a raw connection tuple to a proper ntuple.""" if fam in (socket.AF_INET, AF_INET6): if laddr: laddr = addr(laddr) if raddr: raddr = addr(raddr) if type_ == socket.SOCK_STREAM and fam in (AF_INET, AF_INET6): status = status_map.get(status, CONN_NONE) else: status = CONN_NONE # ignore whatever C returned to us fam = sockfam_to_enum(fam) type_ = socktype_to_enum(type_) if pid is None: return pconn(fd, fam, type_, laddr, raddr, status) else: return sconn(fd, fam, type_, laddr, raddr, status, pid) def deprecated_method(replacement): """A decorator which can be used to mark a method as deprecated 'replcement' is the method name which will be called instead. """ def outer(fun): msg = "%s() is deprecated and will be removed; use %s() instead" % ( fun.__name__, replacement) if fun.__doc__ is None: fun.__doc__ = msg @functools.wraps(fun) def inner(self, args, *kwargs): warnings.warn(msg, category=DeprecationWarning, stacklevel=2) return getattr(self, replacement)(args, *kwargs) return inner return outer class _WrapNumbers: """Watches numbers so that they don't overflow and wrap (reset to zero). """ def __init__(self): self.lock = threading.Lock() self.cache = {} self.reminders = {} self.reminder_keys = {} def _add_dict(self, input_dict, name): assert name not in self.cache assert name not in self.reminders assert name not in self.reminder_keys self.cache[name] = input_dict self.reminders[name] = collections.defaultdict(int) self.reminder_keys[name] = collections.defaultdict(set) def _remove_dead_reminders(self, input_dict, name): """In case the number of keys changed between calls (e.g. a disk disappears) this removes the entry from self.reminders. """ old_dict = self.cache[name] gone_keys = set(old_dict.keys()) - set(input_dict.keys()) for gone_key in gone_keys: for remkey in self.reminder_keys[name][gone_key]: del self.reminders[name][remkey] del self.reminder_keys[name][gone_key] def run(self, input_dict, name): """Cache dict and sum numbers which overflow and wrap. Return an updated copy of `input_dict` """ if name not in self.cache: # This was the first call. self._add_dict(input_dict, name) return input_dict self._remove_dead_reminders(input_dict, name) old_dict = self.cache[name] new_dict = {} for key in input_dict.keys(): input_tuple = input_dict[key] try: old_tuple = old_dict[key] except KeyError: # The input dict has a new key (e.g. a new disk or NIC) # which didn't exist in the previous call. new_dict[key] = input_tuple continue bits = [] for i in range(len(input_tuple)): input_value = input_tuple[i] old_value = old_tuple[i] remkey = (key, i) if input_value < old_value: # it wrapped! self.reminders[name][remkey] += old_value self.reminder_keys[name][key].add(remkey) bits.append(input_value + self.reminders[name][remkey]) new_dict[key] = tuple(bits) self.cache[name] = input_dict return new_dict def cache_clear(self, name=None): """Clear the internal cache, optionally only for function 'name'.""" with self.lock: if name is None: self.cache.clear() self.reminders.clear() self.reminder_keys.clear() else: self.cache.pop(name, None) self.reminders.pop(name, None) self.reminder_keys.pop(name, None) def cache_info(self): """Return internal cache dicts as a tuple of 3 elements.""" with self.lock: return (self.cache, self.reminders, self.reminder_keys) def wrap_numbers(input_dict, name): """Given an `input_dict` and a function `name`, adjust the numbers which "wrap" (restart from zero) across different calls by adding "old value" to "new value" and return an updated dict. """ with _wn.lock: return _wn.run(input_dict, name) _wn = _WrapNumbers() wrap_numbers.cache_clear = _wn.cache_clear wrap_numbers.cache_info = _wn.cache_info # The read buffer size for open() builtin. This (also) dictates how # much data we read(2) when iterating over file lines as in: # >>> with open(file) as f: # ... for line in f: # ... ... # Default per-line buffer size for binary files is 1K. For text files # is 8K. We use a bigger buffer (32K) in order to have more consistent # results when reading /proc pseudo files on Linux, see: # https://github.com/giampaolo/psutil/issues/2050 # On Python 2 this also speeds up the reading of big files: # (namely /proc/{pid}/smaps and /proc/net/): # https://github.com/giampaolo/psutil/issues/708 FILE_READ_BUFFER_SIZE = 32 * 1024 def open_binary(fname): return open(fname, "rb", buffering=FILE_READ_BUFFER_SIZE) def open_text(fname): """On Python 3 opens a file in text mode by using fs encoding and a proper en/decoding errors handler. On Python 2 this is just an alias for open(name, 'rt'). """ if not PY3: return open(fname, "rt", buffering=FILE_READ_BUFFER_SIZE) # See: # https://github.com/giampaolo/psutil/issues/675 # https://github.com/giampaolo/psutil/pull/733 fobj = open(fname, "rt", buffering=FILE_READ_BUFFER_SIZE, encoding=ENCODING, errors=ENCODING_ERRS) try: # Dictates per-line read(2) buffer size. Defaults is 8k. See: # https://github.com/giampaolo/psutil/issues/2050#issuecomment-1013387546 fobj._CHUNK_SIZE = FILE_READ_BUFFER_SIZE except AttributeError: pass except Exception: fobj.close() raise return fobj def cat(fname, fallback=_DEFAULT, _open=open_text): """Read entire file content and return it as a string. File is opened in text mode. If specified, `fallback` is the value returned in case of error, either if the file does not exist or it can't be read(). """ if fallback is _DEFAULT: with _open(fname) as f: return f.read() else: try: with _open(fname) as f: return f.read() except (IOError, OSError): return fallback def bcat(fname, fallback=_DEFAULT): """Same as above but opens file in binary mode.""" return cat(fname, fallback=fallback, _open=open_binary) def bytes2human(n, format="%(value).1f%(symbol)s"): """Used by various scripts. See: http://goo.gl/zeJZl >>> bytes2human(10000) '9.8K' >>> bytes2human(100001221) '95.4M' """ symbols = ('B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y') prefix = {} for i, s in enumerate(symbols[1:]): prefix[s] = 1 << (i + 1) * 10 for symbol in reversed(symbols[1:]): if n >= prefix[symbol]: value = float(n) / prefix[symbol] return format % locals() return format % dict(symbol=symbols[0], value=n) def get_procfs_path(): """Return updated psutil.PROCFS_PATH constant.""" return sys.modules['psutil'].PROCFS_PATH if PY3: def decode(s): return s.decode(encoding=ENCODING, errors=ENCODING_ERRS) else: def decode(s): return s # ===================================================================== # --- shell utils # ===================================================================== @memoize def term_supports_colors(file=sys.stdout): # pragma: no cover if os.name == 'nt': return True try: import curses assert file.isatty() curses.setupterm() assert curses.tigetnum("colors") > 0 except Exception: return False else: return True def hilite(s, color=None, bold=False): # pragma: no cover """Return an highlighted version of 'string'.""" if not term_supports_colors(): return s attr = [] colors = dict(green='32', red='91', brown='33', yellow='93', blue='34', violet='35', lightblue='36', grey='37', darkgrey='30') colors[None] = '29' try: color = colors[color] except KeyError: raise ValueError("invalid color %r; choose between %s" % ( list(colors.keys()))) attr.append(color) if bold: attr.append('1') return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), s) def print_color( s, color=None, bold=False, file=sys.stdout): # pragma: no cover """Print a colorized version of string.""" if not term_supports_colors(): print(s, file=file) # NOQA elif POSIX: print(hilite(s, color, bold), file=file) # NOQA else: import ctypes DEFAULT_COLOR = 7 GetStdHandle = ctypes.windll.Kernel32.GetStdHandle SetConsoleTextAttribute = \ ctypes.windll.Kernel32.SetConsoleTextAttribute colors = dict(green=2, red=4, brown=6, yellow=6) colors[None] = DEFAULT_COLOR try: color = colors[color] except KeyError: raise ValueError("invalid color %r; choose between %r" % ( color, list(colors.keys()))) if bold and color <= 7: color += 8 handle_id = -12 if file is sys.stderr else -11 GetStdHandle.restype = ctypes.c_ulong handle = GetStdHandle(handle_id) SetConsoleTextAttribute(handle, color) try: print(s, file=file) # NOQA finally: SetConsoleTextAttribute(handle, DEFAULT_COLOR) def debug(msg): """If PSUTIL_DEBUG env var is set, print a debug message to stderr.""" if PSUTIL_DEBUG: import inspect fname, lineno, _, lines, index = inspect.getframeinfo( inspect.currentframe().f_back) if isinstance(msg, Exception): if isinstance(msg, (OSError, IOError, EnvironmentError)): # ...because str(exc) may contain info about the file name msg = "ignoring %s" % msg else: msg = "ignoring %r" % msg print("psutil-debug [%s:%s]> %s" % (fname, lineno, msg), # NOQA file=sys.stderr)	28.5 KB	2026-01-20 12:58
📄 _compat.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Module which provides compatibility with older Python versions. This is more future-compatible rather than the opposite (prefer latest Python 3 way of doing things). """ import collections import contextlib import errno import functools import os import sys import types __all__ = [ # constants "PY3", # builtins "long", "range", "super", "unicode", "basestring", # literals "u", "b", # collections module "lru_cache", # shutil module "which", "get_terminal_size", # contextlib module "redirect_stderr", # python 3 exceptions "FileNotFoundError", "PermissionError", "ProcessLookupError", "InterruptedError", "ChildProcessError", "FileExistsError"] PY3 = sys.version_info[0] == 3 _SENTINEL = object() if PY3: long = int xrange = range unicode = str basestring = str range = range def u(s): return s def b(s): return s.encode("latin-1") else: long = long range = xrange unicode = unicode basestring = basestring def u(s): return unicode(s, "unicode_escape") def b(s): return s # --- builtins # Python 3 super(). # Taken from "future" package. # Credit: Ryan Kelly if PY3: super = super else: _builtin_super = super def super(type_=_SENTINEL, type_or_obj=_SENTINEL, framedepth=1): """Like Python 3 builtin super(). If called without any arguments it attempts to infer them at runtime. """ if type_ is _SENTINEL: f = sys._getframe(framedepth) try: # Get the function's first positional argument. type_or_obj = f.f_locals[f.f_code.co_varnames[0]] except (IndexError, KeyError): raise RuntimeError('super() used in a function with no args') try: # Get the MRO so we can crawl it. mro = type_or_obj.__mro__ except (AttributeError, RuntimeError): try: mro = type_or_obj.__class__.__mro__ except AttributeError: raise RuntimeError('super() used in a non-newstyle class') for type_ in mro: # Find the class that owns the currently-executing method. for meth in type_.__dict__.values(): # Drill down through any wrappers to the underlying func. # This handles e.g. classmethod() and staticmethod(). try: while not isinstance(meth, types.FunctionType): if isinstance(meth, property): # Calling __get__ on the property will invoke # user code which might throw exceptions or # have side effects meth = meth.fget else: try: meth = meth.__func__ except AttributeError: meth = meth.__get__(type_or_obj, type_) except (AttributeError, TypeError): continue if meth.func_code is f.f_code: break # found else: # Not found. Move onto the next class in MRO. continue break # found else: raise RuntimeError('super() called outside a method') # Dispatch to builtin super(). if type_or_obj is not _SENTINEL: return _builtin_super(type_, type_or_obj) return _builtin_super(type_) # --- exceptions if PY3: FileNotFoundError = FileNotFoundError # NOQA PermissionError = PermissionError # NOQA ProcessLookupError = ProcessLookupError # NOQA InterruptedError = InterruptedError # NOQA ChildProcessError = ChildProcessError # NOQA FileExistsError = FileExistsError # NOQA else: # https://github.com/PythonCharmers/python-future/blob/exceptions/ # src/future/types/exceptions/pep3151.py import platform def _instance_checking_exception(base_exception=Exception): def wrapped(instance_checker): class TemporaryClass(base_exception): def __init__(self, args, kwargs): if len(args) == 1 and isinstance(args[0], TemporaryClass): unwrap_me = args[0] for attr in dir(unwrap_me): if not attr.startswith('__'): setattr(self, attr, getattr(unwrap_me, attr)) else: super(TemporaryClass, self).__init__(args, *kwargs) class __metaclass__(type): def __instancecheck__(cls, inst): return instance_checker(inst) def __subclasscheck__(cls, classinfo): value = sys.exc_info()[1] return isinstance(value, cls) TemporaryClass.__name__ = instance_checker.__name__ TemporaryClass.__doc__ = instance_checker.__doc__ return TemporaryClass return wrapped @_instance_checking_exception(EnvironmentError) def FileNotFoundError(inst): return getattr(inst, 'errno', _SENTINEL) == errno.ENOENT @_instance_checking_exception(EnvironmentError) def ProcessLookupError(inst): return getattr(inst, 'errno', _SENTINEL) == errno.ESRCH @_instance_checking_exception(EnvironmentError) def PermissionError(inst): return getattr(inst, 'errno', _SENTINEL) in ( errno.EACCES, errno.EPERM) @_instance_checking_exception(EnvironmentError) def InterruptedError(inst): return getattr(inst, 'errno', _SENTINEL) == errno.EINTR @_instance_checking_exception(EnvironmentError) def ChildProcessError(inst): return getattr(inst, 'errno', _SENTINEL) == errno.ECHILD @_instance_checking_exception(EnvironmentError) def FileExistsError(inst): return getattr(inst, 'errno', _SENTINEL) == errno.EEXIST if platform.python_implementation() != "CPython": try: raise OSError(errno.EEXIST, "perm") except FileExistsError: pass except OSError: raise RuntimeError( "broken or incompatible Python implementation, see: " "https://github.com/giampaolo/psutil/issues/1659") # --- stdlib additions # py 3.2 functools.lru_cache # Taken from: http://code.activestate.com/recipes/578078 # Credit: Raymond Hettinger try: from functools import lru_cache except ImportError: try: from threading import RLock except ImportError: from dummy_threading import RLock _CacheInfo = collections.namedtuple( "CacheInfo", ["hits", "misses", "maxsize", "currsize"]) class _HashedSeq(list): __slots__ = 'hashvalue' def __init__(self, tup, hash=hash): self[:] = tup self.hashvalue = hash(tup) def __hash__(self): return self.hashvalue def _make_key(args, kwds, typed, kwd_mark=(_SENTINEL, ), fasttypes=set((int, str, frozenset, type(None))), # noqa sorted=sorted, tuple=tuple, type=type, len=len): key = args if kwds: sorted_items = sorted(kwds.items()) key += kwd_mark for item in sorted_items: key += item if typed: key += tuple(type(v) for v in args) if kwds: key += tuple(type(v) for k, v in sorted_items) elif len(key) == 1 and type(key[0]) in fasttypes: return key[0] return _HashedSeq(key) def lru_cache(maxsize=100, typed=False): """Least-recently-used cache decorator, see: http://docs.python.org/3/library/functools.html#functools.lru_cache """ def decorating_function(user_function): cache = {} stats = [0, 0] HITS, MISSES = 0, 1 make_key = _make_key cache_get = cache.get _len = len lock = RLock() root = [] root[:] = [root, root, None, None] nonlocal_root = [root] PREV, NEXT, KEY, RESULT = 0, 1, 2, 3 if maxsize == 0: def wrapper(args, *kwds): result = user_function(args, *kwds) stats[MISSES] += 1 return result elif maxsize is None: def wrapper(args, *kwds): key = make_key(args, kwds, typed) result = cache_get(key, root) if result is not root: stats[HITS] += 1 return result result = user_function(args, *kwds) cache[key] = result stats[MISSES] += 1 return result else: def wrapper(args, *kwds): if kwds or typed: key = make_key(args, kwds, typed) else: key = args lock.acquire() try: link = cache_get(key) if link is not None: root, = nonlocal_root link_prev, link_next, key, result = link link_prev[NEXT] = link_next link_next[PREV] = link_prev last = root[PREV] last[NEXT] = root[PREV] = link link[PREV] = last link[NEXT] = root stats[HITS] += 1 return result finally: lock.release() result = user_function(args, **kwds) lock.acquire() try: root, = nonlocal_root if key in cache: pass elif _len(cache) >= maxsize: oldroot = root oldroot[KEY] = key oldroot[RESULT] = result root = nonlocal_root[0] = oldroot[NEXT] oldkey = root[KEY] root[KEY] = root[RESULT] = None del cache[oldkey] cache[key] = oldroot else: last = root[PREV] link = [last, root, key, result] last[NEXT] = root[PREV] = cache[key] = link stats[MISSES] += 1 finally: lock.release() return result def cache_info(): """Report cache statistics""" lock.acquire() try: return _CacheInfo(stats[HITS], stats[MISSES], maxsize, len(cache)) finally: lock.release() def cache_clear(): """Clear the cache and cache statistics""" lock.acquire() try: cache.clear() root = nonlocal_root[0] root[:] = [root, root, None, None] stats[:] = [0, 0] finally: lock.release() wrapper.__wrapped__ = user_function wrapper.cache_info = cache_info wrapper.cache_clear = cache_clear return functools.update_wrapper(wrapper, user_function) return decorating_function # python 3.3 try: from shutil import which except ImportError: def which(cmd, mode=os.F_OK \| os.X_OK, path=None): """Given a command, mode, and a PATH string, return the path which conforms to the given mode on the PATH, or None if there is no such file. `mode` defaults to os.F_OK \| os.X_OK. `path` defaults to the result of os.environ.get("PATH"), or can be overridden with a custom search path. """ def _access_check(fn, mode): return (os.path.exists(fn) and os.access(fn, mode) and not os.path.isdir(fn)) if os.path.dirname(cmd): if _access_check(cmd, mode): return cmd return None if path is None: path = os.environ.get("PATH", os.defpath) if not path: return None path = path.split(os.pathsep) if sys.platform == "win32": if os.curdir not in path: path.insert(0, os.curdir) pathext = os.environ.get("PATHEXT", "").split(os.pathsep) if any(cmd.lower().endswith(ext.lower()) for ext in pathext): files = [cmd] else: files = [cmd + ext for ext in pathext] else: files = [cmd] seen = set() for dir in path: normdir = os.path.normcase(dir) if normdir not in seen: seen.add(normdir) for thefile in files: name = os.path.join(dir, thefile) if _access_check(name, mode): return name return None # python 3.3 try: from shutil import get_terminal_size except ImportError: def get_terminal_size(fallback=(80, 24)): try: import fcntl import struct import termios except ImportError: return fallback else: try: # This should work on Linux. res = struct.unpack( 'hh', fcntl.ioctl(1, termios.TIOCGWINSZ, '1234')) return (res[1], res[0]) except Exception: return fallback # python 3.3 try: from subprocess import TimeoutExpired as SubprocessTimeoutExpired except ImportError: class SubprocessTimeoutExpired(Exception): pass # python 3.5 try: from contextlib import redirect_stderr except ImportError: @contextlib.contextmanager def redirect_stderr(new_target): original = sys.stderr try: sys.stderr = new_target yield new_target finally: sys.stderr = original	14.67 KB	2026-01-20 12:58
📄 _psaix.py # Copyright (c) 2009, Giampaolo Rodola' # Copyright (c) 2017, Arnon Yaari # All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """AIX platform implementation.""" import functools import glob import os import re import subprocess import sys from collections import namedtuple from . import _common from . import _psposix from . import _psutil_aix as cext from . import _psutil_posix as cext_posix from ._common import NIC_DUPLEX_FULL from ._common import NIC_DUPLEX_HALF from ._common import NIC_DUPLEX_UNKNOWN from ._common import AccessDenied from ._common import NoSuchProcess from ._common import ZombieProcess from ._common import conn_to_ntuple from ._common import get_procfs_path from ._common import memoize_when_activated from ._common import usage_percent from ._compat import PY3 from ._compat import FileNotFoundError from ._compat import PermissionError from ._compat import ProcessLookupError __extra__all__ = ["PROCFS_PATH"] # ===================================================================== # --- globals # ===================================================================== HAS_THREADS = hasattr(cext, "proc_threads") HAS_NET_IO_COUNTERS = hasattr(cext, "net_io_counters") HAS_PROC_IO_COUNTERS = hasattr(cext, "proc_io_counters") PAGE_SIZE = cext_posix.getpagesize() AF_LINK = cext_posix.AF_LINK PROC_STATUSES = { cext.SIDL: _common.STATUS_IDLE, cext.SZOMB: _common.STATUS_ZOMBIE, cext.SACTIVE: _common.STATUS_RUNNING, cext.SSWAP: _common.STATUS_RUNNING, # TODO what status is this? cext.SSTOP: _common.STATUS_STOPPED, } TCP_STATUSES = { cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT, cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT, cext.TCPS_CLOSED: _common.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK, cext.TCPS_LISTEN: _common.CONN_LISTEN, cext.TCPS_CLOSING: _common.CONN_CLOSING, cext.PSUTIL_CONN_NONE: _common.CONN_NONE, } proc_info_map = dict( ppid=0, rss=1, vms=2, create_time=3, nice=4, num_threads=5, status=6, ttynr=7) # ===================================================================== # --- named tuples # ===================================================================== # psutil.Process.memory_info() pmem = namedtuple('pmem', ['rss', 'vms']) # psutil.Process.memory_full_info() pfullmem = pmem # psutil.Process.cpu_times() scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait']) # psutil.virtual_memory() svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free']) # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): total, avail, free, pinned, inuse = cext.virtual_mem() percent = usage_percent((total - avail), total, round_=1) return svmem(total, avail, percent, inuse, free) def swap_memory(): """Swap system memory as a (total, used, free, sin, sout) tuple.""" total, free, sin, sout = cext.swap_mem() used = total - free percent = usage_percent(used, total, round_=1) return _common.sswap(total, used, free, percent, sin, sout) # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system-wide CPU times as a named tuple""" ret = cext.per_cpu_times() return scputimes([sum(x) for x in zip(ret)]) def per_cpu_times(): """Return system per-CPU times as a list of named tuples""" ret = cext.per_cpu_times() return [scputimes(x) for x in ret] def cpu_count_logical(): """Return the number of logical CPUs in the system.""" try: return os.sysconf("SC_NPROCESSORS_ONLN") except ValueError: # mimic os.cpu_count() behavior return None def cpu_count_cores(): cmd = "lsdev -Cc processor" p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate() if PY3: stdout, stderr = [x.decode(sys.stdout.encoding) for x in (stdout, stderr)] if p.returncode != 0: raise RuntimeError("%r command error\n%s" % (cmd, stderr)) processors = stdout.strip().splitlines() return len(processors) or None def cpu_stats(): """Return various CPU stats as a named tuple.""" ctx_switches, interrupts, soft_interrupts, syscalls = cext.cpu_stats() return _common.scpustats( ctx_switches, interrupts, soft_interrupts, syscalls) # ===================================================================== # --- disks # ===================================================================== disk_io_counters = cext.disk_io_counters disk_usage = _psposix.disk_usage def disk_partitions(all=False): """Return system disk partitions.""" # TODO - the filtering logic should be better checked so that # it tries to reflect 'df' as much as possible retlist = [] partitions = cext.disk_partitions() for partition in partitions: device, mountpoint, fstype, opts = partition if device == 'none': device = '' if not all: # Differently from, say, Linux, we don't have a list of # common fs types so the best we can do, AFAIK, is to # filter by filesystem having a total size > 0. if not disk_usage(mountpoint).total: continue maxfile = maxpath = None # set later ntuple = _common.sdiskpart(device, mountpoint, fstype, opts, maxfile, maxpath) retlist.append(ntuple) return retlist # ===================================================================== # --- network # ===================================================================== net_if_addrs = cext_posix.net_if_addrs if HAS_NET_IO_COUNTERS: net_io_counters = cext.net_io_counters def net_connections(kind, _pid=-1): """Return socket connections. If pid == -1 return system-wide connections (as opposed to connections opened by one process only). """ cmap = _common.conn_tmap if kind not in cmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in cmap]))) families, types = _common.conn_tmap[kind] rawlist = cext.net_connections(_pid) ret = [] for item in rawlist: fd, fam, type_, laddr, raddr, status, pid = item if fam not in families: continue if type_ not in types: continue nt = conn_to_ntuple(fd, fam, type_, laddr, raddr, status, TCP_STATUSES, pid=pid if _pid == -1 else None) ret.append(nt) return ret def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" duplex_map = {"Full": NIC_DUPLEX_FULL, "Half": NIC_DUPLEX_HALF} names = set([x[0] for x in net_if_addrs()]) ret = {} for name in names: mtu = cext_posix.net_if_mtu(name) flags = cext_posix.net_if_flags(name) # try to get speed and duplex # TODO: rewrite this in C (entstat forks, so use truss -f to follow. # looks like it is using an undocumented ioctl?) duplex = "" speed = 0 p = subprocess.Popen(["/usr/bin/entstat", "-d", name], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate() if PY3: stdout, stderr = [x.decode(sys.stdout.encoding) for x in (stdout, stderr)] if p.returncode == 0: re_result = re.search( r"Running: (\d+) Mbps.?(\w+) Duplex", stdout) if re_result is not None: speed = int(re_result.group(1)) duplex = re_result.group(2) output_flags = ','.join(flags) isup = 'running' in flags duplex = duplex_map.get(duplex, NIC_DUPLEX_UNKNOWN) ret[name] = _common.snicstats(isup, duplex, speed, mtu, output_flags) return ret # ===================================================================== # --- other system functions # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() def users(): """Return currently connected users as a list of namedtuples.""" retlist = [] rawlist = cext.users() localhost = (':0.0', ':0') for item in rawlist: user, tty, hostname, tstamp, user_process, pid = item # note: the underlying C function includes entries about # system boot, run level and others. We might want # to use them in the future. if not user_process: continue if hostname in localhost: hostname = 'localhost' nt = _common.suser(user, tty, hostname, tstamp, pid) retlist.append(nt) return retlist # ===================================================================== # --- processes # ===================================================================== def pids(): """Returns a list of PIDs currently running on the system.""" return [int(x) for x in os.listdir(get_procfs_path()) if x.isdigit()] def pid_exists(pid): """Check for the existence of a unix pid.""" return os.path.exists(os.path.join(get_procfs_path(), str(pid), "psinfo")) def wrap_exceptions(fun): """Call callable into a try/except clause and translate ENOENT, EACCES and EPERM in NoSuchProcess or AccessDenied exceptions. """ @functools.wraps(fun) def wrapper(self, args, kwargs): try: return fun(self, args, *kwargs) except (FileNotFoundError, ProcessLookupError): # ENOENT (no such file or directory) gets raised on open(). # ESRCH (no such process) can get raised on read() if # process is gone in meantime. if not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name) else: raise ZombieProcess(self.pid, self._name, self._ppid) except PermissionError: raise AccessDenied(self.pid, self._name) return wrapper class Process(object): """Wrapper class around underlying C implementation.""" __slots__ = ["pid", "_name", "_ppid", "_procfs_path", "_cache"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None self._procfs_path = get_procfs_path() def oneshot_enter(self): self._proc_basic_info.cache_activate(self) self._proc_cred.cache_activate(self) def oneshot_exit(self): self._proc_basic_info.cache_deactivate(self) self._proc_cred.cache_deactivate(self) @wrap_exceptions @memoize_when_activated def _proc_basic_info(self): return cext.proc_basic_info(self.pid, self._procfs_path) @wrap_exceptions @memoize_when_activated def _proc_cred(self): return cext.proc_cred(self.pid, self._procfs_path) @wrap_exceptions def name(self): if self.pid == 0: return "swapper" # note: max 16 characters return cext.proc_name(self.pid, self._procfs_path).rstrip("\x00") @wrap_exceptions def exe(self): # there is no way to get executable path in AIX other than to guess, # and guessing is more complex than what's in the wrapping class cmdline = self.cmdline() if not cmdline: return '' exe = cmdline[0] if os.path.sep in exe: # relative or absolute path if not os.path.isabs(exe): # if cwd has changed, we're out of luck - this may be wrong! exe = os.path.abspath(os.path.join(self.cwd(), exe)) if (os.path.isabs(exe) and os.path.isfile(exe) and os.access(exe, os.X_OK)): return exe # not found, move to search in PATH using basename only exe = os.path.basename(exe) # search for exe name PATH for path in os.environ["PATH"].split(":"): possible_exe = os.path.abspath(os.path.join(path, exe)) if (os.path.isfile(possible_exe) and os.access(possible_exe, os.X_OK)): return possible_exe return '' @wrap_exceptions def cmdline(self): return cext.proc_args(self.pid) @wrap_exceptions def environ(self): return cext.proc_environ(self.pid) @wrap_exceptions def create_time(self): return self._proc_basic_info()[proc_info_map['create_time']] @wrap_exceptions def num_threads(self): return self._proc_basic_info()[proc_info_map['num_threads']] if HAS_THREADS: @wrap_exceptions def threads(self): rawlist = cext.proc_threads(self.pid) retlist = [] for thread_id, utime, stime in rawlist: ntuple = _common.pthread(thread_id, utime, stime) retlist.append(ntuple) # The underlying C implementation retrieves all OS threads # and filters them by PID. At this point we can't tell whether # an empty list means there were no connections for process or # process is no longer active so we force NSP in case the PID # is no longer there. if not retlist: # will raise NSP if process is gone os.stat('%s/%s' % (self._procfs_path, self.pid)) return retlist @wrap_exceptions def connections(self, kind='inet'): ret = net_connections(kind, _pid=self.pid) # The underlying C implementation retrieves all OS connections # and filters them by PID. At this point we can't tell whether # an empty list means there were no connections for process or # process is no longer active so we force NSP in case the PID # is no longer there. if not ret: # will raise NSP if process is gone os.stat('%s/%s' % (self._procfs_path, self.pid)) return ret @wrap_exceptions def nice_get(self): return cext_posix.getpriority(self.pid) @wrap_exceptions def nice_set(self, value): return cext_posix.setpriority(self.pid, value) @wrap_exceptions def ppid(self): self._ppid = self._proc_basic_info()[proc_info_map['ppid']] return self._ppid @wrap_exceptions def uids(self): real, effective, saved, _, _, _ = self._proc_cred() return _common.puids(real, effective, saved) @wrap_exceptions def gids(self): _, _, _, real, effective, saved = self._proc_cred() return _common.puids(real, effective, saved) @wrap_exceptions def cpu_times(self): t = cext.proc_cpu_times(self.pid, self._procfs_path) return _common.pcputimes(t) @wrap_exceptions def terminal(self): ttydev = self._proc_basic_info()[proc_info_map['ttynr']] # convert from 64-bit dev_t to 32-bit dev_t and then map the device ttydev = (((ttydev & 0x0000FFFF00000000) >> 16) \| (ttydev & 0xFFFF)) # try to match rdev of /dev/pts/* files ttydev for dev in glob.glob("/dev/*/"): if os.stat(dev).st_rdev == ttydev: return dev return None @wrap_exceptions def cwd(self): procfs_path = self._procfs_path try: result = os.readlink("%s/%s/cwd" % (procfs_path, self.pid)) return result.rstrip('/') except FileNotFoundError: os.stat("%s/%s" % (procfs_path, self.pid)) # raise NSP or AD return "" @wrap_exceptions def memory_info(self): ret = self._proc_basic_info() rss = ret[proc_info_map['rss']] * 1024 vms = ret[proc_info_map['vms']] * 1024 return pmem(rss, vms) memory_full_info = memory_info @wrap_exceptions def status(self): code = self._proc_basic_info()[proc_info_map['status']] # XXX is '?' legit? (we're not supposed to return it anyway) return PROC_STATUSES.get(code, '?') def open_files(self): # TODO rewrite without using procfiles (stat /proc/pid/fd/* and then # find matching name of the inode) p = subprocess.Popen(["/usr/bin/procfiles", "-n", str(self.pid)], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate() if PY3: stdout, stderr = [x.decode(sys.stdout.encoding) for x in (stdout, stderr)] if "no such process" in stderr.lower(): raise NoSuchProcess(self.pid, self._name) procfiles = re.findall(r"(\d+): S_IFREG.\s.name:(.)\n", stdout) retlist = [] for fd, path in procfiles: path = path.strip() if path.startswith("//"): path = path[1:] if path.lower() == "cannot be retrieved": continue retlist.append(_common.popenfile(path, int(fd))) return retlist @wrap_exceptions def num_fds(self): if self.pid == 0: # no /proc/0/fd return 0 return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid))) @wrap_exceptions def num_ctx_switches(self): return _common.pctxsw( *cext.proc_num_ctx_switches(self.pid)) @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout, self._name) if HAS_PROC_IO_COUNTERS: @wrap_exceptions def io_counters(self): try: rc, wc, rb, wb = cext.proc_io_counters(self.pid) except OSError: # if process is terminated, proc_io_counters returns OSError # instead of NSP if not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name) raise return _common.pio(rc, wc, rb, wb)	18.23 KB	2026-01-20 12:58
📄 _psbsd.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """FreeBSD, OpenBSD and NetBSD platforms implementation.""" import contextlib import errno import functools import os import xml.etree.ElementTree as ET from collections import defaultdict from collections import namedtuple from . import _common from . import _psposix from . import _psutil_bsd as cext from . import _psutil_posix as cext_posix from ._common import FREEBSD from ._common import NETBSD from ._common import OPENBSD from ._common import AccessDenied from ._common import NoSuchProcess from ._common import ZombieProcess from ._common import conn_tmap from ._common import conn_to_ntuple from ._common import memoize from ._common import memoize_when_activated from ._common import usage_percent from ._compat import FileNotFoundError from ._compat import PermissionError from ._compat import ProcessLookupError from ._compat import which __extra__all__ = [] # ===================================================================== # --- globals # ===================================================================== if FREEBSD: PROC_STATUSES = { cext.SIDL: _common.STATUS_IDLE, cext.SRUN: _common.STATUS_RUNNING, cext.SSLEEP: _common.STATUS_SLEEPING, cext.SSTOP: _common.STATUS_STOPPED, cext.SZOMB: _common.STATUS_ZOMBIE, cext.SWAIT: _common.STATUS_WAITING, cext.SLOCK: _common.STATUS_LOCKED, } elif OPENBSD: PROC_STATUSES = { cext.SIDL: _common.STATUS_IDLE, cext.SSLEEP: _common.STATUS_SLEEPING, cext.SSTOP: _common.STATUS_STOPPED, # According to /usr/include/sys/proc.h SZOMB is unused. # test_zombie_process() shows that SDEAD is the right # equivalent. Also it appears there's no equivalent of # psutil.STATUS_DEAD. SDEAD really means STATUS_ZOMBIE. # cext.SZOMB: _common.STATUS_ZOMBIE, cext.SDEAD: _common.STATUS_ZOMBIE, cext.SZOMB: _common.STATUS_ZOMBIE, # From http://www.eecs.harvard.edu/~margo/cs161/videos/proc.h.txt # OpenBSD has SRUN and SONPROC: SRUN indicates that a process # is runnable but not yet running, i.e. is on a run queue. # SONPROC indicates that the process is actually executing on # a CPU, i.e. it is no longer on a run queue. # As such we'll map SRUN to STATUS_WAKING and SONPROC to # STATUS_RUNNING cext.SRUN: _common.STATUS_WAKING, cext.SONPROC: _common.STATUS_RUNNING, } elif NETBSD: PROC_STATUSES = { cext.SIDL: _common.STATUS_IDLE, cext.SSLEEP: _common.STATUS_SLEEPING, cext.SSTOP: _common.STATUS_STOPPED, cext.SZOMB: _common.STATUS_ZOMBIE, cext.SRUN: _common.STATUS_WAKING, cext.SONPROC: _common.STATUS_RUNNING, } TCP_STATUSES = { cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT, cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT, cext.TCPS_CLOSED: _common.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK, cext.TCPS_LISTEN: _common.CONN_LISTEN, cext.TCPS_CLOSING: _common.CONN_CLOSING, cext.PSUTIL_CONN_NONE: _common.CONN_NONE, } PAGESIZE = cext_posix.getpagesize() AF_LINK = cext_posix.AF_LINK HAS_PER_CPU_TIMES = hasattr(cext, "per_cpu_times") HAS_PROC_NUM_THREADS = hasattr(cext, "proc_num_threads") HAS_PROC_OPEN_FILES = hasattr(cext, 'proc_open_files') HAS_PROC_NUM_FDS = hasattr(cext, 'proc_num_fds') kinfo_proc_map = dict( ppid=0, status=1, real_uid=2, effective_uid=3, saved_uid=4, real_gid=5, effective_gid=6, saved_gid=7, ttynr=8, create_time=9, ctx_switches_vol=10, ctx_switches_unvol=11, read_io_count=12, write_io_count=13, user_time=14, sys_time=15, ch_user_time=16, ch_sys_time=17, rss=18, vms=19, memtext=20, memdata=21, memstack=22, cpunum=23, name=24, ) # ===================================================================== # --- named tuples # ===================================================================== # psutil.virtual_memory() svmem = namedtuple( 'svmem', ['total', 'available', 'percent', 'used', 'free', 'active', 'inactive', 'buffers', 'cached', 'shared', 'wired']) # psutil.cpu_times() scputimes = namedtuple( 'scputimes', ['user', 'nice', 'system', 'idle', 'irq']) # psutil.Process.memory_info() pmem = namedtuple('pmem', ['rss', 'vms', 'text', 'data', 'stack']) # psutil.Process.memory_full_info() pfullmem = pmem # psutil.Process.cpu_times() pcputimes = namedtuple('pcputimes', ['user', 'system', 'children_user', 'children_system']) # psutil.Process.memory_maps(grouped=True) pmmap_grouped = namedtuple( 'pmmap_grouped', 'path rss, private, ref_count, shadow_count') # psutil.Process.memory_maps(grouped=False) pmmap_ext = namedtuple( 'pmmap_ext', 'addr, perms path rss, private, ref_count, shadow_count') # psutil.disk_io_counters() if FREEBSD: sdiskio = namedtuple('sdiskio', ['read_count', 'write_count', 'read_bytes', 'write_bytes', 'read_time', 'write_time', 'busy_time']) else: sdiskio = namedtuple('sdiskio', ['read_count', 'write_count', 'read_bytes', 'write_bytes']) # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): mem = cext.virtual_mem() if NETBSD: total, free, active, inactive, wired, cached = mem # On NetBSD buffers and shared mem is determined via /proc. # The C ext set them to 0. with open('/proc/meminfo', 'rb') as f: for line in f: if line.startswith(b'Buffers:'): buffers = int(line.split()[1]) * 1024 elif line.startswith(b'MemShared:'): shared = int(line.split()[1]) * 1024 # Before avail was calculated as (inactive + cached + free), # same as zabbix, but it turned out it could exceed total (see # #2233), so zabbix seems to be wrong. Htop calculates it # differently, and the used value seem more realistic, so let's # match htop. # https://github.com/htop-dev/htop/blob/e7f447b/netbsd/NetBSDProcessList.c#L162 # noqa # https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/zbxsysinfo/netbsd/memory.c#L135 # noqa used = active + wired avail = total - used else: total, free, active, inactive, wired, cached, buffers, shared = mem # matches freebsd-memory CLI: # * https://people.freebsd.org/~rse/dist/freebsd-memory # * https://www.cyberciti.biz/files/scripts/freebsd-memory.pl.txt # matches zabbix: # * https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/zbxsysinfo/freebsd/memory.c#L143 # noqa avail = inactive + cached + free used = active + wired + cached percent = usage_percent((total - avail), total, round_=1) return svmem(total, avail, percent, used, free, active, inactive, buffers, cached, shared, wired) def swap_memory(): """System swap memory as (total, used, free, sin, sout) namedtuple.""" total, used, free, sin, sout = cext.swap_mem() percent = usage_percent(used, total, round_=1) return _common.sswap(total, used, free, percent, sin, sout) # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system per-CPU times as a namedtuple""" user, nice, system, idle, irq = cext.cpu_times() return scputimes(user, nice, system, idle, irq) if HAS_PER_CPU_TIMES: def per_cpu_times(): """Return system CPU times as a namedtuple""" ret = [] for cpu_t in cext.per_cpu_times(): user, nice, system, idle, irq = cpu_t item = scputimes(user, nice, system, idle, irq) ret.append(item) return ret else: # XXX # Ok, this is very dirty. # On FreeBSD < 8 we cannot gather per-cpu information, see: # https://github.com/giampaolo/psutil/issues/226 # If num cpus > 1, on first call we return single cpu times to avoid a # crash at psutil import time. # Next calls will fail with NotImplementedError def per_cpu_times(): """Return system CPU times as a namedtuple""" if cpu_count_logical() == 1: return [cpu_times()] if per_cpu_times.__called__: raise NotImplementedError("supported only starting from FreeBSD 8") per_cpu_times.__called__ = True return [cpu_times()] per_cpu_times.__called__ = False def cpu_count_logical(): """Return the number of logical CPUs in the system.""" return cext.cpu_count_logical() if OPENBSD or NETBSD: def cpu_count_cores(): # OpenBSD and NetBSD do not implement this. return 1 if cpu_count_logical() == 1 else None else: def cpu_count_cores(): """Return the number of CPU cores in the system.""" # From the C module we'll get an XML string similar to this: # http://manpages.ubuntu.com/manpages/precise/man4/smp.4freebsd.html # We may get None in case "sysctl kern.sched.topology_spec" # is not supported on this BSD version, in which case we'll mimic # os.cpu_count() and return None. ret = None s = cext.cpu_topology() if s is not None: # get rid of padding chars appended at the end of the string index = s.rfind("</groups>") if index != -1: s = s[:index + 9] root = ET.fromstring(s) try: ret = len(root.findall('group/children/group/cpu')) or None finally: # needed otherwise it will memleak root.clear() if not ret: # If logical CPUs == 1 it's obvious we' have only 1 core. if cpu_count_logical() == 1: return 1 return ret def cpu_stats(): """Return various CPU stats as a named tuple.""" if FREEBSD: # Note: the C ext is returning some metrics we are not exposing: # traps. ctxsw, intrs, soft_intrs, syscalls, traps = cext.cpu_stats() elif NETBSD: # XXX # Note about intrs: the C extension returns 0. intrs # can be determined via /proc/stat; it has the same value as # soft_intrs thought so the kernel is faking it (?). # # Note about syscalls: the C extension always sets it to 0 (?). # # Note: the C ext is returning some metrics we are not exposing: # traps, faults and forks. ctxsw, intrs, soft_intrs, syscalls, traps, faults, forks = \ cext.cpu_stats() with open('/proc/stat', 'rb') as f: for line in f: if line.startswith(b'intr'): intrs = int(line.split()[1]) elif OPENBSD: # Note: the C ext is returning some metrics we are not exposing: # traps, faults and forks. ctxsw, intrs, soft_intrs, syscalls, traps, faults, forks = \ cext.cpu_stats() return _common.scpustats(ctxsw, intrs, soft_intrs, syscalls) if FREEBSD: def cpu_freq(): """Return frequency metrics for CPUs. As of Dec 2018 only CPU 0 appears to be supported by FreeBSD and all other cores match the frequency of CPU 0. """ ret = [] num_cpus = cpu_count_logical() for cpu in range(num_cpus): try: current, available_freq = cext.cpu_freq(cpu) except NotImplementedError: continue if available_freq: try: min_freq = int(available_freq.split(" ")[-1].split("/")[0]) except (IndexError, ValueError): min_freq = None try: max_freq = int(available_freq.split(" ")[0].split("/")[0]) except (IndexError, ValueError): max_freq = None ret.append(_common.scpufreq(current, min_freq, max_freq)) return ret elif OPENBSD: def cpu_freq(): curr = float(cext.cpu_freq()) return [_common.scpufreq(curr, 0.0, 0.0)] # ===================================================================== # --- disks # ===================================================================== def disk_partitions(all=False): """Return mounted disk partitions as a list of namedtuples. 'all' argument is ignored, see: https://github.com/giampaolo/psutil/issues/906 """ retlist = [] partitions = cext.disk_partitions() for partition in partitions: device, mountpoint, fstype, opts = partition maxfile = maxpath = None # set later ntuple = _common.sdiskpart(device, mountpoint, fstype, opts, maxfile, maxpath) retlist.append(ntuple) return retlist disk_usage = _psposix.disk_usage disk_io_counters = cext.disk_io_counters # ===================================================================== # --- network # ===================================================================== net_io_counters = cext.net_io_counters net_if_addrs = cext_posix.net_if_addrs def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" names = net_io_counters().keys() ret = {} for name in names: try: mtu = cext_posix.net_if_mtu(name) flags = cext_posix.net_if_flags(name) duplex, speed = cext_posix.net_if_duplex_speed(name) except OSError as err: # https://github.com/giampaolo/psutil/issues/1279 if err.errno != errno.ENODEV: raise else: if hasattr(_common, 'NicDuplex'): duplex = _common.NicDuplex(duplex) output_flags = ','.join(flags) isup = 'running' in flags ret[name] = _common.snicstats(isup, duplex, speed, mtu, output_flags) return ret def net_connections(kind): """System-wide network connections.""" if kind not in _common.conn_tmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in conn_tmap]))) families, types = conn_tmap[kind] ret = set() if OPENBSD: rawlist = cext.net_connections(-1, families, types) elif NETBSD: rawlist = cext.net_connections(-1) else: # FreeBSD rawlist = cext.net_connections() for item in rawlist: fd, fam, type, laddr, raddr, status, pid = item if NETBSD or FREEBSD: # OpenBSD implements filtering in C if (fam not in families) or (type not in types): continue nt = conn_to_ntuple(fd, fam, type, laddr, raddr, status, TCP_STATUSES, pid) ret.add(nt) return list(ret) # ===================================================================== # --- sensors # ===================================================================== if FREEBSD: def sensors_battery(): """Return battery info.""" try: percent, minsleft, power_plugged = cext.sensors_battery() except NotImplementedError: # See: https://github.com/giampaolo/psutil/issues/1074 return None power_plugged = power_plugged == 1 if power_plugged: secsleft = _common.POWER_TIME_UNLIMITED elif minsleft == -1: secsleft = _common.POWER_TIME_UNKNOWN else: secsleft = minsleft * 60 return _common.sbattery(percent, secsleft, power_plugged) def sensors_temperatures(): """Return CPU cores temperatures if available, else an empty dict.""" ret = defaultdict(list) num_cpus = cpu_count_logical() for cpu in range(num_cpus): try: current, high = cext.sensors_cpu_temperature(cpu) if high <= 0: high = None name = "Core %s" % cpu ret["coretemp"].append( _common.shwtemp(name, current, high, high)) except NotImplementedError: pass return ret # ===================================================================== # --- other system functions # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() def users(): """Return currently connected users as a list of namedtuples.""" retlist = [] rawlist = cext.users() for item in rawlist: user, tty, hostname, tstamp, pid = item if pid == -1: assert OPENBSD pid = None if tty == '~': continue # reboot or shutdown nt = _common.suser(user, tty or None, hostname, tstamp, pid) retlist.append(nt) return retlist # ===================================================================== # --- processes # ===================================================================== @memoize def _pid_0_exists(): try: Process(0).name() except NoSuchProcess: return False except AccessDenied: return True else: return True def pids(): """Returns a list of PIDs currently running on the system.""" ret = cext.pids() if OPENBSD and (0 not in ret) and _pid_0_exists(): # On OpenBSD the kernel does not return PID 0 (neither does # ps) but it's actually querable (Process(0) will succeed). ret.insert(0, 0) return ret if OPENBSD or NETBSD: def pid_exists(pid): """Return True if pid exists.""" exists = _psposix.pid_exists(pid) if not exists: # We do this because _psposix.pid_exists() lies in case of # zombie processes. return pid in pids() else: return True else: pid_exists = _psposix.pid_exists def is_zombie(pid): try: st = cext.proc_oneshot_info(pid)[kinfo_proc_map['status']] return PROC_STATUSES.get(st) == _common.STATUS_ZOMBIE except Exception: return False def wrap_exceptions(fun): """Decorator which translates bare OSError exceptions into NoSuchProcess and AccessDenied. """ @functools.wraps(fun) def wrapper(self, args, kwargs): try: return fun(self, args, **kwargs) except ProcessLookupError: if is_zombie(self.pid): raise ZombieProcess(self.pid, self._name, self._ppid) else: raise NoSuchProcess(self.pid, self._name) except PermissionError: raise AccessDenied(self.pid, self._name) except OSError: if self.pid == 0: if 0 in pids(): raise AccessDenied(self.pid, self._name) else: raise raise return wrapper @contextlib.contextmanager def wrap_exceptions_procfs(inst): """Same as above, for routines relying on reading /proc fs.""" try: yield except (ProcessLookupError, FileNotFoundError): # ENOENT (no such file or directory) gets raised on open(). # ESRCH (no such process) can get raised on read() if # process is gone in meantime. if is_zombie(inst.pid): raise ZombieProcess(inst.pid, inst._name, inst._ppid) else: raise NoSuchProcess(inst.pid, inst._name) except PermissionError: raise AccessDenied(inst.pid, inst._name) class Process(object): """Wrapper class around underlying C implementation.""" __slots__ = ["pid", "_name", "_ppid", "_cache"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None def _assert_alive(self): """Raise NSP if the process disappeared on us.""" # For those C function who do not raise NSP, possibly returning # incorrect or incomplete result. cext.proc_name(self.pid) @wrap_exceptions @memoize_when_activated def oneshot(self): """Retrieves multiple process info in one shot as a raw tuple.""" ret = cext.proc_oneshot_info(self.pid) assert len(ret) == len(kinfo_proc_map) return ret def oneshot_enter(self): self.oneshot.cache_activate(self) def oneshot_exit(self): self.oneshot.cache_deactivate(self) @wrap_exceptions def name(self): name = self.oneshot()[kinfo_proc_map['name']] return name if name is not None else cext.proc_name(self.pid) @wrap_exceptions def exe(self): if FREEBSD: if self.pid == 0: return '' # else NSP return cext.proc_exe(self.pid) elif NETBSD: if self.pid == 0: # /proc/0 dir exists but /proc/0/exe doesn't return "" with wrap_exceptions_procfs(self): return os.readlink("/proc/%s/exe" % self.pid) else: # OpenBSD: exe cannot be determined; references: # https://chromium.googlesource.com/chromium/src/base/+/ # master/base_paths_posix.cc # We try our best guess by using which against the first # cmdline arg (may return None). cmdline = self.cmdline() if cmdline: return which(cmdline[0]) or "" else: return "" @wrap_exceptions def cmdline(self): if OPENBSD and self.pid == 0: return [] # ...else it crashes elif NETBSD: # XXX - most of the times the underlying sysctl() call on Net # and Open BSD returns a truncated string. # Also /proc/pid/cmdline behaves the same so it looks # like this is a kernel bug. try: return cext.proc_cmdline(self.pid) except OSError as err: if err.errno == errno.EINVAL: if is_zombie(self.pid): raise ZombieProcess(self.pid, self._name, self._ppid) elif not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name, self._ppid) else: # XXX: this happens with unicode tests. It means the C # routine is unable to decode invalid unicode chars. return [] else: raise else: return cext.proc_cmdline(self.pid) @wrap_exceptions def environ(self): return cext.proc_environ(self.pid) @wrap_exceptions def terminal(self): tty_nr = self.oneshot()[kinfo_proc_map['ttynr']] tmap = _psposix.get_terminal_map() try: return tmap[tty_nr] except KeyError: return None @wrap_exceptions def ppid(self): self._ppid = self.oneshot()[kinfo_proc_map['ppid']] return self._ppid @wrap_exceptions def uids(self): rawtuple = self.oneshot() return _common.puids( rawtuple[kinfo_proc_map['real_uid']], rawtuple[kinfo_proc_map['effective_uid']], rawtuple[kinfo_proc_map['saved_uid']]) @wrap_exceptions def gids(self): rawtuple = self.oneshot() return _common.pgids( rawtuple[kinfo_proc_map['real_gid']], rawtuple[kinfo_proc_map['effective_gid']], rawtuple[kinfo_proc_map['saved_gid']]) @wrap_exceptions def cpu_times(self): rawtuple = self.oneshot() return _common.pcputimes( rawtuple[kinfo_proc_map['user_time']], rawtuple[kinfo_proc_map['sys_time']], rawtuple[kinfo_proc_map['ch_user_time']], rawtuple[kinfo_proc_map['ch_sys_time']]) if FREEBSD: @wrap_exceptions def cpu_num(self): return self.oneshot()[kinfo_proc_map['cpunum']] @wrap_exceptions def memory_info(self): rawtuple = self.oneshot() return pmem( rawtuple[kinfo_proc_map['rss']], rawtuple[kinfo_proc_map['vms']], rawtuple[kinfo_proc_map['memtext']], rawtuple[kinfo_proc_map['memdata']], rawtuple[kinfo_proc_map['memstack']]) memory_full_info = memory_info @wrap_exceptions def create_time(self): return self.oneshot()[kinfo_proc_map['create_time']] @wrap_exceptions def num_threads(self): if HAS_PROC_NUM_THREADS: # FreeBSD return cext.proc_num_threads(self.pid) else: return len(self.threads()) @wrap_exceptions def num_ctx_switches(self): rawtuple = self.oneshot() return _common.pctxsw( rawtuple[kinfo_proc_map['ctx_switches_vol']], rawtuple[kinfo_proc_map['ctx_switches_unvol']]) @wrap_exceptions def threads(self): # Note: on OpenSBD this (/dev/mem) requires root access. rawlist = cext.proc_threads(self.pid) retlist = [] for thread_id, utime, stime in rawlist: ntuple = _common.pthread(thread_id, utime, stime) retlist.append(ntuple) if OPENBSD: self._assert_alive() return retlist @wrap_exceptions def connections(self, kind='inet'): if kind not in conn_tmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in conn_tmap]))) families, types = conn_tmap[kind] ret = [] if NETBSD: rawlist = cext.net_connections(self.pid) elif OPENBSD: rawlist = cext.net_connections(self.pid, families, types) else: # FreeBSD rawlist = cext.proc_connections(self.pid, families, types) for item in rawlist: fd, fam, type, laddr, raddr, status = item[:6] if NETBSD: # FreeBSD and OpenBSD implement filtering in C if (fam not in families) or (type not in types): continue nt = conn_to_ntuple(fd, fam, type, laddr, raddr, status, TCP_STATUSES) ret.append(nt) self._assert_alive() return ret @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout, self._name) @wrap_exceptions def nice_get(self): return cext_posix.getpriority(self.pid) @wrap_exceptions def nice_set(self, value): return cext_posix.setpriority(self.pid, value) @wrap_exceptions def status(self): code = self.oneshot()[kinfo_proc_map['status']] # XXX is '?' legit? (we're not supposed to return it anyway) return PROC_STATUSES.get(code, '?') @wrap_exceptions def io_counters(self): rawtuple = self.oneshot() return _common.pio( rawtuple[kinfo_proc_map['read_io_count']], rawtuple[kinfo_proc_map['write_io_count']], -1, -1) @wrap_exceptions def cwd(self): """Return process current working directory.""" # sometimes we get an empty string, in which case we turn # it into None if OPENBSD and self.pid == 0: return "" # ...else it would raise EINVAL elif NETBSD or HAS_PROC_OPEN_FILES: # FreeBSD < 8 does not support functions based on # kinfo_getfile() and kinfo_getvmmap() return cext.proc_cwd(self.pid) else: raise NotImplementedError( "supported only starting from FreeBSD 8" if FREEBSD else "") nt_mmap_grouped = namedtuple( 'mmap', 'path rss, private, ref_count, shadow_count') nt_mmap_ext = namedtuple( 'mmap', 'addr, perms path rss, private, ref_count, shadow_count') def _not_implemented(self): raise NotImplementedError # FreeBSD < 8 does not support functions based on kinfo_getfile() # and kinfo_getvmmap() if HAS_PROC_OPEN_FILES: @wrap_exceptions def open_files(self): """Return files opened by process as a list of namedtuples.""" rawlist = cext.proc_open_files(self.pid) return [_common.popenfile(path, fd) for path, fd in rawlist] else: open_files = _not_implemented # FreeBSD < 8 does not support functions based on kinfo_getfile() # and kinfo_getvmmap() if HAS_PROC_NUM_FDS: @wrap_exceptions def num_fds(self): """Return the number of file descriptors opened by this process.""" ret = cext.proc_num_fds(self.pid) if NETBSD: self._assert_alive() return ret else: num_fds = _not_implemented # --- FreeBSD only APIs if FREEBSD: @wrap_exceptions def cpu_affinity_get(self): return cext.proc_cpu_affinity_get(self.pid) @wrap_exceptions def cpu_affinity_set(self, cpus): # Pre-emptively check if CPUs are valid because the C # function has a weird behavior in case of invalid CPUs, # see: https://github.com/giampaolo/psutil/issues/586 allcpus = tuple(range(len(per_cpu_times()))) for cpu in cpus: if cpu not in allcpus: raise ValueError("invalid CPU #%i (choose between %s)" % (cpu, allcpus)) try: cext.proc_cpu_affinity_set(self.pid, cpus) except OSError as err: # 'man cpuset_setaffinity' about EDEADLK: # <<the call would leave a thread without a valid CPU to run # on because the set does not overlap with the thread's # anonymous mask>> if err.errno in (errno.EINVAL, errno.EDEADLK): for cpu in cpus: if cpu not in allcpus: raise ValueError( "invalid CPU #%i (choose between %s)" % ( cpu, allcpus)) raise @wrap_exceptions def memory_maps(self): return cext.proc_memory_maps(self.pid) @wrap_exceptions def rlimit(self, resource, limits=None): if limits is None: return cext.proc_getrlimit(self.pid, resource) else: if len(limits) != 2: raise ValueError( "second argument must be a (soft, hard) tuple, " "got %s" % repr(limits)) soft, hard = limits return cext.proc_setrlimit(self.pid, resource, soft, hard)	31.02 KB	2026-01-20 12:58
📄 _pslinux.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Linux platform implementation.""" from __future__ import division import base64 import collections import errno import functools import glob import os import re import socket import struct import sys import traceback import warnings from collections import defaultdict from collections import namedtuple from . import _common from . import _psposix from . import _psutil_linux as cext from . import _psutil_posix as cext_posix from ._common import NIC_DUPLEX_FULL from ._common import NIC_DUPLEX_HALF from ._common import NIC_DUPLEX_UNKNOWN from ._common import AccessDenied from ._common import NoSuchProcess from ._common import ZombieProcess from ._common import bcat from ._common import cat from ._common import debug from ._common import decode from ._common import get_procfs_path from ._common import isfile_strict from ._common import memoize from ._common import memoize_when_activated from ._common import open_binary from ._common import open_text from ._common import parse_environ_block from ._common import path_exists_strict from ._common import supports_ipv6 from ._common import usage_percent from ._compat import PY3 from ._compat import FileNotFoundError from ._compat import PermissionError from ._compat import ProcessLookupError from ._compat import b from ._compat import basestring if sys.version_info >= (3, 4): import enum else: enum = None __extra__all__ = [ # 'PROCFS_PATH', # io prio constants "IOPRIO_CLASS_NONE", "IOPRIO_CLASS_RT", "IOPRIO_CLASS_BE", "IOPRIO_CLASS_IDLE", # connection status constants "CONN_ESTABLISHED", "CONN_SYN_SENT", "CONN_SYN_RECV", "CONN_FIN_WAIT1", "CONN_FIN_WAIT2", "CONN_TIME_WAIT", "CONN_CLOSE", "CONN_CLOSE_WAIT", "CONN_LAST_ACK", "CONN_LISTEN", "CONN_CLOSING", ] # ===================================================================== # --- globals # ===================================================================== POWER_SUPPLY_PATH = "/sys/class/power_supply" HAS_PROC_SMAPS = os.path.exists('/proc/%s/smaps' % os.getpid()) HAS_PROC_SMAPS_ROLLUP = os.path.exists('/proc/%s/smaps_rollup' % os.getpid()) HAS_PROC_IO_PRIORITY = hasattr(cext, "proc_ioprio_get") HAS_CPU_AFFINITY = hasattr(cext, "proc_cpu_affinity_get") # Number of clock ticks per second CLOCK_TICKS = os.sysconf("SC_CLK_TCK") PAGESIZE = cext_posix.getpagesize() BOOT_TIME = None # set later LITTLE_ENDIAN = sys.byteorder == 'little' # "man iostat" states that sectors are equivalent with blocks and have # a size of 512 bytes. Despite this value can be queried at runtime # via /sys/block/{DISK}/queue/hw_sector_size and results may vary # between 1k, 2k, or 4k... 512 appears to be a magic constant used # throughout Linux source code: # * https://stackoverflow.com/a/38136179/376587 # * https://lists.gt.net/linux/kernel/2241060 # * https://github.com/giampaolo/psutil/issues/1305 # * https://github.com/torvalds/linux/blob/ # 4f671fe2f9523a1ea206f63fe60a7c7b3a56d5c7/include/linux/bio.h#L99 # * https://lkml.org/lkml/2015/8/17/234 DISK_SECTOR_SIZE = 512 if enum is None: AF_LINK = socket.AF_PACKET else: AddressFamily = enum.IntEnum('AddressFamily', {'AF_LINK': int(socket.AF_PACKET)}) AF_LINK = AddressFamily.AF_LINK # ioprio_* constants http://linux.die.net/man/2/ioprio_get if enum is None: IOPRIO_CLASS_NONE = 0 IOPRIO_CLASS_RT = 1 IOPRIO_CLASS_BE = 2 IOPRIO_CLASS_IDLE = 3 else: class IOPriority(enum.IntEnum): IOPRIO_CLASS_NONE = 0 IOPRIO_CLASS_RT = 1 IOPRIO_CLASS_BE = 2 IOPRIO_CLASS_IDLE = 3 globals().update(IOPriority.__members__) # See: # https://github.com/torvalds/linux/blame/master/fs/proc/array.c # ...and (TASK_* constants): # https://github.com/torvalds/linux/blob/master/include/linux/sched.h PROC_STATUSES = { "R": _common.STATUS_RUNNING, "S": _common.STATUS_SLEEPING, "D": _common.STATUS_DISK_SLEEP, "T": _common.STATUS_STOPPED, "t": _common.STATUS_TRACING_STOP, "Z": _common.STATUS_ZOMBIE, "X": _common.STATUS_DEAD, "x": _common.STATUS_DEAD, "K": _common.STATUS_WAKE_KILL, "W": _common.STATUS_WAKING, "I": _common.STATUS_IDLE, "P": _common.STATUS_PARKED, } # https://github.com/torvalds/linux/blob/master/include/net/tcp_states.h TCP_STATUSES = { "01": _common.CONN_ESTABLISHED, "02": _common.CONN_SYN_SENT, "03": _common.CONN_SYN_RECV, "04": _common.CONN_FIN_WAIT1, "05": _common.CONN_FIN_WAIT2, "06": _common.CONN_TIME_WAIT, "07": _common.CONN_CLOSE, "08": _common.CONN_CLOSE_WAIT, "09": _common.CONN_LAST_ACK, "0A": _common.CONN_LISTEN, "0B": _common.CONN_CLOSING } # ===================================================================== # --- named tuples # ===================================================================== # psutil.virtual_memory() svmem = namedtuple( 'svmem', ['total', 'available', 'percent', 'used', 'free', 'active', 'inactive', 'buffers', 'cached', 'shared', 'slab']) # psutil.disk_io_counters() sdiskio = namedtuple( 'sdiskio', ['read_count', 'write_count', 'read_bytes', 'write_bytes', 'read_time', 'write_time', 'read_merged_count', 'write_merged_count', 'busy_time']) # psutil.Process().open_files() popenfile = namedtuple( 'popenfile', ['path', 'fd', 'position', 'mode', 'flags']) # psutil.Process().memory_info() pmem = namedtuple('pmem', 'rss vms shared text lib data dirty') # psutil.Process().memory_full_info() pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', 'pss', 'swap')) # psutil.Process().memory_maps(grouped=True) pmmap_grouped = namedtuple( 'pmmap_grouped', ['path', 'rss', 'size', 'pss', 'shared_clean', 'shared_dirty', 'private_clean', 'private_dirty', 'referenced', 'anonymous', 'swap']) # psutil.Process().memory_maps(grouped=False) pmmap_ext = namedtuple( 'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields)) # psutil.Process.io_counters() pio = namedtuple('pio', ['read_count', 'write_count', 'read_bytes', 'write_bytes', 'read_chars', 'write_chars']) # psutil.Process.cpu_times() pcputimes = namedtuple('pcputimes', ['user', 'system', 'children_user', 'children_system', 'iowait']) # ===================================================================== # --- utils # ===================================================================== def readlink(path): """Wrapper around os.readlink().""" assert isinstance(path, basestring), path path = os.readlink(path) # readlink() might return paths containing null bytes ('\x00') # resulting in "TypeError: must be encoded string without NULL # bytes, not str" errors when the string is passed to other # fs-related functions (os., open(), ...). # Apparently everything after '\x00' is garbage (we can have # ' (deleted)', 'new' and possibly others), see: # https://github.com/giampaolo/psutil/issues/717 path = path.split('\x00')[0] # Certain paths have ' (deleted)' appended. Usually this is # bogus as the file actually exists. Even if it doesn't we # don't care. if path.endswith(' (deleted)') and not path_exists_strict(path): path = path[:-10] return path def file_flags_to_mode(flags): """Convert file's open() flags into a readable string. Used by Process.open_files(). """ modes_map = {os.O_RDONLY: 'r', os.O_WRONLY: 'w', os.O_RDWR: 'w+'} mode = modes_map[flags & (os.O_RDONLY \| os.O_WRONLY \| os.O_RDWR)] if flags & os.O_APPEND: mode = mode.replace('w', 'a', 1) mode = mode.replace('w+', 'r+') # possible values: r, w, a, r+, a+ return mode def is_storage_device(name): """Return True if the given name refers to a root device (e.g. "sda", "nvme0n1") as opposed to a logical partition (e.g. "sda1", "nvme0n1p1"). If name is a virtual device (e.g. "loop1", "ram") return True. """ # Re-adapted from iostat source code, see: # https://github.com/sysstat/sysstat/blob/ # 97912938cd476645b267280069e83b1c8dc0e1c7/common.c#L208 # Some devices may have a slash in their name (e.g. cciss/c0d0...). name = name.replace('/', '!') including_virtual = True if including_virtual: path = "/sys/block/%s" % name else: path = "/sys/block/%s/device" % name return os.access(path, os.F_OK) @memoize def set_scputimes_ntuple(procfs_path): """Set a namedtuple of variable fields depending on the CPU times available on this Linux kernel version which may be: (user, nice, system, idle, iowait, irq, softirq, [steal, [guest, [guest_nice]]]) Used by cpu_times() function. """ global scputimes with open_binary('%s/stat' % procfs_path) as f: values = f.readline().split()[1:] fields = ['user', 'nice', 'system', 'idle', 'iowait', 'irq', 'softirq'] vlen = len(values) if vlen >= 8: # Linux >= 2.6.11 fields.append('steal') if vlen >= 9: # Linux >= 2.6.24 fields.append('guest') if vlen >= 10: # Linux >= 3.2.0 fields.append('guest_nice') scputimes = namedtuple('scputimes', fields) try: set_scputimes_ntuple("/proc") except Exception: # pragma: no cover # Don't want to crash at import time. traceback.print_exc() scputimes = namedtuple('scputimes', 'user system idle')(0.0, 0.0, 0.0) # ===================================================================== # --- prlimit # ===================================================================== # Backport of resource.prlimit() for Python 2. Originally this was done # in C, but CentOS-6 which we use to create manylinux wheels is too old # and does not support prlimit() syscall. As such the resulting wheel # would not include prlimit(), even when installed on newer systems. # This is the only part of psutil using ctypes. prlimit = None try: from resource import prlimit # python >= 3.4 except ImportError: import ctypes libc = ctypes.CDLL(None, use_errno=True) if hasattr(libc, "prlimit"): def prlimit(pid, resource_, limits=None): class StructRlimit(ctypes.Structure): _fields_ = [('rlim_cur', ctypes.c_longlong), ('rlim_max', ctypes.c_longlong)] current = StructRlimit() if limits is None: # get ret = libc.prlimit(pid, resource_, None, ctypes.byref(current)) else: # set new = StructRlimit() new.rlim_cur = limits[0] new.rlim_max = limits[1] ret = libc.prlimit( pid, resource_, ctypes.byref(new), ctypes.byref(current)) if ret != 0: errno_ = ctypes.get_errno() raise OSError(errno_, os.strerror(errno_)) return (current.rlim_cur, current.rlim_max) if prlimit is not None: __extra__all__.extend( [x for x in dir(cext) if x.startswith('RLIM') and x.isupper()]) # ===================================================================== # --- system memory # ===================================================================== def calculate_avail_vmem(mems): """Fallback for kernels < 3.14 where /proc/meminfo does not provide "MemAvailable", see: https://blog.famzah.net/2014/09/24/ This code reimplements the algorithm outlined here: https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/ commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773 We use this function also when "MemAvailable" returns 0 (possibly a kernel bug, see: https://github.com/giampaolo/psutil/issues/1915). In that case this routine matches "free" CLI tool result ("available" column). XXX: on recent kernels this calculation may differ by ~1.5% compared to "MemAvailable:", as it's calculated slightly differently. It is still way more realistic than doing (free + cached) though. See: https://gitlab.com/procps-ng/procps/issues/42 * https://github.com/famzah/linux-memavailable-procfs/issues/2 """ # Note about "fallback" value. According to: # https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/ # commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773 # ...long ago "available" memory was calculated as (free + cached), # We use fallback when one of these is missing from /proc/meminfo: # "Active(file)": introduced in 2.6.28 / Dec 2008 # "Inactive(file)": introduced in 2.6.28 / Dec 2008 # "SReclaimable": introduced in 2.6.19 / Nov 2006 # /proc/zoneinfo: introduced in 2.6.13 / Aug 2005 free = mems[b'MemFree:'] fallback = free + mems.get(b"Cached:", 0) try: lru_active_file = mems[b'Active(file):'] lru_inactive_file = mems[b'Inactive(file):'] slab_reclaimable = mems[b'SReclaimable:'] except KeyError as err: debug("%r is missing from /proc/meminfo; using an approximation " "for calculating available memory" % err.args[0]) return fallback try: f = open_binary('%s/zoneinfo' % get_procfs_path()) except IOError: return fallback # kernel 2.6.13 watermark_low = 0 with f: for line in f: line = line.strip() if line.startswith(b'low'): watermark_low += int(line.split()[1]) watermark_low = PAGESIZE avail = free - watermark_low pagecache = lru_active_file + lru_inactive_file pagecache -= min(pagecache / 2, watermark_low) avail += pagecache avail += slab_reclaimable - min(slab_reclaimable / 2.0, watermark_low) return int(avail) def virtual_memory(): """Report virtual memory stats. This implementation mimicks procps-ng-3.3.12, aka "free" CLI tool: https://gitlab.com/procps-ng/procps/blob/ 24fd2605c51fccc375ab0287cec33aa767f06718/proc/sysinfo.c#L778-791 The returned values are supposed to match both "free" and "vmstat -s" CLI tools. """ missing_fields = [] mems = {} with open_binary('%s/meminfo' % get_procfs_path()) as f: for line in f: fields = line.split() mems[fields[0]] = int(fields[1]) 1024 # /proc doc states that the available fields in /proc/meminfo vary # by architecture and compile options, but these 3 values are also # returned by sysinfo(2); as such we assume they are always there. total = mems[b'MemTotal:'] free = mems[b'MemFree:'] try: buffers = mems[b'Buffers:'] except KeyError: # https://github.com/giampaolo/psutil/issues/1010 buffers = 0 missing_fields.append('buffers') try: cached = mems[b"Cached:"] except KeyError: cached = 0 missing_fields.append('cached') else: # "free" cmdline utility sums reclaimable to cached. # Older versions of procps used to add slab memory instead. # This got changed in: # https://gitlab.com/procps-ng/procps/commit/ # 05d751c4f076a2f0118b914c5e51cfbb4762ad8e cached += mems.get(b"SReclaimable:", 0) # since kernel 2.6.19 try: shared = mems[b'Shmem:'] # since kernel 2.6.32 except KeyError: try: shared = mems[b'MemShared:'] # kernels 2.4 except KeyError: shared = 0 missing_fields.append('shared') try: active = mems[b"Active:"] except KeyError: active = 0 missing_fields.append('active') try: inactive = mems[b"Inactive:"] except KeyError: try: inactive = \ mems[b"Inact_dirty:"] + \ mems[b"Inact_clean:"] + \ mems[b"Inact_laundry:"] except KeyError: inactive = 0 missing_fields.append('inactive') try: slab = mems[b"Slab:"] except KeyError: slab = 0 used = total - free - cached - buffers if used < 0: # May be symptomatic of running within a LCX container where such # values will be dramatically distorted over those of the host. used = total - free # - starting from 4.4.0 we match free's "available" column. # Before 4.4.0 we calculated it as (free + buffers + cached) # which matched htop. # - free and htop available memory differs as per: # http://askubuntu.com/a/369589 # http://unix.stackexchange.com/a/65852/168884 # - MemAvailable has been introduced in kernel 3.14 try: avail = mems[b'MemAvailable:'] except KeyError: avail = calculate_avail_vmem(mems) else: if avail == 0: # Yes, it can happen (probably a kernel bug): # https://github.com/giampaolo/psutil/issues/1915 # In this case "free" CLI tool makes an estimate. We do the same, # and it matches "free" CLI tool. avail = calculate_avail_vmem(mems) if avail < 0: avail = 0 missing_fields.append('available') elif avail > total: # If avail is greater than total or our calculation overflows, # that's symptomatic of running within a LCX container where such # values will be dramatically distorted over those of the host. # https://gitlab.com/procps-ng/procps/blob/ # 24fd2605c51fccc375ab0287cec33aa767f06718/proc/sysinfo.c#L764 avail = free percent = usage_percent((total - avail), total, round_=1) # Warn about missing metrics which are set to 0. if missing_fields: msg = "%s memory stats couldn't be determined and %s set to 0" % ( ", ".join(missing_fields), "was" if len(missing_fields) == 1 else "were") warnings.warn(msg, RuntimeWarning, stacklevel=2) return svmem(total, avail, percent, used, free, active, inactive, buffers, cached, shared, slab) def swap_memory(): """Return swap memory metrics.""" mems = {} with open_binary('%s/meminfo' % get_procfs_path()) as f: for line in f: fields = line.split() mems[fields[0]] = int(fields[1]) * 1024 # We prefer /proc/meminfo over sysinfo() syscall so that # psutil.PROCFS_PATH can be used in order to allow retrieval # for linux containers, see: # https://github.com/giampaolo/psutil/issues/1015 try: total = mems[b'SwapTotal:'] free = mems[b'SwapFree:'] except KeyError: _, _, _, _, total, free, unit_multiplier = cext.linux_sysinfo() total = unit_multiplier free = unit_multiplier used = total - free percent = usage_percent(used, total, round_=1) # get pgin/pgouts try: f = open_binary("%s/vmstat" % get_procfs_path()) except IOError as err: # see https://github.com/giampaolo/psutil/issues/722 msg = "'sin' and 'sout' swap memory stats couldn't " \ "be determined and were set to 0 (%s)" % str(err) warnings.warn(msg, RuntimeWarning, stacklevel=2) sin = sout = 0 else: with f: sin = sout = None for line in f: # values are expressed in 4 kilo bytes, we want # bytes instead if line.startswith(b'pswpin'): sin = int(line.split(b' ')[1]) * 4 * 1024 elif line.startswith(b'pswpout'): sout = int(line.split(b' ')[1]) * 4 * 1024 if sin is not None and sout is not None: break else: # we might get here when dealing with exotic Linux # flavors, see: # https://github.com/giampaolo/psutil/issues/313 msg = "'sin' and 'sout' swap memory stats couldn't " \ "be determined and were set to 0" warnings.warn(msg, RuntimeWarning, stacklevel=2) sin = sout = 0 return _common.sswap(total, used, free, percent, sin, sout) # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return a named tuple representing the following system-wide CPU times: (user, nice, system, idle, iowait, irq, softirq [steal, [guest, [guest_nice]]]) Last 3 fields may not be available on all Linux kernel versions. """ procfs_path = get_procfs_path() set_scputimes_ntuple(procfs_path) with open_binary('%s/stat' % procfs_path) as f: values = f.readline().split() fields = values[1:len(scputimes._fields) + 1] fields = [float(x) / CLOCK_TICKS for x in fields] return scputimes(fields) def per_cpu_times(): """Return a list of namedtuple representing the CPU times for every CPU available on the system. """ procfs_path = get_procfs_path() set_scputimes_ntuple(procfs_path) cpus = [] with open_binary('%s/stat' % procfs_path) as f: # get rid of the first line which refers to system wide CPU stats f.readline() for line in f: if line.startswith(b'cpu'): values = line.split() fields = values[1:len(scputimes._fields) + 1] fields = [float(x) / CLOCK_TICKS for x in fields] entry = scputimes(fields) cpus.append(entry) return cpus def cpu_count_logical(): """Return the number of logical CPUs in the system.""" try: return os.sysconf("SC_NPROCESSORS_ONLN") except ValueError: # as a second fallback we try to parse /proc/cpuinfo num = 0 with open_binary('%s/cpuinfo' % get_procfs_path()) as f: for line in f: if line.lower().startswith(b'processor'): num += 1 # unknown format (e.g. amrel/sparc architectures), see: # https://github.com/giampaolo/psutil/issues/200 # try to parse /proc/stat as a last resort if num == 0: search = re.compile(r'cpu\d') with open_text('%s/stat' % get_procfs_path()) as f: for line in f: line = line.split(' ')[0] if search.match(line): num += 1 if num == 0: # mimic os.cpu_count() return None return num def cpu_count_cores(): """Return the number of CPU cores in the system.""" # Method #1 ls = set() # These 2 files are the same but /core_cpus_list is newer while # /thread_siblings_list is deprecated and may disappear in the future. # https://www.kernel.org/doc/Documentation/admin-guide/cputopology.rst # https://github.com/giampaolo/psutil/pull/1727#issuecomment-707624964 # https://lkml.org/lkml/2019/2/26/41 p1 = "/sys/devices/system/cpu/cpu[0-9]/topology/core_cpus_list" p2 = "/sys/devices/system/cpu/cpu[0-9]/topology/thread_siblings_list" for path in glob.glob(p1) or glob.glob(p2): with open_binary(path) as f: ls.add(f.read().strip()) result = len(ls) if result != 0: return result # Method #2 mapping = {} current_info = {} with open_binary('%s/cpuinfo' % get_procfs_path()) as f: for line in f: line = line.strip().lower() if not line: # new section try: mapping[current_info[b'physical id']] = \ current_info[b'cpu cores'] except KeyError: pass current_info = {} else: # ongoing section if line.startswith((b'physical id', b'cpu cores')): key, value = line.split(b'\t:', 1) current_info[key] = int(value) result = sum(mapping.values()) return result or None # mimic os.cpu_count() def cpu_stats(): """Return various CPU stats as a named tuple.""" with open_binary('%s/stat' % get_procfs_path()) as f: ctx_switches = None interrupts = None soft_interrupts = None for line in f: if line.startswith(b'ctxt'): ctx_switches = int(line.split()[1]) elif line.startswith(b'intr'): interrupts = int(line.split()[1]) elif line.startswith(b'softirq'): soft_interrupts = int(line.split()[1]) if ctx_switches is not None and soft_interrupts is not None \ and interrupts is not None: break syscalls = 0 return _common.scpustats( ctx_switches, interrupts, soft_interrupts, syscalls) def _cpu_get_cpuinfo_freq(): """Return current CPU frequency from cpuinfo if available. """ ret = [] with open_binary('%s/cpuinfo' % get_procfs_path()) as f: for line in f: if line.lower().startswith(b'cpu mhz'): ret.append(float(line.split(b':', 1)[1])) return ret if os.path.exists("/sys/devices/system/cpu/cpufreq/policy0") or \ os.path.exists("/sys/devices/system/cpu/cpu0/cpufreq"): def cpu_freq(): """Return frequency metrics for all CPUs. Contrarily to other OSes, Linux updates these values in real-time. """ cpuinfo_freqs = _cpu_get_cpuinfo_freq() paths = \ glob.glob("/sys/devices/system/cpu/cpufreq/policy[0-9]") or \ glob.glob("/sys/devices/system/cpu/cpu[0-9]/cpufreq") paths.sort(key=lambda x: int(re.search(r"[0-9]+", x).group())) ret = [] pjoin = os.path.join for i, path in enumerate(paths): if len(paths) == len(cpuinfo_freqs): # take cached value from cpuinfo if available, see: # https://github.com/giampaolo/psutil/issues/1851 curr = cpuinfo_freqs[i] * 1000 else: curr = bcat(pjoin(path, "scaling_cur_freq"), fallback=None) if curr is None: # Likely an old RedHat, see: # https://github.com/giampaolo/psutil/issues/1071 curr = bcat(pjoin(path, "cpuinfo_cur_freq"), fallback=None) if curr is None: raise NotImplementedError( "can't find current frequency file") curr = int(curr) / 1000 max_ = int(bcat(pjoin(path, "scaling_max_freq"))) / 1000 min_ = int(bcat(pjoin(path, "scaling_min_freq"))) / 1000 ret.append(_common.scpufreq(curr, min_, max_)) return ret else: def cpu_freq(): """Alternate implementation using /proc/cpuinfo. min and max frequencies are not available and are set to None. """ return [_common.scpufreq(x, 0., 0.) for x in _cpu_get_cpuinfo_freq()] # ===================================================================== # --- network # ===================================================================== net_if_addrs = cext_posix.net_if_addrs class _Ipv6UnsupportedError(Exception): pass class Connections: """A wrapper on top of /proc/net/* files, retrieving per-process and system-wide open connections (TCP, UDP, UNIX) similarly to "netstat -an". Note: in case of UNIX sockets we're only able to determine the local endpoint/path, not the one it's connected to. According to [1] it would be possible but not easily. [1] http://serverfault.com/a/417946 """ def __init__(self): # The string represents the basename of the corresponding # /proc/net/{proto_name} file. tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM) tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM) udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM) udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM) unix = ("unix", socket.AF_UNIX, None) self.tmap = { "all": (tcp4, tcp6, udp4, udp6, unix), "tcp": (tcp4, tcp6), "tcp4": (tcp4,), "tcp6": (tcp6,), "udp": (udp4, udp6), "udp4": (udp4,), "udp6": (udp6,), "unix": (unix,), "inet": (tcp4, tcp6, udp4, udp6), "inet4": (tcp4, udp4), "inet6": (tcp6, udp6), } self._procfs_path = None def get_proc_inodes(self, pid): inodes = defaultdict(list) for fd in os.listdir("%s/%s/fd" % (self._procfs_path, pid)): try: inode = readlink("%s/%s/fd/%s" % (self._procfs_path, pid, fd)) except (FileNotFoundError, ProcessLookupError): # ENOENT == file which is gone in the meantime; # os.stat('/proc/%s' % self.pid) will be done later # to force NSP (if it's the case) continue except OSError as err: if err.errno == errno.EINVAL: # not a link continue if err.errno == errno.ENAMETOOLONG: # file name too long debug(err) continue raise else: if inode.startswith('socket:['): # the process is using a socket inode = inode[8:][:-1] inodes[inode].append((pid, int(fd))) return inodes def get_all_inodes(self): inodes = {} for pid in pids(): try: inodes.update(self.get_proc_inodes(pid)) except (FileNotFoundError, ProcessLookupError, PermissionError): # os.listdir() is gonna raise a lot of access denied # exceptions in case of unprivileged user; that's fine # as we'll just end up returning a connection with PID # and fd set to None anyway. # Both netstat -an and lsof does the same so it's # unlikely we can do any better. # ENOENT just means a PID disappeared on us. continue return inodes @staticmethod def decode_address(addr, family): """Accept an "ip:port" address as displayed in /proc/net/* and convert it into a human readable form, like: "0500000A:0016" -> ("10.0.0.5", 22) "0000000000000000FFFF00000100007F:9E49" -> ("::ffff:127.0.0.1", 40521) The IP address portion is a little or big endian four-byte hexadecimal number; that is, the least significant byte is listed first, so we need to reverse the order of the bytes to convert it to an IP address. The port is represented as a two-byte hexadecimal number. Reference: http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html """ ip, port = addr.split(':') port = int(port, 16) # this usually refers to a local socket in listen mode with # no end-points connected if not port: return () if PY3: ip = ip.encode('ascii') if family == socket.AF_INET: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop(family, base64.b16decode(ip)[::-1]) else: ip = socket.inet_ntop(family, base64.b16decode(ip)) else: # IPv6 ip = base64.b16decode(ip) try: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('>4I', struct.unpack('<4I', ip))) else: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('<4I', struct.unpack('<4I', ip))) except ValueError: # see: https://github.com/giampaolo/psutil/issues/623 if not supports_ipv6(): raise _Ipv6UnsupportedError else: raise return _common.addr(ip, port) @staticmethod def process_inet(file, family, type_, inodes, filter_pid=None): """Parse /proc/net/tcp* and /proc/net/udp* files.""" if file.endswith('6') and not os.path.exists(file): # IPv6 not supported return with open_text(file) as f: f.readline() # skip the first line for lineno, line in enumerate(f, 1): try: _, laddr, raddr, status, _, _, _, _, _, inode = \ line.split()[:10] except ValueError: raise RuntimeError( "error while parsing %s; malformed line %s %r" % ( file, lineno, line)) if inode in inodes: # # We assume inet sockets are unique, so we error # # out if there are multiple references to the # # same inode. We won't do this for UNIX sockets. # if len(inodes[inode]) > 1 and family != socket.AF_UNIX: # raise ValueError("ambiguous inode with multiple " # "PIDs references") pid, fd = inodes[inode][0] else: pid, fd = None, -1 if filter_pid is not None and filter_pid != pid: continue else: if type_ == socket.SOCK_STREAM: status = TCP_STATUSES[status] else: status = _common.CONN_NONE try: laddr = Connections.decode_address(laddr, family) raddr = Connections.decode_address(raddr, family) except _Ipv6UnsupportedError: continue yield (fd, family, type_, laddr, raddr, status, pid) @staticmethod def process_unix(file, family, inodes, filter_pid=None): """Parse /proc/net/unix files.""" with open_text(file) as f: f.readline() # skip the first line for line in f: tokens = line.split() try: _, _, _, _, type_, _, inode = tokens[0:7] except ValueError: if ' ' not in line: # see: https://github.com/giampaolo/psutil/issues/766 continue raise RuntimeError( "error while parsing %s; malformed line %r" % ( file, line)) if inode in inodes: # With UNIX sockets we can have a single inode # referencing many file descriptors. pairs = inodes[inode] else: pairs = [(None, -1)] for pid, fd in pairs: if filter_pid is not None and filter_pid != pid: continue else: if len(tokens) == 8: path = tokens[-1] else: path = "" type_ = _common.socktype_to_enum(int(type_)) # XXX: determining the remote endpoint of a # UNIX socket on Linux is not possible, see: # https://serverfault.com/questions/252723/ raddr = "" status = _common.CONN_NONE yield (fd, family, type_, path, raddr, status, pid) def retrieve(self, kind, pid=None): if kind not in self.tmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in self.tmap]))) self._procfs_path = get_procfs_path() if pid is not None: inodes = self.get_proc_inodes(pid) if not inodes: # no connections for this process return [] else: inodes = self.get_all_inodes() ret = set() for proto_name, family, type_ in self.tmap[kind]: path = "%s/net/%s" % (self._procfs_path, proto_name) if family in (socket.AF_INET, socket.AF_INET6): ls = self.process_inet( path, family, type_, inodes, filter_pid=pid) else: ls = self.process_unix( path, family, inodes, filter_pid=pid) for fd, family, type_, laddr, raddr, status, bound_pid in ls: if pid: conn = _common.pconn(fd, family, type_, laddr, raddr, status) else: conn = _common.sconn(fd, family, type_, laddr, raddr, status, bound_pid) ret.add(conn) return list(ret) _connections = Connections() def net_connections(kind='inet'): """Return system-wide open connections.""" return _connections.retrieve(kind) def net_io_counters(): """Return network I/O statistics for every network interface installed on the system as a dict of raw tuples. """ with open_text("%s/net/dev" % get_procfs_path()) as f: lines = f.readlines() retdict = {} for line in lines[2:]: colon = line.rfind(':') assert colon > 0, repr(line) name = line[:colon].strip() fields = line[colon + 1:].strip().split() # in (bytes_recv, packets_recv, errin, dropin, fifoin, # unused framein, # unused compressedin, # unused multicastin, # unused # out bytes_sent, packets_sent, errout, dropout, fifoout, # unused collisionsout, # unused carrierout, # unused compressedout) = map(int, fields) retdict[name] = (bytes_sent, bytes_recv, packets_sent, packets_recv, errin, errout, dropin, dropout) return retdict def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" duplex_map = {cext.DUPLEX_FULL: NIC_DUPLEX_FULL, cext.DUPLEX_HALF: NIC_DUPLEX_HALF, cext.DUPLEX_UNKNOWN: NIC_DUPLEX_UNKNOWN} names = net_io_counters().keys() ret = {} for name in names: try: mtu = cext_posix.net_if_mtu(name) flags = cext_posix.net_if_flags(name) duplex, speed = cext.net_if_duplex_speed(name) except OSError as err: # https://github.com/giampaolo/psutil/issues/1279 if err.errno != errno.ENODEV: raise else: debug(err) else: output_flags = ','.join(flags) isup = 'running' in flags ret[name] = _common.snicstats(isup, duplex_map[duplex], speed, mtu, output_flags) return ret # ===================================================================== # --- disks # ===================================================================== disk_usage = _psposix.disk_usage def disk_io_counters(perdisk=False): """Return disk I/O statistics for every disk installed on the system as a dict of raw tuples. """ def read_procfs(): # OK, this is a bit confusing. The format of /proc/diskstats can # have 3 variations. # On Linux 2.4 each line has always 15 fields, e.g.: # "3 0 8 hda 8 8 8 8 8 8 8 8 8 8 8" # On Linux 2.6+ each line usually has 14 fields, and the disk # name is in another position, like this: # "3 0 hda 8 8 8 8 8 8 8 8 8 8 8" # ...unless (Linux 2.6) the line refers to a partition instead # of a disk, in which case the line has less fields (7): # "3 1 hda1 8 8 8 8" # 4.18+ has 4 fields added: # "3 0 hda 8 8 8 8 8 8 8 8 8 8 8 0 0 0 0" # 5.5 has 2 more fields. # See: # https://www.kernel.org/doc/Documentation/iostats.txt # https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats with open_text("%s/diskstats" % get_procfs_path()) as f: lines = f.readlines() for line in lines: fields = line.split() flen = len(fields) if flen == 15: # Linux 2.4 name = fields[3] reads = int(fields[2]) (reads_merged, rbytes, rtime, writes, writes_merged, wbytes, wtime, _, busy_time, _) = map(int, fields[4:14]) elif flen == 14 or flen >= 18: # Linux 2.6+, line referring to a disk name = fields[2] (reads, reads_merged, rbytes, rtime, writes, writes_merged, wbytes, wtime, _, busy_time, _) = map(int, fields[3:14]) elif flen == 7: # Linux 2.6+, line referring to a partition name = fields[2] reads, rbytes, writes, wbytes = map(int, fields[3:]) rtime = wtime = reads_merged = writes_merged = busy_time = 0 else: raise ValueError("not sure how to interpret line %r" % line) yield (name, reads, writes, rbytes, wbytes, rtime, wtime, reads_merged, writes_merged, busy_time) def read_sysfs(): for block in os.listdir('/sys/block'): for root, _, files in os.walk(os.path.join('/sys/block', block)): if 'stat' not in files: continue with open_text(os.path.join(root, 'stat')) as f: fields = f.read().strip().split() name = os.path.basename(root) (reads, reads_merged, rbytes, rtime, writes, writes_merged, wbytes, wtime, _, busy_time) = map(int, fields[:10]) yield (name, reads, writes, rbytes, wbytes, rtime, wtime, reads_merged, writes_merged, busy_time) if os.path.exists('%s/diskstats' % get_procfs_path()): gen = read_procfs() elif os.path.exists('/sys/block'): gen = read_sysfs() else: raise NotImplementedError( "%s/diskstats nor /sys/block filesystem are available on this " "system" % get_procfs_path()) retdict = {} for entry in gen: (name, reads, writes, rbytes, wbytes, rtime, wtime, reads_merged, writes_merged, busy_time) = entry if not perdisk and not is_storage_device(name): # perdisk=False means we want to calculate totals so we skip # partitions (e.g. 'sda1', 'nvme0n1p1') and only include # base disk devices (e.g. 'sda', 'nvme0n1'). Base disks # include a total of all their partitions + some extra size # of their own: # $ cat /proc/diskstats # 259 0 sda 10485760 ... # 259 1 sda1 5186039 ... # 259 1 sda2 5082039 ... # See: # https://github.com/giampaolo/psutil/pull/1313 continue rbytes = DISK_SECTOR_SIZE wbytes = DISK_SECTOR_SIZE retdict[name] = (reads, writes, rbytes, wbytes, rtime, wtime, reads_merged, writes_merged, busy_time) return retdict class RootFsDeviceFinder: """disk_partitions() may return partitions with device == "/dev/root" or "rootfs". This container class uses different strategies to try to obtain the real device path. Resources: https://bootlin.com/blog/find-root-device/ https://www.systutorials.com/how-to-find-the-disk-where-root-is-on-in-bash-on-linux/ """ __slots__ = ['major', 'minor'] def __init__(self): dev = os.stat("/").st_dev self.major = os.major(dev) self.minor = os.minor(dev) def ask_proc_partitions(self): with open_text("%s/partitions" % get_procfs_path()) as f: for line in f.readlines()[2:]: fields = line.split() if len(fields) < 4: # just for extra safety continue major = int(fields[0]) if fields[0].isdigit() else None minor = int(fields[1]) if fields[1].isdigit() else None name = fields[3] if major == self.major and minor == self.minor: if name: # just for extra safety return "/dev/%s" % name def ask_sys_dev_block(self): path = "/sys/dev/block/%s:%s/uevent" % (self.major, self.minor) with open_text(path) as f: for line in f: if line.startswith("DEVNAME="): name = line.strip().rpartition("DEVNAME=")[2] if name: # just for extra safety return "/dev/%s" % name def ask_sys_class_block(self): needle = "%s:%s" % (self.major, self.minor) files = glob.iglob("/sys/class/block//dev") for file in files: try: f = open_text(file) except FileNotFoundError: # race condition continue else: with f: data = f.read().strip() if data == needle: name = os.path.basename(os.path.dirname(file)) return "/dev/%s" % name def find(self): path = None if path is None: try: path = self.ask_proc_partitions() except (IOError, OSError) as err: debug(err) if path is None: try: path = self.ask_sys_dev_block() except (IOError, OSError) as err: debug(err) if path is None: try: path = self.ask_sys_class_block() except (IOError, OSError) as err: debug(err) # We use exists() because the "/dev/" part of the path is hard # coded, so we want to be sure. if path is not None and os.path.exists(path): return path def disk_partitions(all=False): """Return mounted disk partitions as a list of namedtuples.""" fstypes = set() procfs_path = get_procfs_path() if not all: with open_text("%s/filesystems" % procfs_path) as f: for line in f: line = line.strip() if not line.startswith("nodev"): fstypes.add(line.strip()) else: # ignore all lines starting with "nodev" except "nodev zfs" fstype = line.split("\t")[1] if fstype == "zfs": fstypes.add("zfs") # See: https://github.com/giampaolo/psutil/issues/1307 if procfs_path == "/proc" and os.path.isfile('/etc/mtab'): mounts_path = os.path.realpath("/etc/mtab") else: mounts_path = os.path.realpath("%s/self/mounts" % procfs_path) retlist = [] partitions = cext.disk_partitions(mounts_path) for partition in partitions: device, mountpoint, fstype, opts = partition if device == 'none': device = '' if device in ("/dev/root", "rootfs"): device = RootFsDeviceFinder().find() or device if not all: if device == '' or fstype not in fstypes: continue maxfile = maxpath = None # set later ntuple = _common.sdiskpart(device, mountpoint, fstype, opts, maxfile, maxpath) retlist.append(ntuple) return retlist # ===================================================================== # --- sensors # ===================================================================== def sensors_temperatures(): """Return hardware (CPU and others) temperatures as a dict including hardware name, label, current, max and critical temperatures. Implementation notes: - /sys/class/hwmon looks like the most recent interface to retrieve this info, and this implementation relies on it only (old distros will probably use something else) - lm-sensors on Ubuntu 16.04 relies on /sys/class/hwmon - /sys/class/thermal/thermal_zone* is another one but it's more difficult to parse """ ret = collections.defaultdict(list) basenames = glob.glob('/sys/class/hwmon/hwmon/temp_') # CentOS has an intermediate /device directory: # https://github.com/giampaolo/psutil/issues/971 # https://github.com/nicolargo/glances/issues/1060 basenames.extend(glob.glob('/sys/class/hwmon/hwmon/device/temp_')) basenames = sorted(set([x.split('_')[0] for x in basenames])) # Only add the coretemp hwmon entries if they're not already in # /sys/class/hwmon/ # https://github.com/giampaolo/psutil/issues/1708 # https://github.com/giampaolo/psutil/pull/1648 basenames2 = glob.glob( '/sys/devices/platform/coretemp./hwmon/hwmon/temp_') repl = re.compile('/sys/devices/platform/coretemp./hwmon/') for name in basenames2: altname = repl.sub('/sys/class/hwmon/', name) if altname not in basenames: basenames.append(name) for base in basenames: try: path = base + '_input' current = float(bcat(path)) / 1000.0 path = os.path.join(os.path.dirname(base), 'name') unit_name = cat(path).strip() except (IOError, OSError, ValueError): # A lot of things can go wrong here, so let's just skip the # whole entry. Sure thing is Linux's /sys/class/hwmon really # is a stinky broken mess. # https://github.com/giampaolo/psutil/issues/1009 # https://github.com/giampaolo/psutil/issues/1101 # https://github.com/giampaolo/psutil/issues/1129 # https://github.com/giampaolo/psutil/issues/1245 # https://github.com/giampaolo/psutil/issues/1323 continue high = bcat(base + '_max', fallback=None) critical = bcat(base + '_crit', fallback=None) label = cat(base + '_label', fallback='').strip() if high is not None: try: high = float(high) / 1000.0 except ValueError: high = None if critical is not None: try: critical = float(critical) / 1000.0 except ValueError: critical = None ret[unit_name].append((label, current, high, critical)) # Indication that no sensors were detected in /sys/class/hwmon/ if not basenames: basenames = glob.glob('/sys/class/thermal/thermal_zone') basenames = sorted(set(basenames)) for base in basenames: try: path = os.path.join(base, 'temp') current = float(bcat(path)) / 1000.0 path = os.path.join(base, 'type') unit_name = cat(path).strip() except (IOError, OSError, ValueError) as err: debug(err) continue trip_paths = glob.glob(base + '/trip_point') trip_points = set(['_'.join( os.path.basename(p).split('_')[0:3]) for p in trip_paths]) critical = None high = None for trip_point in trip_points: path = os.path.join(base, trip_point + "_type") trip_type = cat(path, fallback='').strip() if trip_type == 'critical': critical = bcat(os.path.join(base, trip_point + "_temp"), fallback=None) elif trip_type == 'high': high = bcat(os.path.join(base, trip_point + "_temp"), fallback=None) if high is not None: try: high = float(high) / 1000.0 except ValueError: high = None if critical is not None: try: critical = float(critical) / 1000.0 except ValueError: critical = None ret[unit_name].append(('', current, high, critical)) return dict(ret) def sensors_fans(): """Return hardware fans info (for CPU and other peripherals) as a dict including hardware label and current speed. Implementation notes: - /sys/class/hwmon looks like the most recent interface to retrieve this info, and this implementation relies on it only (old distros will probably use something else) - lm-sensors on Ubuntu 16.04 relies on /sys/class/hwmon """ ret = collections.defaultdict(list) basenames = glob.glob('/sys/class/hwmon/hwmon/fan_') if not basenames: # CentOS has an intermediate /device directory: # https://github.com/giampaolo/psutil/issues/971 basenames = glob.glob('/sys/class/hwmon/hwmon/device/fan_') basenames = sorted(set([x.split('_')[0] for x in basenames])) for base in basenames: try: current = int(bcat(base + '_input')) except (IOError, OSError) as err: debug(err) continue unit_name = cat(os.path.join(os.path.dirname(base), 'name')).strip() label = cat(base + '_label', fallback='').strip() ret[unit_name].append(_common.sfan(label, current)) return dict(ret) def sensors_battery(): """Return battery information. Implementation note: it appears /sys/class/power_supply/BAT0/ directory structure may vary and provide files with the same meaning but under different names, see: https://github.com/giampaolo/psutil/issues/966 """ null = object() def multi_bcat(paths): """Attempt to read the content of multiple files which may not exist. If none of them exist return None. """ for path in paths: ret = bcat(path, fallback=null) if ret != null: try: return int(ret) except ValueError: return ret.strip() return None bats = [x for x in os.listdir(POWER_SUPPLY_PATH) if x.startswith('BAT') or 'battery' in x.lower()] if not bats: return None # Get the first available battery. Usually this is "BAT0", except # some rare exceptions: # https://github.com/giampaolo/psutil/issues/1238 root = os.path.join(POWER_SUPPLY_PATH, sorted(bats)[0]) # Base metrics. energy_now = multi_bcat( root + "/energy_now", root + "/charge_now") power_now = multi_bcat( root + "/power_now", root + "/current_now") energy_full = multi_bcat( root + "/energy_full", root + "/charge_full") time_to_empty = multi_bcat(root + "/time_to_empty_now") # Percent. If we have energy_full the percentage will be more # accurate compared to reading /capacity file (float vs. int). if energy_full is not None and energy_now is not None: try: percent = 100.0 * energy_now / energy_full except ZeroDivisionError: percent = 0.0 else: percent = int(cat(root + "/capacity", fallback=-1)) if percent == -1: return None # Is AC power cable plugged in? # Note: AC0 is not always available and sometimes (e.g. CentOS7) # it's called "AC". power_plugged = None online = multi_bcat( os.path.join(POWER_SUPPLY_PATH, "AC0/online"), os.path.join(POWER_SUPPLY_PATH, "AC/online")) if online is not None: power_plugged = online == 1 else: status = cat(root + "/status", fallback="").strip().lower() if status == "discharging": power_plugged = False elif status in ("charging", "full"): power_plugged = True # Seconds left. # Note to self: we may also calculate the charging ETA as per: # https://github.com/thialfihar/dotfiles/blob/ # 013937745fd9050c30146290e8f963d65c0179e6/bin/battery.py#L55 if power_plugged: secsleft = _common.POWER_TIME_UNLIMITED elif energy_now is not None and power_now is not None: try: secsleft = int(energy_now / power_now * 3600) except ZeroDivisionError: secsleft = _common.POWER_TIME_UNKNOWN elif time_to_empty is not None: secsleft = int(time_to_empty * 60) if secsleft < 0: secsleft = _common.POWER_TIME_UNKNOWN else: secsleft = _common.POWER_TIME_UNKNOWN return _common.sbattery(percent, secsleft, power_plugged) # ===================================================================== # --- other system functions # ===================================================================== def users(): """Return currently connected users as a list of namedtuples.""" retlist = [] rawlist = cext.users() for item in rawlist: user, tty, hostname, tstamp, user_process, pid = item # note: the underlying C function includes entries about # system boot, run level and others. We might want # to use them in the future. if not user_process: continue if hostname in (':0.0', ':0'): hostname = 'localhost' nt = _common.suser(user, tty or None, hostname, tstamp, pid) retlist.append(nt) return retlist def boot_time(): """Return the system boot time expressed in seconds since the epoch.""" global BOOT_TIME path = '%s/stat' % get_procfs_path() with open_binary(path) as f: for line in f: if line.startswith(b'btime'): ret = float(line.strip().split()[1]) BOOT_TIME = ret return ret raise RuntimeError( "line 'btime' not found in %s" % path) # ===================================================================== # --- processes # ===================================================================== def pids(): """Returns a list of PIDs currently running on the system.""" return [int(x) for x in os.listdir(b(get_procfs_path())) if x.isdigit()] def pid_exists(pid): """Check for the existence of a unix PID. Linux TIDs are not supported (always return False). """ if not _psposix.pid_exists(pid): return False else: # Linux's apparently does not distinguish between PIDs and TIDs # (thread IDs). # listdir("/proc") won't show any TID (only PIDs) but # os.stat("/proc/{tid}") will succeed if {tid} exists. # os.kill() can also be passed a TID. This is quite confusing. # In here we want to enforce this distinction and support PIDs # only, see: # https://github.com/giampaolo/psutil/issues/687 try: # Note: already checked that this is faster than using a # regular expr. Also (a lot) faster than doing # 'return pid in pids()' path = "%s/%s/status" % (get_procfs_path(), pid) with open_binary(path) as f: for line in f: if line.startswith(b"Tgid:"): tgid = int(line.split()[1]) # If tgid and pid are the same then we're # dealing with a process PID. return tgid == pid raise ValueError("'Tgid' line not found in %s" % path) except (EnvironmentError, ValueError): return pid in pids() def ppid_map(): """Obtain a {pid: ppid, ...} dict for all running processes in one shot. Used to speed up Process.children(). """ ret = {} procfs_path = get_procfs_path() for pid in pids(): try: with open_binary("%s/%s/stat" % (procfs_path, pid)) as f: data = f.read() except (FileNotFoundError, ProcessLookupError): # Note: we should be able to access /stat for all processes # aka it's unlikely we'll bump into EPERM, which is good. pass else: rpar = data.rfind(b')') dset = data[rpar + 2:].split() ppid = int(dset[1]) ret[pid] = ppid return ret def wrap_exceptions(fun): """Decorator which translates bare OSError and IOError exceptions into NoSuchProcess and AccessDenied. """ @functools.wraps(fun) def wrapper(self, args, kwargs): try: return fun(self, args, *kwargs) except PermissionError: raise AccessDenied(self.pid, self._name) except ProcessLookupError: raise NoSuchProcess(self.pid, self._name) except FileNotFoundError: if not os.path.exists("%s/%s" % (self._procfs_path, self.pid)): raise NoSuchProcess(self.pid, self._name) # Note: zombies will keep existing under /proc until they're # gone so there's no way to distinguish them in here. raise return wrapper class Process(object): """Linux process implementation.""" __slots__ = ["pid", "_name", "_ppid", "_procfs_path", "_cache"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None self._procfs_path = get_procfs_path() def _assert_alive(self): """Raise NSP if the process disappeared on us.""" # For those C function who do not raise NSP, possibly returning # incorrect or incomplete result. os.stat('%s/%s' % (self._procfs_path, self.pid)) @wrap_exceptions @memoize_when_activated def _parse_stat_file(self): """Parse /proc/{pid}/stat file and return a dict with various process info. Using "man proc" as a reference: where "man proc" refers to position N always subtract 3 (e.g ppid position 4 in 'man proc' == position 1 in here). The return value is cached in case oneshot() ctx manager is in use. """ data = bcat("%s/%s/stat" % (self._procfs_path, self.pid)) # Process name is between parentheses. It can contain spaces and # other parentheses. This is taken into account by looking for # the first occurrence of "(" and the last occurrence of ")". rpar = data.rfind(b')') name = data[data.find(b'(') + 1:rpar] fields = data[rpar + 2:].split() ret = {} ret['name'] = name ret['status'] = fields[0] ret['ppid'] = fields[1] ret['ttynr'] = fields[4] ret['utime'] = fields[11] ret['stime'] = fields[12] ret['children_utime'] = fields[13] ret['children_stime'] = fields[14] ret['create_time'] = fields[19] ret['cpu_num'] = fields[36] ret['blkio_ticks'] = fields[39] # aka 'delayacct_blkio_ticks' return ret @wrap_exceptions @memoize_when_activated def _read_status_file(self): """Read /proc/{pid}/stat file and return its content. The return value is cached in case oneshot() ctx manager is in use. """ with open_binary("%s/%s/status" % (self._procfs_path, self.pid)) as f: return f.read() @wrap_exceptions @memoize_when_activated def _read_smaps_file(self): with open_binary("%s/%s/smaps" % (self._procfs_path, self.pid)) as f: return f.read().strip() def oneshot_enter(self): self._parse_stat_file.cache_activate(self) self._read_status_file.cache_activate(self) self._read_smaps_file.cache_activate(self) def oneshot_exit(self): self._parse_stat_file.cache_deactivate(self) self._read_status_file.cache_deactivate(self) self._read_smaps_file.cache_deactivate(self) @wrap_exceptions def name(self): name = self._parse_stat_file()['name'] if PY3: name = decode(name) # XXX - gets changed later and probably needs refactoring return name def exe(self): try: return readlink("%s/%s/exe" % (self._procfs_path, self.pid)) except (FileNotFoundError, ProcessLookupError): # no such file error; might be raised also if the # path actually exists for system processes with # low pids (about 0-20) if os.path.lexists("%s/%s" % (self._procfs_path, self.pid)): return "" else: if not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name) else: raise ZombieProcess(self.pid, self._name, self._ppid) except PermissionError: raise AccessDenied(self.pid, self._name) @wrap_exceptions def cmdline(self): with open_text("%s/%s/cmdline" % (self._procfs_path, self.pid)) as f: data = f.read() if not data: # may happen in case of zombie process return [] # 'man proc' states that args are separated by null bytes '\0' # and last char is supposed to be a null byte. Nevertheless # some processes may change their cmdline after being started # (via setproctitle() or similar), they are usually not # compliant with this rule and use spaces instead. Google # Chrome process is an example. See: # https://github.com/giampaolo/psutil/issues/1179 sep = '\x00' if data.endswith('\x00') else ' ' if data.endswith(sep): data = data[:-1] cmdline = data.split(sep) # Sometimes last char is a null byte '\0' but the args are # separated by spaces, see: https://github.com/giampaolo/psutil/ # issues/1179#issuecomment-552984549 if sep == '\x00' and len(cmdline) == 1 and ' ' in data: cmdline = data.split(' ') return cmdline @wrap_exceptions def environ(self): with open_text("%s/%s/environ" % (self._procfs_path, self.pid)) as f: data = f.read() return parse_environ_block(data) @wrap_exceptions def terminal(self): tty_nr = int(self._parse_stat_file()['ttynr']) tmap = _psposix.get_terminal_map() try: return tmap[tty_nr] except KeyError: return None # May not be available on old kernels. if os.path.exists('/proc/%s/io' % os.getpid()): @wrap_exceptions def io_counters(self): fname = "%s/%s/io" % (self._procfs_path, self.pid) fields = {} with open_binary(fname) as f: for line in f: # https://github.com/giampaolo/psutil/issues/1004 line = line.strip() if line: try: name, value = line.split(b': ') except ValueError: # https://github.com/giampaolo/psutil/issues/1004 continue else: fields[name] = int(value) if not fields: raise RuntimeError("%s file was empty" % fname) try: return pio( fields[b'syscr'], # read syscalls fields[b'syscw'], # write syscalls fields[b'read_bytes'], # read bytes fields[b'write_bytes'], # write bytes fields[b'rchar'], # read chars fields[b'wchar'], # write chars ) except KeyError as err: raise ValueError("%r field was not found in %s; found fields " "are %r" % (err.args[0], fname, fields)) @wrap_exceptions def cpu_times(self): values = self._parse_stat_file() utime = float(values['utime']) / CLOCK_TICKS stime = float(values['stime']) / CLOCK_TICKS children_utime = float(values['children_utime']) / CLOCK_TICKS children_stime = float(values['children_stime']) / CLOCK_TICKS iowait = float(values['blkio_ticks']) / CLOCK_TICKS return pcputimes(utime, stime, children_utime, children_stime, iowait) @wrap_exceptions def cpu_num(self): """What CPU the process is on.""" return int(self._parse_stat_file()['cpu_num']) @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout, self._name) @wrap_exceptions def create_time(self): ctime = float(self._parse_stat_file()['create_time']) # According to documentation, starttime is in field 21 and the # unit is jiffies (clock ticks). # We first divide it for clock ticks and then add uptime returning # seconds since the epoch. # Also use cached value if available. bt = BOOT_TIME or boot_time() return (ctime / CLOCK_TICKS) + bt @wrap_exceptions def memory_info(self): # ============================================================ # \| FIELD \| DESCRIPTION \| AKA \| TOP \| # ============================================================ # \| rss \| resident set size \| \| RES \| # \| vms \| total program size \| size \| VIRT \| # \| shared \| shared pages (from shared mappings) \| \| SHR \| # \| text \| text ('code') \| trs \| CODE \| # \| lib \| library (unused in Linux 2.6) \| lrs \| \| # \| data \| data + stack \| drs \| DATA \| # \| dirty \| dirty pages (unused in Linux 2.6) \| dt \| \| # ============================================================ with open_binary("%s/%s/statm" % (self._procfs_path, self.pid)) as f: vms, rss, shared, text, lib, data, dirty = \ [int(x) PAGESIZE for x in f.readline().split()[:7]] return pmem(rss, vms, shared, text, lib, data, dirty) if HAS_PROC_SMAPS_ROLLUP or HAS_PROC_SMAPS: @wrap_exceptions def _parse_smaps_rollup(self): # /proc/pid/smaps_rollup was added to Linux in 2017. Faster # than /proc/pid/smaps. It reports higher PSS than /smaps # (from 1k up to 200k higher; tested against all processes). uss = pss = swap = 0 try: with open_binary("{}/{}/smaps_rollup".format( self._procfs_path, self.pid)) as f: for line in f: if line.startswith(b"Private_"): # Private_Clean, Private_Dirty, Private_Hugetlb uss += int(line.split()[1]) 1024 elif line.startswith(b"Pss:"): pss = int(line.split()[1]) * 1024 elif line.startswith(b"Swap:"): swap = int(line.split()[1]) * 1024 except ProcessLookupError: # happens on readline() if not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name) else: raise ZombieProcess(self.pid, self._name, self._ppid) return (uss, pss, swap) @wrap_exceptions def _parse_smaps( self, # Gets Private_Clean, Private_Dirty, Private_Hugetlb. _private_re=re.compile(br"\nPrivate.:\s+(\d+)"), _pss_re=re.compile(br"\nPss\:\s+(\d+)"), _swap_re=re.compile(br"\nSwap\:\s+(\d+)")): # /proc/pid/smaps does not exist on kernels < 2.6.14 or if # CONFIG_MMU kernel configuration option is not enabled. # Note: using 3 regexes is faster than reading the file # line by line. # XXX: on Python 3 the 2 regexes are 30% slower than on # Python 2 though. Figure out why. # # You might be tempted to calculate USS by subtracting # the "shared" value from the "resident" value in # /proc/<pid>/statm. But at least on Linux, statm's "shared" # value actually counts pages backed by files, which has # little to do with whether the pages are actually shared. # /proc/self/smaps on the other hand appears to give us the # correct information. smaps_data = self._read_smaps_file() # Note: smaps file can be empty for certain processes. # The code below will not crash though and will result to 0. uss = sum(map(int, _private_re.findall(smaps_data))) 1024 pss = sum(map(int, _pss_re.findall(smaps_data))) * 1024 swap = sum(map(int, _swap_re.findall(smaps_data))) * 1024 return (uss, pss, swap) def memory_full_info(self): if HAS_PROC_SMAPS_ROLLUP: # faster uss, pss, swap = self._parse_smaps_rollup() else: uss, pss, swap = self._parse_smaps() basic_mem = self.memory_info() return pfullmem(basic_mem + (uss, pss, swap)) else: memory_full_info = memory_info if HAS_PROC_SMAPS: @wrap_exceptions def memory_maps(self): """Return process's mapped memory regions as a list of named tuples. Fields are explained in 'man proc'; here is an updated (Apr 2012) version: http://goo.gl/fmebo /proc/{PID}/smaps does not exist on kernels < 2.6.14 or if CONFIG_MMU kernel configuration option is not enabled. """ def get_blocks(lines, current_block): data = {} for line in lines: fields = line.split(None, 5) if not fields[0].endswith(b':'): # new block section yield (current_block.pop(), data) current_block.append(line) else: try: data[fields[0]] = int(fields[1]) 1024 except ValueError: if fields[0].startswith(b'VmFlags:'): # see issue #369 continue else: raise ValueError("don't know how to inte" "rpret line %r" % line) yield (current_block.pop(), data) data = self._read_smaps_file() # Note: smaps file can be empty for certain processes. if not data: return [] lines = data.split(b'\n') ls = [] first_line = lines.pop(0) current_block = [first_line] for header, data in get_blocks(lines, current_block): hfields = header.split(None, 5) try: addr, perms, offset, dev, inode, path = hfields except ValueError: addr, perms, offset, dev, inode, path = \ hfields + [''] if not path: path = '[anon]' else: if PY3: path = decode(path) path = path.strip() if (path.endswith(' (deleted)') and not path_exists_strict(path)): path = path[:-10] ls.append(( decode(addr), decode(perms), path, data.get(b'Rss:', 0), data.get(b'Size:', 0), data.get(b'Pss:', 0), data.get(b'Shared_Clean:', 0), data.get(b'Shared_Dirty:', 0), data.get(b'Private_Clean:', 0), data.get(b'Private_Dirty:', 0), data.get(b'Referenced:', 0), data.get(b'Anonymous:', 0), data.get(b'Swap:', 0) )) return ls @wrap_exceptions def cwd(self): try: return readlink("%s/%s/cwd" % (self._procfs_path, self.pid)) except (FileNotFoundError, ProcessLookupError): # https://github.com/giampaolo/psutil/issues/986 if not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name) else: raise ZombieProcess(self.pid, self._name, self._ppid) @wrap_exceptions def num_ctx_switches(self, _ctxsw_re=re.compile(br'ctxt_switches:\t(\d+)')): data = self._read_status_file() ctxsw = _ctxsw_re.findall(data) if not ctxsw: raise NotImplementedError( "'voluntary_ctxt_switches' and 'nonvoluntary_ctxt_switches'" "lines were not found in %s/%s/status; the kernel is " "probably older than 2.6.23" % ( self._procfs_path, self.pid)) else: return _common.pctxsw(int(ctxsw[0]), int(ctxsw[1])) @wrap_exceptions def num_threads(self, _num_threads_re=re.compile(br'Threads:\t(\d+)')): # Note: on Python 3 using a re is faster than iterating over file # line by line. On Python 2 is the exact opposite, and iterating # over a file on Python 3 is slower than on Python 2. data = self._read_status_file() return int(_num_threads_re.findall(data)[0]) @wrap_exceptions def threads(self): thread_ids = os.listdir("%s/%s/task" % (self._procfs_path, self.pid)) thread_ids.sort() retlist = [] hit_enoent = False for thread_id in thread_ids: fname = "%s/%s/task/%s/stat" % ( self._procfs_path, self.pid, thread_id) try: with open_binary(fname) as f: st = f.read().strip() except (FileNotFoundError, ProcessLookupError): # no such file or directory or no such process; # it means thread disappeared on us hit_enoent = True continue # ignore the first two values ("pid (exe)") st = st[st.find(b')') + 2:] values = st.split(b' ') utime = float(values[11]) / CLOCK_TICKS stime = float(values[12]) / CLOCK_TICKS ntuple = _common.pthread(int(thread_id), utime, stime) retlist.append(ntuple) if hit_enoent: self._assert_alive() return retlist @wrap_exceptions def nice_get(self): # with open_text('%s/%s/stat' % (self._procfs_path, self.pid)) as f: # data = f.read() # return int(data.split()[18]) # Use C implementation return cext_posix.getpriority(self.pid) @wrap_exceptions def nice_set(self, value): return cext_posix.setpriority(self.pid, value) # starting from CentOS 6. if HAS_CPU_AFFINITY: @wrap_exceptions def cpu_affinity_get(self): return cext.proc_cpu_affinity_get(self.pid) def _get_eligible_cpus( self, _re=re.compile(br"Cpus_allowed_list:\t(\d+)-(\d+)")): # See: https://github.com/giampaolo/psutil/issues/956 data = self._read_status_file() match = _re.findall(data) if match: return list(range(int(match[0][0]), int(match[0][1]) + 1)) else: return list(range(len(per_cpu_times()))) @wrap_exceptions def cpu_affinity_set(self, cpus): try: cext.proc_cpu_affinity_set(self.pid, cpus) except (OSError, ValueError) as err: if isinstance(err, ValueError) or err.errno == errno.EINVAL: eligible_cpus = self._get_eligible_cpus() all_cpus = tuple(range(len(per_cpu_times()))) for cpu in cpus: if cpu not in all_cpus: raise ValueError( "invalid CPU number %r; choose between %s" % ( cpu, eligible_cpus)) if cpu not in eligible_cpus: raise ValueError( "CPU number %r is not eligible; choose " "between %s" % (cpu, eligible_cpus)) raise # only starting from kernel 2.6.13 if HAS_PROC_IO_PRIORITY: @wrap_exceptions def ionice_get(self): ioclass, value = cext.proc_ioprio_get(self.pid) if enum is not None: ioclass = IOPriority(ioclass) return _common.pionice(ioclass, value) @wrap_exceptions def ionice_set(self, ioclass, value): if value is None: value = 0 if value and ioclass in (IOPRIO_CLASS_IDLE, IOPRIO_CLASS_NONE): raise ValueError("%r ioclass accepts no value" % ioclass) if value < 0 or value > 7: raise ValueError("value not in 0-7 range") return cext.proc_ioprio_set(self.pid, ioclass, value) if prlimit is not None: @wrap_exceptions def rlimit(self, resource_, limits=None): # If pid is 0 prlimit() applies to the calling process and # we don't want that. We should never get here though as # PID 0 is not supported on Linux. if self.pid == 0: raise ValueError("can't use prlimit() against PID 0 process") try: if limits is None: # get return prlimit(self.pid, resource_) else: # set if len(limits) != 2: raise ValueError( "second argument must be a (soft, hard) tuple, " "got %s" % repr(limits)) prlimit(self.pid, resource_, limits) except OSError as err: if err.errno == errno.ENOSYS and pid_exists(self.pid): # I saw this happening on Travis: # https://travis-ci.org/giampaolo/psutil/jobs/51368273 raise ZombieProcess(self.pid, self._name, self._ppid) else: raise @wrap_exceptions def status(self): letter = self._parse_stat_file()['status'] if PY3: letter = letter.decode() # XXX is '?' legit? (we're not supposed to return it anyway) return PROC_STATUSES.get(letter, '?') @wrap_exceptions def open_files(self): retlist = [] files = os.listdir("%s/%s/fd" % (self._procfs_path, self.pid)) hit_enoent = False for fd in files: file = "%s/%s/fd/%s" % (self._procfs_path, self.pid, fd) try: path = readlink(file) except (FileNotFoundError, ProcessLookupError): # ENOENT == file which is gone in the meantime hit_enoent = True continue except OSError as err: if err.errno == errno.EINVAL: # not a link continue if err.errno == errno.ENAMETOOLONG: # file name too long debug(err) continue raise else: # If path is not an absolute there's no way to tell # whether it's a regular file or not, so we skip it. # A regular file is always supposed to be have an # absolute path though. if path.startswith('/') and isfile_strict(path): # Get file position and flags. file = "%s/%s/fdinfo/%s" % ( self._procfs_path, self.pid, fd) try: with open_binary(file) as f: pos = int(f.readline().split()[1]) flags = int(f.readline().split()[1], 8) except (FileNotFoundError, ProcessLookupError): # fd gone in the meantime; process may # still be alive hit_enoent = True else: mode = file_flags_to_mode(flags) ntuple = popenfile( path, int(fd), int(pos), mode, flags) retlist.append(ntuple) if hit_enoent: self._assert_alive() return retlist @wrap_exceptions def connections(self, kind='inet'): ret = _connections.retrieve(kind, self.pid) self._assert_alive() return ret @wrap_exceptions def num_fds(self): return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid))) @wrap_exceptions def ppid(self): return int(self._parse_stat_file()['ppid']) @wrap_exceptions def uids(self, _uids_re=re.compile(br'Uid:\t(\d+)\t(\d+)\t(\d+)')): data = self._read_status_file() real, effective, saved = _uids_re.findall(data)[0] return _common.puids(int(real), int(effective), int(saved)) @wrap_exceptions def gids(self, _gids_re=re.compile(br'Gid:\t(\d+)\t(\d+)\t(\d+)')): data = self._read_status_file() real, effective, saved = _gids_re.findall(data)[0] return _common.pgids(int(real), int(effective), int(saved))	84.88 KB	2026-01-20 12:58
📄 _psosx.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """macOS platform implementation.""" import errno import functools import os from collections import namedtuple from . import _common from . import _psposix from . import _psutil_osx as cext from . import _psutil_posix as cext_posix from ._common import AccessDenied from ._common import NoSuchProcess from ._common import ZombieProcess from ._common import conn_tmap from ._common import conn_to_ntuple from ._common import isfile_strict from ._common import memoize_when_activated from ._common import parse_environ_block from ._common import usage_percent from ._compat import PermissionError from ._compat import ProcessLookupError __extra__all__ = [] # ===================================================================== # --- globals # ===================================================================== PAGESIZE = cext_posix.getpagesize() AF_LINK = cext_posix.AF_LINK TCP_STATUSES = { cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT, cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT, cext.TCPS_CLOSED: _common.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK, cext.TCPS_LISTEN: _common.CONN_LISTEN, cext.TCPS_CLOSING: _common.CONN_CLOSING, cext.PSUTIL_CONN_NONE: _common.CONN_NONE, } PROC_STATUSES = { cext.SIDL: _common.STATUS_IDLE, cext.SRUN: _common.STATUS_RUNNING, cext.SSLEEP: _common.STATUS_SLEEPING, cext.SSTOP: _common.STATUS_STOPPED, cext.SZOMB: _common.STATUS_ZOMBIE, } kinfo_proc_map = dict( ppid=0, ruid=1, euid=2, suid=3, rgid=4, egid=5, sgid=6, ttynr=7, ctime=8, status=9, name=10, ) pidtaskinfo_map = dict( cpuutime=0, cpustime=1, rss=2, vms=3, pfaults=4, pageins=5, numthreads=6, volctxsw=7, ) # ===================================================================== # --- named tuples # ===================================================================== # psutil.cpu_times() scputimes = namedtuple('scputimes', ['user', 'nice', 'system', 'idle']) # psutil.virtual_memory() svmem = namedtuple( 'svmem', ['total', 'available', 'percent', 'used', 'free', 'active', 'inactive', 'wired']) # psutil.Process.memory_info() pmem = namedtuple('pmem', ['rss', 'vms', 'pfaults', 'pageins']) # psutil.Process.memory_full_info() pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', )) # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): """System virtual memory as a namedtuple.""" total, active, inactive, wired, free, speculative = cext.virtual_mem() # This is how Zabbix calculate avail and used mem: # https://github.com/zabbix/zabbix/blob/trunk/src/libs/zbxsysinfo/ # osx/memory.c # Also see: https://github.com/giampaolo/psutil/issues/1277 avail = inactive + free used = active + wired # This is NOT how Zabbix calculates free mem but it matches "free" # cmdline utility. free -= speculative percent = usage_percent((total - avail), total, round_=1) return svmem(total, avail, percent, used, free, active, inactive, wired) def swap_memory(): """Swap system memory as a (total, used, free, sin, sout) tuple.""" total, used, free, sin, sout = cext.swap_mem() percent = usage_percent(used, total, round_=1) return _common.sswap(total, used, free, percent, sin, sout) # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system CPU times as a namedtuple.""" user, nice, system, idle = cext.cpu_times() return scputimes(user, nice, system, idle) def per_cpu_times(): """Return system CPU times as a named tuple""" ret = [] for cpu_t in cext.per_cpu_times(): user, nice, system, idle = cpu_t item = scputimes(user, nice, system, idle) ret.append(item) return ret def cpu_count_logical(): """Return the number of logical CPUs in the system.""" return cext.cpu_count_logical() def cpu_count_cores(): """Return the number of CPU cores in the system.""" return cext.cpu_count_cores() def cpu_stats(): ctx_switches, interrupts, soft_interrupts, syscalls, traps = \ cext.cpu_stats() return _common.scpustats( ctx_switches, interrupts, soft_interrupts, syscalls) def cpu_freq(): """Return CPU frequency. On macOS per-cpu frequency is not supported. Also, the returned frequency never changes, see: https://arstechnica.com/civis/viewtopic.php?f=19&t=465002 """ curr, min_, max_ = cext.cpu_freq() return [_common.scpufreq(curr, min_, max_)] # ===================================================================== # --- disks # ===================================================================== disk_usage = _psposix.disk_usage disk_io_counters = cext.disk_io_counters def disk_partitions(all=False): """Return mounted disk partitions as a list of namedtuples.""" retlist = [] partitions = cext.disk_partitions() for partition in partitions: device, mountpoint, fstype, opts = partition if device == 'none': device = '' if not all: if not os.path.isabs(device) or not os.path.exists(device): continue maxfile = maxpath = None # set later ntuple = _common.sdiskpart(device, mountpoint, fstype, opts, maxfile, maxpath) retlist.append(ntuple) return retlist # ===================================================================== # --- sensors # ===================================================================== def sensors_battery(): """Return battery information.""" try: percent, minsleft, power_plugged = cext.sensors_battery() except NotImplementedError: # no power source - return None according to interface return None power_plugged = power_plugged == 1 if power_plugged: secsleft = _common.POWER_TIME_UNLIMITED elif minsleft == -1: secsleft = _common.POWER_TIME_UNKNOWN else: secsleft = minsleft * 60 return _common.sbattery(percent, secsleft, power_plugged) # ===================================================================== # --- network # ===================================================================== net_io_counters = cext.net_io_counters net_if_addrs = cext_posix.net_if_addrs def net_connections(kind='inet'): """System-wide network connections.""" # Note: on macOS this will fail with AccessDenied unless # the process is owned by root. ret = [] for pid in pids(): try: cons = Process(pid).connections(kind) except NoSuchProcess: continue else: if cons: for c in cons: c = list(c) + [pid] ret.append(_common.sconn(c)) return ret def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" names = net_io_counters().keys() ret = {} for name in names: try: mtu = cext_posix.net_if_mtu(name) flags = cext_posix.net_if_flags(name) duplex, speed = cext_posix.net_if_duplex_speed(name) except OSError as err: # https://github.com/giampaolo/psutil/issues/1279 if err.errno != errno.ENODEV: raise else: if hasattr(_common, 'NicDuplex'): duplex = _common.NicDuplex(duplex) output_flags = ','.join(flags) isup = 'running' in flags ret[name] = _common.snicstats(isup, duplex, speed, mtu, output_flags) return ret # ===================================================================== # --- other system functions # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() def users(): """Return currently connected users as a list of namedtuples.""" retlist = [] rawlist = cext.users() for item in rawlist: user, tty, hostname, tstamp, pid = item if tty == '~': continue # reboot or shutdown if not tstamp: continue nt = _common.suser(user, tty or None, hostname or None, tstamp, pid) retlist.append(nt) return retlist # ===================================================================== # --- processes # ===================================================================== def pids(): ls = cext.pids() if 0 not in ls: # On certain macOS versions pids() C doesn't return PID 0 but # "ps" does and the process is querable via sysctl(): # https://travis-ci.org/giampaolo/psutil/jobs/309619941 try: Process(0).create_time() ls.insert(0, 0) except NoSuchProcess: pass except AccessDenied: ls.insert(0, 0) return ls pid_exists = _psposix.pid_exists def is_zombie(pid): try: st = cext.proc_kinfo_oneshot(pid)[kinfo_proc_map['status']] return st == cext.SZOMB except Exception: return False def wrap_exceptions(fun): """Decorator which translates bare OSError exceptions into NoSuchProcess and AccessDenied. """ @functools.wraps(fun) def wrapper(self, args, *kwargs): try: return fun(self, args, *kwargs) except ProcessLookupError: if is_zombie(self.pid): raise ZombieProcess(self.pid, self._name, self._ppid) else: raise NoSuchProcess(self.pid, self._name) except PermissionError: raise AccessDenied(self.pid, self._name) except cext.ZombieProcessError: raise ZombieProcess(self.pid, self._name, self._ppid) return wrapper class Process(object): """Wrapper class around underlying C implementation.""" __slots__ = ["pid", "_name", "_ppid", "_cache"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None @wrap_exceptions @memoize_when_activated def _get_kinfo_proc(self): # Note: should work with all PIDs without permission issues. ret = cext.proc_kinfo_oneshot(self.pid) assert len(ret) == len(kinfo_proc_map) return ret @wrap_exceptions @memoize_when_activated def _get_pidtaskinfo(self): # Note: should work for PIDs owned by user only. ret = cext.proc_pidtaskinfo_oneshot(self.pid) assert len(ret) == len(pidtaskinfo_map) return ret def oneshot_enter(self): self._get_kinfo_proc.cache_activate(self) self._get_pidtaskinfo.cache_activate(self) def oneshot_exit(self): self._get_kinfo_proc.cache_deactivate(self) self._get_pidtaskinfo.cache_deactivate(self) @wrap_exceptions def name(self): name = self._get_kinfo_proc()[kinfo_proc_map['name']] return name if name is not None else cext.proc_name(self.pid) @wrap_exceptions def exe(self): return cext.proc_exe(self.pid) @wrap_exceptions def cmdline(self): return cext.proc_cmdline(self.pid) @wrap_exceptions def environ(self): return parse_environ_block(cext.proc_environ(self.pid)) @wrap_exceptions def ppid(self): self._ppid = self._get_kinfo_proc()[kinfo_proc_map['ppid']] return self._ppid @wrap_exceptions def cwd(self): return cext.proc_cwd(self.pid) @wrap_exceptions def uids(self): rawtuple = self._get_kinfo_proc() return _common.puids( rawtuple[kinfo_proc_map['ruid']], rawtuple[kinfo_proc_map['euid']], rawtuple[kinfo_proc_map['suid']]) @wrap_exceptions def gids(self): rawtuple = self._get_kinfo_proc() return _common.puids( rawtuple[kinfo_proc_map['rgid']], rawtuple[kinfo_proc_map['egid']], rawtuple[kinfo_proc_map['sgid']]) @wrap_exceptions def terminal(self): tty_nr = self._get_kinfo_proc()[kinfo_proc_map['ttynr']] tmap = _psposix.get_terminal_map() try: return tmap[tty_nr] except KeyError: return None @wrap_exceptions def memory_info(self): rawtuple = self._get_pidtaskinfo() return pmem( rawtuple[pidtaskinfo_map['rss']], rawtuple[pidtaskinfo_map['vms']], rawtuple[pidtaskinfo_map['pfaults']], rawtuple[pidtaskinfo_map['pageins']], ) @wrap_exceptions def memory_full_info(self): basic_mem = self.memory_info() uss = cext.proc_memory_uss(self.pid) return pfullmem(basic_mem + (uss, )) @wrap_exceptions def cpu_times(self): rawtuple = self._get_pidtaskinfo() return _common.pcputimes( rawtuple[pidtaskinfo_map['cpuutime']], rawtuple[pidtaskinfo_map['cpustime']], # children user / system times are not retrievable (set to 0) 0.0, 0.0) @wrap_exceptions def create_time(self): return self._get_kinfo_proc()[kinfo_proc_map['ctime']] @wrap_exceptions def num_ctx_switches(self): # Unvoluntary value seems not to be available; # getrusage() numbers seems to confirm this theory. # We set it to 0. vol = self._get_pidtaskinfo()[pidtaskinfo_map['volctxsw']] return _common.pctxsw(vol, 0) @wrap_exceptions def num_threads(self): return self._get_pidtaskinfo()[pidtaskinfo_map['numthreads']] @wrap_exceptions def open_files(self): if self.pid == 0: return [] files = [] rawlist = cext.proc_open_files(self.pid) for path, fd in rawlist: if isfile_strict(path): ntuple = _common.popenfile(path, fd) files.append(ntuple) return files @wrap_exceptions def connections(self, kind='inet'): if kind not in conn_tmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in conn_tmap]))) families, types = conn_tmap[kind] rawlist = cext.proc_connections(self.pid, families, types) ret = [] for item in rawlist: fd, fam, type, laddr, raddr, status = item nt = conn_to_ntuple(fd, fam, type, laddr, raddr, status, TCP_STATUSES) ret.append(nt) return ret @wrap_exceptions def num_fds(self): if self.pid == 0: return 0 return cext.proc_num_fds(self.pid) @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout, self._name) @wrap_exceptions def nice_get(self): return cext_posix.getpriority(self.pid) @wrap_exceptions def nice_set(self, value): return cext_posix.setpriority(self.pid, value) @wrap_exceptions def status(self): code = self._get_kinfo_proc()[kinfo_proc_map['status']] # XXX is '?' legit? (we're not supposed to return it anyway) return PROC_STATUSES.get(code, '?') @wrap_exceptions def threads(self): rawlist = cext.proc_threads(self.pid) retlist = [] for thread_id, utime, stime in rawlist: ntuple = _common.pthread(thread_id, utime, stime) retlist.append(ntuple) return retlist	15.89 KB	2026-01-20 12:58
📄 _psposix.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Routines common to all posix systems.""" import glob import os import signal import sys import time from ._common import MACOS from ._common import TimeoutExpired from ._common import memoize from ._common import sdiskusage from ._common import usage_percent from ._compat import PY3 from ._compat import ChildProcessError from ._compat import FileNotFoundError from ._compat import InterruptedError from ._compat import PermissionError from ._compat import ProcessLookupError from ._compat import unicode if MACOS: from . import _psutil_osx if sys.version_info >= (3, 4): import enum else: enum = None __all__ = ['pid_exists', 'wait_pid', 'disk_usage', 'get_terminal_map'] def pid_exists(pid): """Check whether pid exists in the current process table.""" if pid == 0: # According to "man 2 kill" PID 0 has a special meaning: # it refers to <<every process in the process group of the # calling process>> so we don't want to go any further. # If we get here it means this UNIX platform does have # a process with id 0. return True try: os.kill(pid, 0) except ProcessLookupError: return False except PermissionError: # EPERM clearly means there's a process to deny access to return True # According to "man 2 kill" possible error values are # (EINVAL, EPERM, ESRCH) else: return True # Python 3.5 signals enum (contributed by me ^^): # https://bugs.python.org/issue21076 if enum is not None and hasattr(signal, "Signals"): Negsignal = enum.IntEnum( 'Negsignal', dict([(x.name, -x.value) for x in signal.Signals])) def negsig_to_enum(num): """Convert a negative signal value to an enum.""" try: return Negsignal(num) except ValueError: return num else: # pragma: no cover def negsig_to_enum(num): return num def wait_pid(pid, timeout=None, proc_name=None, _waitpid=os.waitpid, _timer=getattr(time, 'monotonic', time.time), _min=min, _sleep=time.sleep, _pid_exists=pid_exists): """Wait for a process PID to terminate. If the process terminated normally by calling exit(3) or _exit(2), or by returning from main(), the return value is the positive integer passed to exit(). If it was terminated by a signal it returns the negated value of the signal which caused the termination (e.g. -SIGTERM). If PID is not a children of os.getpid() (current process) just wait until the process disappears and return None. If PID does not exist at all return None immediately. If timeout* != None and process is still alive raise TimeoutExpired. timeout=0 is also possible (either return immediately or raise). """ if pid <= 0: raise ValueError("can't wait for PID 0") # see "man waitpid" interval = 0.0001 flags = 0 if timeout is not None: flags \|= os.WNOHANG stop_at = _timer() + timeout def sleep(interval): # Sleep for some time and return a new increased interval. if timeout is not None: if _timer() >= stop_at: raise TimeoutExpired(timeout, pid=pid, name=proc_name) _sleep(interval) return _min(interval * 2, 0.04) # See: https://linux.die.net/man/2/waitpid while True: try: retpid, status = os.waitpid(pid, flags) except InterruptedError: interval = sleep(interval) except ChildProcessError: # This has two meanings: # - PID is not a child of os.getpid() in which case # we keep polling until it's gone # - PID never existed in the first place # In both cases we'll eventually return None as we # can't determine its exit status code. while _pid_exists(pid): interval = sleep(interval) return else: if retpid == 0: # WNOHANG flag was used and PID is still running. interval = sleep(interval) continue elif os.WIFEXITED(status): # Process terminated normally by calling exit(3) or _exit(2), # or by returning from main(). The return value is the # positive integer passed to exit(). return os.WEXITSTATUS(status) elif os.WIFSIGNALED(status): # Process exited due to a signal. Return the negative value # of that signal. return negsig_to_enum(-os.WTERMSIG(status)) # elif os.WIFSTOPPED(status): # # Process was stopped via SIGSTOP or is being traced, and # # waitpid() was called with WUNTRACED flag. PID is still # # alive. From now on waitpid() will keep returning (0, 0) # # until the process state doesn't change. # # It may make sense to catch/enable this since stopped PIDs # # ignore SIGTERM. # interval = sleep(interval) # continue # elif os.WIFCONTINUED(status): # # Process was resumed via SIGCONT and waitpid() was called # # with WCONTINUED flag. # interval = sleep(interval) # continue else: # Should never happen. raise ValueError("unknown process exit status %r" % status) def disk_usage(path): """Return disk usage associated with path. Note: UNIX usually reserves 5% disk space which is not accessible by user. In this function "total" and "used" values reflect the total and used disk space whereas "free" and "percent" represent the "free" and "used percent" user disk space. """ if PY3: st = os.statvfs(path) else: # pragma: no cover # os.statvfs() does not support unicode on Python 2: # - https://github.com/giampaolo/psutil/issues/416 # - http://bugs.python.org/issue18695 try: st = os.statvfs(path) except UnicodeEncodeError: if isinstance(path, unicode): try: path = path.encode(sys.getfilesystemencoding()) except UnicodeEncodeError: pass st = os.statvfs(path) else: raise # Total space which is only available to root (unless changed # at system level). total = (st.f_blocks st.f_frsize) # Remaining free space usable by root. avail_to_root = (st.f_bfree * st.f_frsize) # Remaining free space usable by user. avail_to_user = (st.f_bavail * st.f_frsize) # Total space being used in general. used = (total - avail_to_root) if MACOS: # see: https://github.com/giampaolo/psutil/pull/2152 used = _psutil_osx.disk_usage_used(path, used) # Total space which is available to user (same as 'total' but # for the user). total_user = used + avail_to_user # User usage percent compared to the total amount of space # the user can use. This number would be higher if compared # to root's because the user has less space (usually -5%). usage_percent_user = usage_percent(used, total_user, round_=1) # NB: the percentage is -5% than what shown by df due to # reserved blocks that we are currently not considering: # https://github.com/giampaolo/psutil/issues/829#issuecomment-223750462 return sdiskusage( total=total, used=used, free=avail_to_user, percent=usage_percent_user) @memoize def get_terminal_map(): """Get a map of device-id -> path as a dict. Used by Process.terminal() """ ret = {} ls = glob.glob('/dev/tty') + glob.glob('/dev/pts/') for name in ls: assert name not in ret, name try: ret[os.stat(name).st_rdev] = name except FileNotFoundError: pass return ret	8.05 KB	2026-01-20 12:58
📄 _pssunos.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Sun OS Solaris platform implementation.""" import errno import functools import os import socket import subprocess import sys from collections import namedtuple from socket import AF_INET from . import _common from . import _psposix from . import _psutil_posix as cext_posix from . import _psutil_sunos as cext from ._common import AF_INET6 from ._common import AccessDenied from ._common import NoSuchProcess from ._common import ZombieProcess from ._common import debug from ._common import get_procfs_path from ._common import isfile_strict from ._common import memoize_when_activated from ._common import sockfam_to_enum from ._common import socktype_to_enum from ._common import usage_percent from ._compat import PY3 from ._compat import FileNotFoundError from ._compat import PermissionError from ._compat import ProcessLookupError from ._compat import b __extra__all__ = ["CONN_IDLE", "CONN_BOUND", "PROCFS_PATH"] # ===================================================================== # --- globals # ===================================================================== PAGE_SIZE = cext_posix.getpagesize() AF_LINK = cext_posix.AF_LINK IS_64_BIT = sys.maxsize > 2*32 CONN_IDLE = "IDLE" CONN_BOUND = "BOUND" PROC_STATUSES = { cext.SSLEEP: _common.STATUS_SLEEPING, cext.SRUN: _common.STATUS_RUNNING, cext.SZOMB: _common.STATUS_ZOMBIE, cext.SSTOP: _common.STATUS_STOPPED, cext.SIDL: _common.STATUS_IDLE, cext.SONPROC: _common.STATUS_RUNNING, # same as run cext.SWAIT: _common.STATUS_WAITING, } TCP_STATUSES = { cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT, cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT, cext.TCPS_CLOSED: _common.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK, cext.TCPS_LISTEN: _common.CONN_LISTEN, cext.TCPS_CLOSING: _common.CONN_CLOSING, cext.PSUTIL_CONN_NONE: _common.CONN_NONE, cext.TCPS_IDLE: CONN_IDLE, # sunos specific cext.TCPS_BOUND: CONN_BOUND, # sunos specific } proc_info_map = dict( ppid=0, rss=1, vms=2, create_time=3, nice=4, num_threads=5, status=6, ttynr=7, uid=8, euid=9, gid=10, egid=11) # ===================================================================== # --- named tuples # ===================================================================== # psutil.cpu_times() scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait']) # psutil.cpu_times(percpu=True) pcputimes = namedtuple('pcputimes', ['user', 'system', 'children_user', 'children_system']) # psutil.virtual_memory() svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free']) # psutil.Process.memory_info() pmem = namedtuple('pmem', ['rss', 'vms']) pfullmem = pmem # psutil.Process.memory_maps(grouped=True) pmmap_grouped = namedtuple('pmmap_grouped', ['path', 'rss', 'anonymous', 'locked']) # psutil.Process.memory_maps(grouped=False) pmmap_ext = namedtuple( 'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields)) # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): """Report virtual memory metrics.""" # we could have done this with kstat, but IMHO this is good enough total = os.sysconf('SC_PHYS_PAGES') PAGE_SIZE # note: there's no difference on Solaris free = avail = os.sysconf('SC_AVPHYS_PAGES') * PAGE_SIZE used = total - free percent = usage_percent(used, total, round_=1) return svmem(total, avail, percent, used, free) def swap_memory(): """Report swap memory metrics.""" sin, sout = cext.swap_mem() # XXX # we are supposed to get total/free by doing so: # http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/ # usr/src/cmd/swap/swap.c # ...nevertheless I can't manage to obtain the same numbers as 'swap' # cmdline utility, so let's parse its output (sigh!) p = subprocess.Popen(['/usr/bin/env', 'PATH=/usr/sbin:/sbin:%s' % os.environ['PATH'], 'swap', '-l'], stdout=subprocess.PIPE) stdout, _ = p.communicate() if PY3: stdout = stdout.decode(sys.stdout.encoding) if p.returncode != 0: raise RuntimeError("'swap -l' failed (retcode=%s)" % p.returncode) lines = stdout.strip().split('\n')[1:] if not lines: raise RuntimeError('no swap device(s) configured') total = free = 0 for line in lines: line = line.split() t, f = line[3:5] total += int(int(t) * 512) free += int(int(f) * 512) used = total - free percent = usage_percent(used, total, round_=1) return _common.sswap(total, used, free, percent, sin * PAGE_SIZE, sout * PAGE_SIZE) # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system-wide CPU times as a named tuple""" ret = cext.per_cpu_times() return scputimes([sum(x) for x in zip(ret)]) def per_cpu_times(): """Return system per-CPU times as a list of named tuples""" ret = cext.per_cpu_times() return [scputimes(x) for x in ret] def cpu_count_logical(): """Return the number of logical CPUs in the system.""" try: return os.sysconf("SC_NPROCESSORS_ONLN") except ValueError: # mimic os.cpu_count() behavior return None def cpu_count_cores(): """Return the number of CPU cores in the system.""" return cext.cpu_count_cores() def cpu_stats(): """Return various CPU stats as a named tuple.""" ctx_switches, interrupts, syscalls, traps = cext.cpu_stats() soft_interrupts = 0 return _common.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls) # ===================================================================== # --- disks # ===================================================================== disk_io_counters = cext.disk_io_counters disk_usage = _psposix.disk_usage def disk_partitions(all=False): """Return system disk partitions.""" # TODO - the filtering logic should be better checked so that # it tries to reflect 'df' as much as possible retlist = [] partitions = cext.disk_partitions() for partition in partitions: device, mountpoint, fstype, opts = partition if device == 'none': device = '' if not all: # Differently from, say, Linux, we don't have a list of # common fs types so the best we can do, AFAIK, is to # filter by filesystem having a total size > 0. try: if not disk_usage(mountpoint).total: continue except OSError as err: # https://github.com/giampaolo/psutil/issues/1674 debug("skipping %r: %s" % (mountpoint, err)) continue maxfile = maxpath = None # set later ntuple = _common.sdiskpart(device, mountpoint, fstype, opts, maxfile, maxpath) retlist.append(ntuple) return retlist # ===================================================================== # --- network # ===================================================================== net_io_counters = cext.net_io_counters net_if_addrs = cext_posix.net_if_addrs def net_connections(kind, _pid=-1): """Return socket connections. If pid == -1 return system-wide connections (as opposed to connections opened by one process only). Only INET sockets are returned (UNIX are not). """ cmap = _common.conn_tmap.copy() if _pid == -1: cmap.pop('unix', 0) if kind not in cmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in cmap]))) families, types = _common.conn_tmap[kind] rawlist = cext.net_connections(_pid) ret = set() for item in rawlist: fd, fam, type_, laddr, raddr, status, pid = item if fam not in families: continue if type_ not in types: continue # TODO: refactor and use _common.conn_to_ntuple. if fam in (AF_INET, AF_INET6): if laddr: laddr = _common.addr(laddr) if raddr: raddr = _common.addr(raddr) status = TCP_STATUSES[status] fam = sockfam_to_enum(fam) type_ = socktype_to_enum(type_) if _pid == -1: nt = _common.sconn(fd, fam, type_, laddr, raddr, status, pid) else: nt = _common.pconn(fd, fam, type_, laddr, raddr, status) ret.add(nt) return list(ret) def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" ret = cext.net_if_stats() for name, items in ret.items(): isup, duplex, speed, mtu = items if hasattr(_common, 'NicDuplex'): duplex = _common.NicDuplex(duplex) ret[name] = _common.snicstats(isup, duplex, speed, mtu, '') return ret # ===================================================================== # --- other system functions # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() def users(): """Return currently connected users as a list of namedtuples.""" retlist = [] rawlist = cext.users() localhost = (':0.0', ':0') for item in rawlist: user, tty, hostname, tstamp, user_process, pid = item # note: the underlying C function includes entries about # system boot, run level and others. We might want # to use them in the future. if not user_process: continue if hostname in localhost: hostname = 'localhost' nt = _common.suser(user, tty, hostname, tstamp, pid) retlist.append(nt) return retlist # ===================================================================== # --- processes # ===================================================================== def pids(): """Returns a list of PIDs currently running on the system.""" return [int(x) for x in os.listdir(b(get_procfs_path())) if x.isdigit()] def pid_exists(pid): """Check for the existence of a unix pid.""" return _psposix.pid_exists(pid) def wrap_exceptions(fun): """Call callable into a try/except clause and translate ENOENT, EACCES and EPERM in NoSuchProcess or AccessDenied exceptions. """ @functools.wraps(fun) def wrapper(self, args, *kwargs): try: return fun(self, args, *kwargs) except (FileNotFoundError, ProcessLookupError): # ENOENT (no such file or directory) gets raised on open(). # ESRCH (no such process) can get raised on read() if # process is gone in meantime. if not pid_exists(self.pid): raise NoSuchProcess(self.pid, self._name) else: raise ZombieProcess(self.pid, self._name, self._ppid) except PermissionError: raise AccessDenied(self.pid, self._name) except OSError: if self.pid == 0: if 0 in pids(): raise AccessDenied(self.pid, self._name) else: raise raise return wrapper class Process(object): """Wrapper class around underlying C implementation.""" __slots__ = ["pid", "_name", "_ppid", "_procfs_path", "_cache"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None self._procfs_path = get_procfs_path() def _assert_alive(self): """Raise NSP if the process disappeared on us.""" # For those C function who do not raise NSP, possibly returning # incorrect or incomplete result. os.stat('%s/%s' % (self._procfs_path, self.pid)) def oneshot_enter(self): self._proc_name_and_args.cache_activate(self) self._proc_basic_info.cache_activate(self) self._proc_cred.cache_activate(self) def oneshot_exit(self): self._proc_name_and_args.cache_deactivate(self) self._proc_basic_info.cache_deactivate(self) self._proc_cred.cache_deactivate(self) @wrap_exceptions @memoize_when_activated def _proc_name_and_args(self): return cext.proc_name_and_args(self.pid, self._procfs_path) @wrap_exceptions @memoize_when_activated def _proc_basic_info(self): if self.pid == 0 and not \ os.path.exists('%s/%s/psinfo' % (self._procfs_path, self.pid)): raise AccessDenied(self.pid) ret = cext.proc_basic_info(self.pid, self._procfs_path) assert len(ret) == len(proc_info_map) return ret @wrap_exceptions @memoize_when_activated def _proc_cred(self): return cext.proc_cred(self.pid, self._procfs_path) @wrap_exceptions def name(self): # note: max len == 15 return self._proc_name_and_args()[0] @wrap_exceptions def exe(self): try: return os.readlink( "%s/%s/path/a.out" % (self._procfs_path, self.pid)) except OSError: pass # continue and guess the exe name from the cmdline # Will be guessed later from cmdline but we want to explicitly # invoke cmdline here in order to get an AccessDenied # exception if the user has not enough privileges. self.cmdline() return "" @wrap_exceptions def cmdline(self): return self._proc_name_and_args()[1].split(' ') @wrap_exceptions def environ(self): return cext.proc_environ(self.pid, self._procfs_path) @wrap_exceptions def create_time(self): return self._proc_basic_info()[proc_info_map['create_time']] @wrap_exceptions def num_threads(self): return self._proc_basic_info()[proc_info_map['num_threads']] @wrap_exceptions def nice_get(self): # Note #1: getpriority(3) doesn't work for realtime processes. # Psinfo is what ps uses, see: # https://github.com/giampaolo/psutil/issues/1194 return self._proc_basic_info()[proc_info_map['nice']] @wrap_exceptions def nice_set(self, value): if self.pid in (2, 3): # Special case PIDs: internally setpriority(3) return ESRCH # (no such process), no matter what. # The process actually exists though, as it has a name, # creation time, etc. raise AccessDenied(self.pid, self._name) return cext_posix.setpriority(self.pid, value) @wrap_exceptions def ppid(self): self._ppid = self._proc_basic_info()[proc_info_map['ppid']] return self._ppid @wrap_exceptions def uids(self): try: real, effective, saved, _, _, _ = self._proc_cred() except AccessDenied: real = self._proc_basic_info()[proc_info_map['uid']] effective = self._proc_basic_info()[proc_info_map['euid']] saved = None return _common.puids(real, effective, saved) @wrap_exceptions def gids(self): try: _, _, _, real, effective, saved = self._proc_cred() except AccessDenied: real = self._proc_basic_info()[proc_info_map['gid']] effective = self._proc_basic_info()[proc_info_map['egid']] saved = None return _common.puids(real, effective, saved) @wrap_exceptions def cpu_times(self): try: times = cext.proc_cpu_times(self.pid, self._procfs_path) except OSError as err: if err.errno == errno.EOVERFLOW and not IS_64_BIT: # We may get here if we attempt to query a 64bit process # with a 32bit python. # Error originates from read() and also tools like "cat" # fail in the same way (!). # Since there simply is no way to determine CPU times we # return 0.0 as a fallback. See: # https://github.com/giampaolo/psutil/issues/857 times = (0.0, 0.0, 0.0, 0.0) else: raise return _common.pcputimes(times) @wrap_exceptions def cpu_num(self): return cext.proc_cpu_num(self.pid, self._procfs_path) @wrap_exceptions def terminal(self): procfs_path = self._procfs_path hit_enoent = False tty = wrap_exceptions( self._proc_basic_info()[proc_info_map['ttynr']]) if tty != cext.PRNODEV: for x in (0, 1, 2, 255): try: return os.readlink( '%s/%d/path/%d' % (procfs_path, self.pid, x)) except FileNotFoundError: hit_enoent = True continue if hit_enoent: self._assert_alive() @wrap_exceptions def cwd(self): # /proc/PID/path/cwd may not be resolved by readlink() even if # it exists (ls shows it). If that's the case and the process # is still alive return None (we can return None also on BSD). # Reference: http://goo.gl/55XgO procfs_path = self._procfs_path try: return os.readlink("%s/%s/path/cwd" % (procfs_path, self.pid)) except FileNotFoundError: os.stat("%s/%s" % (procfs_path, self.pid)) # raise NSP or AD return "" @wrap_exceptions def memory_info(self): ret = self._proc_basic_info() rss = ret[proc_info_map['rss']] * 1024 vms = ret[proc_info_map['vms']] * 1024 return pmem(rss, vms) memory_full_info = memory_info @wrap_exceptions def status(self): code = self._proc_basic_info()[proc_info_map['status']] # XXX is '?' legit? (we're not supposed to return it anyway) return PROC_STATUSES.get(code, '?') @wrap_exceptions def threads(self): procfs_path = self._procfs_path ret = [] tids = os.listdir('%s/%d/lwp' % (procfs_path, self.pid)) hit_enoent = False for tid in tids: tid = int(tid) try: utime, stime = cext.query_process_thread( self.pid, tid, procfs_path) except EnvironmentError as err: if err.errno == errno.EOVERFLOW and not IS_64_BIT: # We may get here if we attempt to query a 64bit process # with a 32bit python. # Error originates from read() and also tools like "cat" # fail in the same way (!). # Since there simply is no way to determine CPU times we # return 0.0 as a fallback. See: # https://github.com/giampaolo/psutil/issues/857 continue # ENOENT == thread gone in meantime if err.errno == errno.ENOENT: hit_enoent = True continue raise else: nt = _common.pthread(tid, utime, stime) ret.append(nt) if hit_enoent: self._assert_alive() return ret @wrap_exceptions def open_files(self): retlist = [] hit_enoent = False procfs_path = self._procfs_path pathdir = '%s/%d/path' % (procfs_path, self.pid) for fd in os.listdir('%s/%d/fd' % (procfs_path, self.pid)): path = os.path.join(pathdir, fd) if os.path.islink(path): try: file = os.readlink(path) except FileNotFoundError: hit_enoent = True continue else: if isfile_strict(file): retlist.append(_common.popenfile(file, int(fd))) if hit_enoent: self._assert_alive() return retlist def _get_unix_sockets(self, pid): """Get UNIX sockets used by process by parsing 'pfiles' output.""" # TODO: rewrite this in C (...but the damn netstat source code # does not include this part! Argh!!) cmd = "pfiles %s" % pid p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate() if PY3: stdout, stderr = [x.decode(sys.stdout.encoding) for x in (stdout, stderr)] if p.returncode != 0: if 'permission denied' in stderr.lower(): raise AccessDenied(self.pid, self._name) if 'no such process' in stderr.lower(): raise NoSuchProcess(self.pid, self._name) raise RuntimeError("%r command error\n%s" % (cmd, stderr)) lines = stdout.split('\n')[2:] for i, line in enumerate(lines): line = line.lstrip() if line.startswith('sockname: AF_UNIX'): path = line.split(' ', 2)[2] type = lines[i - 2].strip() if type == 'SOCK_STREAM': type = socket.SOCK_STREAM elif type == 'SOCK_DGRAM': type = socket.SOCK_DGRAM else: type = -1 yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE) @wrap_exceptions def connections(self, kind='inet'): ret = net_connections(kind, _pid=self.pid) # The underlying C implementation retrieves all OS connections # and filters them by PID. At this point we can't tell whether # an empty list means there were no connections for process or # process is no longer active so we force NSP in case the PID # is no longer there. if not ret: # will raise NSP if process is gone os.stat('%s/%s' % (self._procfs_path, self.pid)) # UNIX sockets if kind in ('all', 'unix'): ret.extend([_common.pconn(conn) for conn in self._get_unix_sockets(self.pid)]) return ret nt_mmap_grouped = namedtuple('mmap', 'path rss anon locked') nt_mmap_ext = namedtuple('mmap', 'addr perms path rss anon locked') @wrap_exceptions def memory_maps(self): def toaddr(start, end): return '%s-%s' % (hex(start)[2:].strip('L'), hex(end)[2:].strip('L')) procfs_path = self._procfs_path retlist = [] try: rawlist = cext.proc_memory_maps(self.pid, procfs_path) except OSError as err: if err.errno == errno.EOVERFLOW and not IS_64_BIT: # We may get here if we attempt to query a 64bit process # with a 32bit python. # Error originates from read() and also tools like "cat" # fail in the same way (!). # Since there simply is no way to determine CPU times we # return 0.0 as a fallback. See: # https://github.com/giampaolo/psutil/issues/857 return [] else: raise hit_enoent = False for item in rawlist: addr, addrsize, perm, name, rss, anon, locked = item addr = toaddr(addr, addrsize) if not name.startswith('['): try: name = os.readlink( '%s/%s/path/%s' % (procfs_path, self.pid, name)) except OSError as err: if err.errno == errno.ENOENT: # sometimes the link may not be resolved by # readlink() even if it exists (ls shows it). # If that's the case we just return the # unresolved link path. # This seems an incosistency with /proc similar # to: http://goo.gl/55XgO name = '%s/%s/path/%s' % (procfs_path, self.pid, name) hit_enoent = True else: raise retlist.append((addr, perm, name, rss, anon, locked)) if hit_enoent: self._assert_alive() return retlist @wrap_exceptions def num_fds(self): return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid))) @wrap_exceptions def num_ctx_switches(self): return _common.pctxsw( cext.proc_num_ctx_switches(self.pid, self._procfs_path)) @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout, self._name)	24.89 KB	2026-01-20 12:58
📄 _psutil_linux.abi3.so ELF��>��0$��@��\|��@�8� �@�� $��$��P��P��P�� ]��m��m��]��m��m��8��8��8��$��$��P�td��\T��\T��\T��Q�td��R�td��]��m��m��X��X��GNU�'@2��(#��հ ��z��G��!�8� �R��G��L��P��tn��ȷԸf��W�~��:hde�H��ذ��$��r:��Y��\��g�� =��\|��k��%��o��u�� h��{��Q��R��3��=��X�� 5��!��7��f��~��8�� F��R��"��`��a��$��?��5��W��%��&��W��L��'��)��$��5�� V�� 6��i��0��du�� C��D��6�� &��__gmon_start__�_init�_fini�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�PyErr_SetFromOSErrnoWithSyscall�__errno_location�strerror�sprintf�PyExc_OSError�PyObject_CallFunction�PyErr_SetObject�_Py_Dealloc�NoSuchProcess�AccessDenied�psutil_set_debug�PyArg_ParseTuple�PyObject_IsTrue�PSUTIL_DEBUG�_Py_NoneStruct�psutil_setup�getenv�socket�strncpy�ioctl�close�Py_BuildValue�PyErr_SetFromErrno�_Py_TrueStruct�_Py_FalseStruct�setpriority�getnameinfo�PyList_New�getifaddrs�PyList_Append�freeifaddrs�getpriority�PyUnicode_FromString�psutil_getpagesize�sysconf�psutil_pid_exists�kill�psutil_raise_for_pid�PyExc_RuntimeError�PyErr_Format�PyInit__psutil_posix�PyModule_Create2�PyModule_AddIntConstant�PyLong_FromLong�PyModule_AddObject�setutent�getutent�PyUnicode_DecodeFSDefault�endutent�PyEval_SaveThread�setmntent�PyEval_RestoreThread�getmntent�endmntent�PyErr_SetFromErrnoWithFilename�stderr�fprintf�fwrite�fputc�PySequence_Check�PySequence_Size�PyErr_Occurred�PySequence_GetItem�PyLong_AsLong�PyExc_TypeError�sched_setaffinity�PyExc_ValueError�PyErr_SetString�__sched_cpualloc�sched_getaffinity�__sched_cpufree�PyExc_OverflowError�PyErr_NoMemory�__sched_cpucount�sysinfo�syscall�PyInit__psutil_linux�libpthread.so.0�libc.so.6�GLIBC_2.2.5�GLIBC_2.7�GLIBC_2.3�GLIBC_2.3.4�GLIBC_2.6�� ui ��ii ��ii ��ti ��ii ��ui ��m��$��m��$��m��m��Hr��(R��`r��r��r��6R��r��5��r��BR��r��.��r��NR��r��P��s��[R��s��.�� s��hR��(s��'��@s��zR��Hs��@'��`s��R��hs��(��s��fS��s�� t�� t��tS��(t��pC��@t��S��Ht��B��`t��S��ht��P@��t��S��t��>��t��S��t��@<��t��S��t��:��t��S��t��8��u��S��u��B�� u��S��o�� o��o��o��o��o��!��o��#��o��%��o��.��o��4��o��N��o��A��o��D��o��E��(u��J��p�� p��(p��0p��G��8p��@p��Hp��Pp��Xp��`p�� hp��pp��xp�� p��p��p��p��p��L��p��p��p��p��p��p��p��p��p��p��p�� q��"��q��#��q��$��q��&�� q��'��(q��(��0q��)��8q����@q��+��Hq��,��Pq��-��Xq��/��`q��0��hq��1��pq��2��xq��H��q��I��q��3��q��5��q��6��q��7��q��8��q��9��q��:��q��;��q��<��q��=��q��>��q��?��q��@��q��B��q��C��r��D��r��K��r��F��H��H��O��H��t��H��5�O��%�O��@��%�O��h��%�O��h��%�O��h��%�O��h��%�O��h��%�O��h��%�O��h��%�O��h��p��%�O��h��`��%�O��h ��P��%�O��h ��@��%�O��h��0��%�O��h�� %zO��h ��%rO��h��%jO��h��%bO��h��%ZO��h��%RO��h��%JO��h��%BO��h��%:O��h��%2O��h��%O��h��p��%"O��h��`��%O��h��P��%O��h��@��% O��h��0��%O��h�� %�N��h��%�N��h��%�N��h��%�N��h ��%�N��h!��%�N��h"��%�N��h#��%�N��h$��%�N��h%��%�N��h&��%�N��h'��p��%�N��h(��`��%�N��h)��P��%�N��h��@��%�N��h+��0��%�N��h,�� %zN��h-��%rN��h.��%jN��h/��%bN��h0��%ZN��h1��%RN��h2��%JN��h3��%BN��h4��%:N��h5��%2N��h6��%N��h7��p��%"N��h8��`��%N��h9��P��%N��h:��@��% N��h;��0��%N��h<�� %�M��h=��%�M��h>��%�M��h?��H�=)Q��H�"Q��H9�tH�FK��H��t ��H�=�P��H�5�P��H)�H��H��?H��H�H�tH�]K��H��t��fD��=�P��u/UH�=>K��H��tH�=�H��=��h��P��]��{��f.��AUATI��UH��I��8H��L��H�5���L��H��1��U�1�L��L�%yJ��H�5���I�<$��I�<$H��H��H��tH�m�tH��1�]A\A]��H��`��H��1�]A\A]ÐATH��H�5���1�USH��I��L��1�L��H��I��H�5N��H�;�N��H�;H��H�� H��tH�m�tH��1�[]A\�fD��H��H��1�[]A\�f.��ATH��H�54��1�USH��I��L��~��1�L�� H�]I��H�5�)��H�;��H�;H��H��H��tH�m�tH��1�[]A\�fD��H��H��H��1�[]A\�f.��H��H��H�5:+��1�H�T$��t2H�\|$��x$H��H��҉H��H��H��H��D��1�H��f��H��H�=)��H��t H��H��1�H��UH��1�H�5+��H��@H�T$��A��1�E��tc1Ҿ��Ń��tXL�D$H�t$��L��!��D$�H��1��t��t$ H�=���1��h��H��@]�f��H��G��H�8��H��@]�fD��UH��1�H�5i��H��@H�T$��A��1�E��tm1Ҿ��Ń��thL�D$H�t$��L��\��D$�H��1��t/��D$ @tCH�5dG��H�=})��1��H��@]��H�G��H�8�,��H��@]�fD��H�5G��H�=:)��1��k��H��@]�D��H��H��H�5V��1�H�L$H�T$��A��1�E��t�T$�t$1��(��tH��F��H��H��H��F��H�8��ff.��@�H��AW��AV��AUATUSH��u\��H��E�H��E1�E1�j��H��H��H�.F��H��H��[]A\A]A^A_��u�D�wM��t�I��H��N�,7L��L�%�&��D��SH��L��1�H��H��I9�u�K�vL��H�=R(��D��1��fD��H��H�=4(��1��h��f�H��E��H��@�AW1�AVAUATUSH��(��H�D$H��H�\|$�3��f��H�l$H��,��0��H�!E��H��I��I��H��H�uD��M��AUI��L��H�=�%��1��S��I��XZM��H�\|$L��L�$��L�$��I��N��I�,$�V��H�+�^��I�/�f��I�m��n��H�m�H��w��H�}H��t�D�7D��H;kD��I��t�H��=��H�} D��H��H��E��E�� H�}(D��I��H�$D��H��I��M��E1�H�\|$H��t L�$�N��L�$H�T$H�H�$H��H��M��t I��B��M��tI�,$�R��H��t H�+�c��M��t I�/�t��M��tI�m��H�D$��H�D$H��([]A\A]A^A_��L��x�I�,$��L��e�H�+��H��S�I�/��L��A�I�m��L��.�H�m�H��H�l$H��S��s��fD��H�}(D��\��I��H��B��H��I��M��D��H��L�$��L�$M��f.��L��L��M��f.��L��x�H��f.��H��X�M��f.��L��8��H�\|$E1�E1�1�E1�H��f�H�\|$E1�E1�E1�H��H��A��E1�E1�1�E1�H�8��E1��f�UH��SH��r�H�T$H�5�$��H��H��1��A��1�E��t!�t$1��^�Ƌ��uH�=V$��1��H��[]ÐH�9A��H�8�Q�H��[]�f.��AU1�ATUH��H��@��H��t(I��H�T$1�H��H�5�#��uI�,$�`��E1�H��@L��]A\A]�1Ҿ��/��Ń��T��H�t$L�D$��L��D$�H��1��'��6��'��l$ @��@��>��@��@��:��@��@�� @��@��@�ŀ�R��f��f��f��!��f��f��f�� f��@�E��f��H�=B!��`�H��H��H��L��H�E��W��H��H�E��H��f�L��H�=y ��I��H��m��H��L��}��I�E��H��I�E��L��[��fD��H�=, ��I��H��H��L��-��I�E�uuH��I�E��L��\|��f.��H�=#��d�I��H��H��L��I�E�u%H��I�E��C��L��6��f.��H��I�E��L��z��D��H�=B��d��H�==��I�,$��E1��H��@L��]A\A]�f.��H�=&��I��H�� H��L��I�E��a��H��I�E��L��\|��fD��H�=��T�I��H��H��L��I�E��H��I�E��C��L��6��fD��H�=��I��H��m��H��L��}��I�E��H��I�E��=��L��[��0��L��N��f��H�=j��I��H�� H��L��I�E��a��H��I�E��L��fD��H�=$��T�I��H��H��L��I�E��H��I�E��L��fD��H�=��I��H��m��H��L��}��I�E��H��I�E��L��[��fD��H�=��I��H��H��L��-��I�E��q��H��I�E��L��fD��H�=��d�I��H��H��L��I�E��!��H��I�E��q��L��d��fD��H�=��I��H��}��H��L��I�E��H��I�E��,��L��k��fD��H�=t��I��H��-��H��L��=��I�E��H��I�E��L��fD��H�=-��t�I��H��H��L��I�E��1��H��I�E��L��fD��H�=��$�I��H��H��L��I�E��H��I�E��~��L��{��q��H��H�E��M��H��`��@��ff.��fD��H��H�=q��H��H��1��r�f��1��f��H��1��e�A��E��t��t��tH��9��H�8��1�H��f��UH��SH��H��_��tH��H��[]��uH��H��[]��H�)9��H��H�5��H�8H��1�[]�'��AT��H�=�;��H�� H�5��H��I��H�5z��L��1�H�5m��L��H�5\��L��l��l��H�5L��L��P��P��H�5=��L��4��4��H�50��L��H�5"��L��H�5��L��H�5��L�� H�5��L��H�5��L�� H�5��L��p��ut��H�5��L��X��u\��H�5��L��@��uD��H�5��L��(��u,H��X�H��H��tH�5��L�� E1�L��A\�f.��D��ATH��1�H�5��UE1�H��xH�T$� ��1Ҿ��G��Ń��L�D$H�t$��L��f�F��I��H�D$@D$@H�D$ L��1��D$�H�D$`��D$h��D$@��D$P��tF�T$\�D$L�t$N�� ¸��H�H�=@��1��I��H��t`��H��xL��]A\�f��_t��u/1Ҿ��fD��H�=��H��xI��]L��A\�fD��H�=��E1��z�H��xL��]A\�ff.��@�AW1�AVAUATUSH��+�I��H�� f.��K�H��H��f�;��L�-f5��H�{,��H��H��Q��H�{��I��H��H�{L��I��H��f�D�KM��H���T��L��H��H�=��r�I��H��H��L��H�m��I�,$tyI�/t[I�m��0��L��s�H��H��(��H��L��[]A\A]A^A_�f��L�-�4��@�L��I�m��L��p��z��H��`��c��E1�H�m�uH��F�I�,$toM��tI�/tTM��tI�m�t0I�.t��E1��Z��D��L��E1��@��L��I�.u��L��fD��L��fD��H�m�u�H��ff.��@�AW1�AVAUATUH��SH��H��w��I��H�T$1�H��H�5��f��V��H�\|$H�5v��L�5`��H��H��I��M��f.��L��H��H��H�;�d�H��H��H�{�O�I��H��3��H�KL�CH��H��L��1��H��H��H��L��H�m�t%I�/t-H�+�u��H��h��H��x�I�/u�L��j�H�+t�L��H��H��D��L��AfD��H�92��H��1��H�t$H�8��I�,$uL��@�E1�H��L��[]A\A]A^A_��L��x�H�m��I�/tH��t�H�+u�H��f�L��fD��L��8�H�m�u�H��y��@�H��1��H�V��1�H�5d��H�;�\|�H��H�=_��C�H�3� ��L��H��+��I��fD��AWH��1�H�53��AVAUATUSH��H�L$H�T$��H�\|$�R��H�\|$��I��H��L�l$ ��L��H��1�A��>��I��tb��H��uXI��wL��L��D��H��H��I T��H��I9�tyH�\|$H��H��H��t&H��H�m�I��u�H��2��H��t`1�H�Ĩ��[]A\A]A^A_�f�H�D$H�5,��H�PH��/��H�81��D��\|$L�꾀��u/H��/��H��H�/��H�5��H�D$H�:��H�D$�H�m/��H�8��l��AWH��1�H�5Y��AVA��AUA�@��ATUSH��H�T$�`��u��E�Ic�L�?�q�M��I��H��I��H��\|$H��L��Å��H��8��A��u�H��.��H�57��E1�H�8��H��L��[]A\A]A^A_�H��I�uL��H��I�m��/��E1��ŐH��.��I��D��1��I��H��twL��H��I��A�ą�u�_f��Hc�L9�s�H��H��H�D��H��s��I��H��i��H��L��I��B��H��I�t3��A��u�H��D��H��-��H�8��I��L��H��-��H��1�H�5��H�;��H��H�=��y�H�3� ��<��L��o��f.��H��xH��u@�D$hH�=��P1��t$PL�L$PL�D$@H�L$HH�T$8H�t$0�p��ZYH��x�f��H��,��H�8��H��x�ff.��H��H��H�55��1�L�D$H�L$H�T$��A��1�E��t.�L$�T$�� L$��tH��,��H��H��H�Q,��H�8�i��H��H��H�59��1�H�T$�V��A��1�E��t3�T$��Y��t$��H�=}��1�� i��H��@�H��+��H�8��H��ff.��AT��H�=�/��]��H��tp�S��H�5#��H��I��a��uU1�H�5��L��L��u@��H�5��L��4��u(��H�5��L��u��L��A\�D��E1�L��A\��H��H��%s (originated from %s)�(is)�PSUTIL_DEBUG��assume no such process (originated from %s)��assume access denied (originated from %s)�%02x:�(siOOOO)�socket(SOCK_DGRAM)�ioctl(SIOCGIFFLAGS)�up�broadcast�loopback�pointopoint�notrailers�noarp�promisc�allmulti�master�slave�multicast�portsel�automedia�dynamic�%s syscall failed�RLIMIT_AS�RLIMIT_CORE�RLIMIT_CPU�RLIMIT_DATA�RLIMIT_FSIZE�RLIMIT_MEMLOCK�RLIMIT_NOFILE�RLIMIT_NPROC�RLIMIT_RSS�RLIMIT_STACK�RLIMIT_LOCKS�RLIMIT_MSGQUEUE�RLIMIT_NICE�RLIMIT_RTPRIO�RLIMIT_RTTIME�RLIMIT_SIGPENDING�RLIM_INFINITY�_psutil_posix�getpagesize�getpriority�net_if_addrs�net_if_flags�net_if_is_running�net_if_mtu�setpriority�socket()�ioctl(SIOCETHTOOL)�[ii]�OOOdOi�psutil/_psutil_linux.c�psutil-debug [%s:%d]> �setmntent() failed�(OOss)�iO�invalid CPU value�CPU_ALLOC() failed�(kkkkkkI)�iii�version�DUPLEX_HALF�DUPLEX_FULL�DUPLEX_UNKNOWN�_psutil_linux�proc_ioprio_get�proc_ioprio_set�proc_cpu_affinity_get�proc_cpu_affinity_set�disk_partitions�users�net_if_duplex_speed�linux_sysinfo�set_debug��sequence argument expected, got %R��could not allocate a large enough CPU set��;��$��4��d��T��H��t��\|��X��4��4��D��d��4�T��D�t��d�P��$��4��T��zR�x��$��FJw��?;3$"��<��D��h��B�B�D �G�j CBBHO CBB<��B�M�A �G�L CABGO CAB<��B�M�A �G�L CABGO CAB��h��W��D F FF��$��)��Dd�(��<��A�PP{ ACXA��0��h��D��A�PP� AIX AGYA��a��D H D�`��D��K�D�E �B(�A0�A8�G�\�H�P�Z 8A0A(B BBBI��X��B�D�B �B(�A0�A8�D`]hLpXhA`l 8A0A(B BBBH��0��x��T��v��A�D�D0S AABSAA@��B�D�A �G`y DBBA� DBBK��\�� X��DP��`��W��TB<��4��i��A�D�G O DAHO DALXCA��t��B��@��Q��B�M�G�� DBCp DEGZDB��H��1��B�D�B �B(�A0�A8�D@ 8D0A(B BBBJH��$��z��B�D�B �B(�A0�D8�DP� 8D0A(B BBBDH��p��B�N�B �B(�A0�A8�G�� 8A0A(B BBBCH��P�&��B�N�H �H(�A0�A8�DP� 8D0A(B BBBA�,��4�d��D�X�F�_�A�D JS��8��t�y��D \ H��T��t��D W ES��t��8��B�� FH��$��$��m�� D��m��m��o��`�� p�� o��`��o��o��o��&��m��6 ��F ��V ��f ��v �� !��!��&!��6!��F!��V!��f!��v!��!��!��!��!��!��!��!��!��"��"��&"��6"��F"��V"��f"��v"��"��"��"��"��"��"��"��"��#��#��&#��6#��F#��V#��f#��v#��#��#��#��#��#��#��#��#��$��$��&$��(R��r��6R��5��BR��.��NR��P��[R��.��hR��'��zR��@'��R��(��fS�� t��tS��pC��S��B��S��P@��S��>��S��@<��S��:��S��8��S��B��S��GCC: (GNU) 10.2.1 20210130 (Red Hat 10.2.1-11)��0$��`$��$��,��`u��8��m��_��$��k��m��@'��'��(��a��@)��P��.��v��.��%��5��B�� r��h��L��r��X��8��Q��s��:��1��@<��z��>��P@��&��B��d��B��y��pC��t��B��s��h��L�� t��@��Z��"��m��/��m��8��\T��K��`u��W��p��8��`�� `�� 0$��D�� P��\T��@U��m��m��m��m��o��p�� r��`u��m��$�� 8�� T��i��\|��C��D��6��'��7��P��5�� c��v�� +��9��N��^��s�� 6��i��%��<��S��b��x��5��W��%��,��&��W��=��W��l��~�� &��du��*�� D��c��y��"�� '��)��deregister_tm_clones�__do_global_dtors_aux�completed.0�__do_global_dtors_aux_fini_array_entry�frame_dummy�__frame_dummy_init_array_entry�psutil_net_if_mtu�psutil_net_if_is_running�psutil_posix_setpriority�psutil_convert_ipaddr�psutil_net_if_addrs�psutil_posix_getpriority�psutil_net_if_flags�psutil_getpagesize_pywrapper�moduledef�mod_methods�psutil_net_if_duplex_speed�psutil_users�psutil_disk_partitions�psutil_proc_cpu_affinity_set�psutil_proc_cpu_affinity_get�psutil_linux_sysinfo�psutil_proc_ioprio_set�psutil_proc_ioprio_get�__FRAME_END__�__dso_handle�_DYNAMIC�__GNU_EH_FRAME_HDR�__TMC_END__�_GLOBAL_OFFSET_TABLE_�getenv@@GLIBC_2.2.5�PyList_New�PySequence_Check�PyErr_SetFromOSErrnoWithSyscall�endmntent@@GLIBC_2.2.5�PyModule_AddIntConstant�__errno_location@@GLIBC_2.2.5�strncpy@@GLIBC_2.2.5�getpriority@@GLIBC_2.2.5�_ITM_deregisterTMCloneTable�PyEval_RestoreThread�PyErr_SetFromErrno�PyInit__psutil_linux�_Py_Dealloc�PyErr_NoMemory�PyErr_SetObject�__sched_cpucount@@GLIBC_2.6�_fini�PyExc_RuntimeError�PyInit__psutil_posix�PyErr_SetString�PyExc_ValueError�PyExc_TypeError�setpriority@@GLIBC_2.2.5�psutil_getpagesize�ioctl@@GLIBC_2.2.5�close@@GLIBC_2.2.5�PySequence_GetItem�getnameinfo@@GLIBC_2.2.5�sched_setaffinity@@GLIBC_2.3.4�fputc@@GLIBC_2.2.5�endutent@@GLIBC_2.2.5�PyLong_FromLong�PySequence_Size�PyList_Append�PyExc_OSError�fprintf@@GLIBC_2.2.5�_Py_FalseStruct�syscall@@GLIBC_2.2.5�__gmon_start__�PyObject_CallFunction�PyExc_OverflowError�Py_BuildValue�kill@@GLIBC_2.2.5�PyErr_Occurred�PyModule_Create2�PyLong_AsLong�psutil_raise_for_pid�getutent@@GLIBC_2.2.5�getmntent@@GLIBC_2.2.5�setmntent@@GLIBC_2.2.5�_Py_NoneStruct�getifaddrs@@GLIBC_2.3�__sched_cpufree@@GLIBC_2.7�PyObject_IsTrue�PyArg_ParseTuple�psutil_pid_exists�NoSuchProcess�__sched_cpualloc@@GLIBC_2.7�_Py_TrueStruct�freeifaddrs@@GLIBC_2.3�setutent@@GLIBC_2.2.5�psutil_set_debug�PyUnicode_DecodeFSDefault�PyUnicode_FromString�PyEval_SaveThread�PyModule_AddObject�AccessDenied�sysconf@@GLIBC_2.2.5�PSUTIL_DEBUG�sysinfo@@GLIBC_2.2.5�PyErr_SetFromErrnoWithFilename�PyErr_Format�sprintf@@GLIBC_2.2.5�fwrite@@GLIBC_2.2.5�_ITM_registerTMCloneTable�sched_getaffinity@@GLIBC_2.3.4�strerror@@GLIBC_2.2.5�__cxa_finalize@@GLIBC_2.2.5�_init�psutil_setup�stderr@@GLIBC_2.2.5�socket@@GLIBC_2.2.5��.symtab�.strtab�.shstrtab�.note.gnu.build-id�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.got.plt�.data�.bss�.comment��8��8��$��.��o��`��`��`��8��@�� H��o��U��o��`��`��d��n��B��x�� s�� ~��0$��0$��Q ��D��D�� 2��P��P��Z��\T��\T��@U��@U��m��]��m��]��m��]��m��]��o��_��p��p��`�� r�� b��@�� `u��`e��0��`e��/��e��8 ��:�� r��{��	32.9 KB	2026-01-20 12:58
📄 _psutil_posix.abi3.so ELF��>��p"��@��b��@�8� �@�� @��@��@��M��]��]��M��]��]��8��8��8��$��$��P�td��B��B��B��Q�td��R�td��M��]��]��8��8��GNU��o2>p�Rz%��\\|l��(��!�8� �R��(��-��1��tn��ȷԸf��W�~��:hde�H��$��r:��Y��g�� k��o��u�� {��Q��=�� 7��~��8�� R��"��`��a��0#��?��4��W��#��$��W��L��P%��)��$��3�� V��`4��i��0��b�� 6��4��`$��__gmon_start__�_init�_fini�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�PyErr_SetFromOSErrnoWithSyscall�__errno_location�strerror�sprintf�PyExc_OSError�PyObject_CallFunction�PyErr_SetObject�_Py_Dealloc�NoSuchProcess�AccessDenied�psutil_set_debug�PyArg_ParseTuple�PyObject_IsTrue�PSUTIL_DEBUG�_Py_NoneStruct�psutil_setup�getenv�socket�strncpy�ioctl�close�Py_BuildValue�PyErr_SetFromErrno�_Py_TrueStruct�_Py_FalseStruct�setpriority�getnameinfo�PyList_New�getifaddrs�PyList_Append�freeifaddrs�getpriority�PyUnicode_FromString�psutil_getpagesize�sysconf�psutil_pid_exists�kill�psutil_raise_for_pid�PyExc_RuntimeError�PyErr_Format�PyInit__psutil_posix�PyModule_Create2�PyModule_AddIntConstant�PyLong_FromLong�PyModule_AddObject�libpthread.so.0�libc.so.6�GLIBC_2.2.5�GLIBC_2.3�� ui ��ii ��ui ��]�� #��]��"��]��]��ha��1B��a��a��a��?B��a��3��a��KB��a��P,��b��WB��b��(�� b��dB��(b��,��@b��qB��Hb��0&��`b��B��hb��%��b��B��b��'��_��_��_��_��_��_��_��_��/��_��$��_��&��`�� `��(`��(��0`��8`��@`��H`��P`��X`�� ``�� h`��p`��-��x`�� `��`��`��`��`��`��`��`��`��`��`��`��`��)��`����`��`��a�� a��!��a��"��a��#�� a��%��(a��&��0a��'��H��H��?��H��t�+��H��5�?��%�?��@��%�?��h��%�?��h��%�?��h��%�?��h��%�?��h��%�?��h��%�?��h��%�?��h��p��%�?��h��`��%�?��h ��P��%�?��h ��@��%�?��h��0��%�?��h�� %z?��h ��%r?��h��%j?��h��%b?��h��%Z?��h��%R?��h��%J?��h��%B?��h��%:?��h��%2?��h��%?��h��p��%"?��h��`��%?��h��P��%?��h��@��% ?��h��0��%?��h�� %�>��h��%�>��h��%�>��h��%�>��h ��%�>��h!��%�>��h"��%�>��h#��H�=I@��H�B@��H9�tH�&=��H��t ��H�=@��H�5@��H)�H��H��?H��H�H�tH�%=��H��t��fD��=�?��u/UH�==��H��tH�=�:��M��h��?��]��{��f.��AUATI��UH��,��I��8H��L��H�5��L��H��1��U�1�L��L�%I<��H�5��I�<$��I�<$H��H����H��tH�m�tH��1�]A\A]��H��H��1�]A\A]ÐATH��H�5T��1�USH��I��L��>��1�L��H��;��H�5��H�;�>��H�;H��H��H��tH�m�tH��1�[]A\�fD��H��h��H��1�[]A\�f.��ATH��H�5��1�USH��I��L��1�L�� H�-;��H�5~��H�;��H�;H��H��H��tH�m�tH��1�[]A\�fD��H��H��1�[]A\�f.��H��H��H�5��1�H�T$��t2H�\|$��x$H��:��҉H��:��H��H��D��1�H��f��H��H�=��H��t H�\|:��1�H��UH��1�H�5��H��@H�T$��A��1�E��tc1Ҿ��Ń��tXL�D$H�t$��L��!��D$�H��1��t� ��t$ H�=��1��X��H��@]�f��H��9��H�8�\|��H��@]�fD��UH��1�H�52��H��@H�T$�e��A��1�E��tm1Ҿ��Ń��thL�D$H�t$��L��D$�H��1��V��t/�Z��D$ @tCH�5,9��H�=F��1��H��@]��+��H��8��H�8��H��@]�fD��H�5�8��H�=��1��[��H��@]�D��H��H��H�5l��1�H�L$H�T$��A��1�E��t�T$�t$1��tH��8��H��H��H�Y8��H�8�1��ff.��@�H��AW��AV��AUATUSH��u\��H��E�H��E1�E1�j��H��@��H��H��7��H��H��[]A\A]A^A_��u�D�wM��t�I��H��N�,7L��L�%j��D��SH��L��1�H��H��I9�u�K�vL��H�=��D��1��fD��H��H�=��1��h��f�H�Q7��H��@�AW1�AVAUATUSH��(��H�D$H��H�\|$��f��H�l$H��,��0��H��6��H��I��I��H��H�uD��M��AUI��L��H�=}��1��C��I��XZM��H�\|$L��L�$��L�$��I��N��I�,$�V��H�+�^��I�/�f��I�m��n��H�m�H��w��H�}H��t�D�7D��H;36��I��t�H��=��H�} D��H��H��E��E�� H�}(D��I��H��5��H��I��M��E1�H�\|$H��t L�$��L�$H�T$H�H�$H��H��M��t I��B��M��tI�,$�R��H��t H�+�c��M��t I�/�t��M��tI�m��H�D$��H�D$H��([]A\A]A^A_��L��I�,$��L��H�+��H��I�/��L��I�m��L��H�m�H��H�l$H��s��fD��H�}(D��\��I��H��4��H��I��M��D��H��L�$�\��L�$M��f.��L��8��L��(��M��f.��L��H��f.��H��M��f.��L��H�\|$E1�E1�1�E1�H��f�H�\|$E1�E1�E1�H��H��3��E1�E1�1�E1�H�8�Z�E1��f�UH��SH��H�T$H�5!��H��H��1��3��A��1�E��t!�t$1��Ƌ��uH�=��1��H��[]ÐH� 3��H�8��H��[]�f.��AU1�ATUH��H��@�]�H��t(I��H�T$1�H��H�5s��uI�,$�`��E1�H��@L��]A\A]�1Ҿ��/��Ń��T��H�t$L�D$��L��-��D$�H��1��6��l$ @��@��>��@��@��:��@��@�� @��@��@�ŀ�R��f��f��f��!��f��f��f�� f��@�E��f��H�=��H��H��H��L��H�E��W��H��H�E��H��G��f�L��8��H�=<��d�I��H��m��H��L��I�E��H��I�E��L��fD��H�=��I��H��H��L��=��I�E�uuH��I�E��L��\|��f.��H�=��I��H��H��L��I�E�u%H��I�E��C��L��O��6��f.��H��I�E��L����z��D��H�=��d��H�=��I�,$��E1��7�H��@L��]A\A]�f.��H�=��I��H�� H��L��-��I�E��a��H��I�E��L��\|��fD��H�=��I��H��H��L��I�E��H��I�E��C��L��;��6��fD��H�=��d�I��H��m��H��L��I�E��H��I�E��=��L��0��L��f��H�=3��I��H�� H��L��-��I�E��a��H��I�E��L��fD��H�=��I��H��H��L��I�E��H��I�E��L��;��fD��H�=d��d�I��H��m��H��L��I�E��H��I�E��L��fD��H�=��I��H��H��L��=��I�E��q��H��I�E��L��fD��H�=��I��H��H��L��I�E��!��H��I�E��q��L��K��d��fD��H�=��t�I��H��}��H��L��I�E��H��I�E��,��L��fD��H�==��$�I��H��-��H��L��M��I�E��H��I�E��L��fD��H�=� ��I��H��H��L��I�E��1��H��I�E��L��[��fD��H�=� ��I��H��H��L��I�E��H��I�E��~��L��q��H��H�E��M��H��@��ff.��6�fD��H��H�=: ��H��H��1��b�f��1��f��H��1��U�A��E��t�C��t��tH��+��H�8�X��1�H��f��UH��SH��H��tH��H��[]��1��uH��H��[]�/��H� +��H��H�5��H�8H��1�[]�W��AT��H�=b,��H�� H�5X��H��I��]��H�5C��L��A��1�H�56��L��(��H�5%��L��l��H�5��L��P��H�5��L��4��H�5��L��H�5��L��H�5��L��H�5��L��d�� H�5��L��H��H�5��L��,�� H�5��L��ut��H�5��L��u\��H�5��L��uD��H�5��L��u,H��x�H��H��tH�5l��L��A�� E1�L��A\��H��H��%s (originated from %s)�(is)�PSUTIL_DEBUG��assume no such process (originated from %s)��assume access denied (originated from %s)�ii�%02x:�(siOOOO)�socket(SOCK_DGRAM)�ioctl(SIOCGIFFLAGS)�up�broadcast�debug�loopback�pointopoint�notrailers�noarp�promisc�allmulti�master�slave�multicast�portsel�automedia�dynamic�%s syscall failed�RLIMIT_AS�RLIMIT_CORE�RLIMIT_CPU�RLIMIT_DATA�RLIMIT_FSIZE�RLIMIT_MEMLOCK�RLIMIT_NOFILE�RLIMIT_NPROC�RLIMIT_RSS�RLIMIT_STACK�RLIMIT_LOCKS�RLIMIT_MSGQUEUE�RLIMIT_NICE�RLIMIT_RTPRIO�RLIMIT_RTTIME�RLIMIT_SIGPENDING�RLIM_INFINITY�_psutil_posix�getpagesize�getpriority�net_if_addrs�net_if_flags�net_if_is_running�net_if_mtu�setpriority��;��4��\��T��t�4��P��4�D��4��D��d��4��zR�x��$��P��FJw��?;3$"��<��D��B�B�D �G�j CBBHO CBB<��B�M�A �G�L CABGO CAB<��`��B�M�A �G�L CABGO CAB��W��D F FF��$��)��Dd�(��<��A�PP{ ACXA��0��h��A�PP� AIX AGYA��8�a��D H D�`��K�D�E �B(�A0�A8�G�\�H�P�Z 8A0A(B BBBI��X��8��B�D�B �B(�A0�A8�D`]hLpXhA`l 8A0A(B BBBH��0��x��v��A�D�D0S AABSAA@��B�D�A �G`y DBBA� DBBK�� DP��W��TB<��4��i��A�D�G O DAHO DALXCA��t�� B�� #��"��]�� 6��]��]��o��`�� `��`��0��x�� o��(��o��o�� o��]��6 ��F ��V ��f ��v �� !��!��&!��6!��F!��V!��f!��v!��!��!��!��!��!��!��!��!��"��"��&"��6"��F"��V"��f"��1B��a��?B��3��KB��P,��WB��(��dB��,��qB��0&��B��%��B��'��GCC: (GNU) 10.2.1 20210130 (Red Hat 10.2.1-11)��p"��"��"��,��b��8��]��_�� #��k��]��%��0&��'��a��'��(��P,��v��,��%��3��B��@a��h��L��a��X��F��f��]��s��]��\|��B��b��`��8��`�� (��x��0�� p"��6�� @��B��8C��]��]��]��]��_��`��@a��b��0#��&��;��T�� p��6��4��3�� 8��H��V��d��t�� `4��i��%��4��W��7��#��E��T��k��$��W��\|��`$��b�� %��"��A�� G��P%��)��T��deregister_tm_clones�__do_global_dtors_aux�completed.0�__do_global_dtors_aux_fini_array_entry�frame_dummy�__frame_dummy_init_array_entry�psutil_net_if_mtu�psutil_net_if_is_running�psutil_posix_setpriority�psutil_convert_ipaddr�psutil_net_if_addrs�psutil_posix_getpriority�psutil_net_if_flags�psutil_getpagesize_pywrapper�moduledef�mod_methods�__FRAME_END__�__dso_handle�_DYNAMIC�__GNU_EH_FRAME_HDR�__TMC_END__�_GLOBAL_OFFSET_TABLE_�getenv@@GLIBC_2.2.5�PyList_New�PyErr_SetFromOSErrnoWithSyscall�PyModule_AddIntConstant�__errno_location@@GLIBC_2.2.5�strncpy@@GLIBC_2.2.5�getpriority@@GLIBC_2.2.5�_ITM_deregisterTMCloneTable�PyErr_SetFromErrno�_Py_Dealloc�PyErr_SetObject�_fini�PyExc_RuntimeError�PyInit__psutil_posix�setpriority@@GLIBC_2.2.5�psutil_getpagesize�ioctl@@GLIBC_2.2.5�close@@GLIBC_2.2.5�getnameinfo@@GLIBC_2.2.5�PyLong_FromLong�PyList_Append�PyExc_OSError�_Py_FalseStruct�__gmon_start__�PyObject_CallFunction�Py_BuildValue�kill@@GLIBC_2.2.5�PyModule_Create2�psutil_raise_for_pid�_Py_NoneStruct�getifaddrs@@GLIBC_2.3�PyObject_IsTrue�PyArg_ParseTuple�psutil_pid_exists�NoSuchProcess�_Py_TrueStruct�freeifaddrs@@GLIBC_2.3�psutil_set_debug�PyUnicode_FromString�PyModule_AddObject�AccessDenied�sysconf@@GLIBC_2.2.5�PSUTIL_DEBUG�PyErr_Format�sprintf@@GLIBC_2.2.5�_ITM_registerTMCloneTable�strerror@@GLIBC_2.2.5�__cxa_finalize@@GLIBC_2.2.5�_init�psutil_setup�socket@@GLIBC_2.2.5��.symtab�.strtab�.shstrtab�.note.gnu.build-id�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.got.plt�.data�.bss�.comment��8��8��$��.��o��`��`��\��8��@��H��o�� h��U��o��(��(��P��d��x��x��n��B��0��0��`��x�� s�� P��~��p"��p"��a��6��6�� 2��@��@��B��B��8C��8C��]��M��]��M��]��M��]��M��_��O��P��`��P��8��@a��@Q�� b��R��0��R��/��R��H ��0�� 8\��h��a��	26.41 KB	2026-01-20 12:58
📄 _pswindows.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Windows platform implementation.""" import contextlib import errno import functools import os import signal import sys import time from collections import namedtuple from . import _common from ._common import ENCODING from ._common import ENCODING_ERRS from ._common import AccessDenied from ._common import NoSuchProcess from ._common import TimeoutExpired from ._common import conn_tmap from ._common import conn_to_ntuple from ._common import debug from ._common import isfile_strict from ._common import memoize from ._common import memoize_when_activated from ._common import parse_environ_block from ._common import usage_percent from ._compat import PY3 from ._compat import long from ._compat import lru_cache from ._compat import range from ._compat import unicode from ._psutil_windows import ABOVE_NORMAL_PRIORITY_CLASS from ._psutil_windows import BELOW_NORMAL_PRIORITY_CLASS from ._psutil_windows import HIGH_PRIORITY_CLASS from ._psutil_windows import IDLE_PRIORITY_CLASS from ._psutil_windows import NORMAL_PRIORITY_CLASS from ._psutil_windows import REALTIME_PRIORITY_CLASS try: from . import _psutil_windows as cext except ImportError as err: if str(err).lower().startswith("dll load failed") and \ sys.getwindowsversion()[0] < 6: # We may get here if: # 1) we are on an old Windows version # 2) psutil was installed via pip + wheel # See: https://github.com/giampaolo/psutil/issues/811 msg = "this Windows version is too old (< Windows Vista); " msg += "psutil 3.4.2 is the latest version which supports Windows " msg += "2000, XP and 2003 server" raise RuntimeError(msg) else: raise if sys.version_info >= (3, 4): import enum else: enum = None # process priority constants, import from __init__.py: # http://msdn.microsoft.com/en-us/library/ms686219(v=vs.85).aspx __extra__all__ = [ "win_service_iter", "win_service_get", # Process priority "ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS", "HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS", "NORMAL_PRIORITY_CLASS", "REALTIME_PRIORITY_CLASS", # IO priority "IOPRIO_VERYLOW", "IOPRIO_LOW", "IOPRIO_NORMAL", "IOPRIO_HIGH", # others "CONN_DELETE_TCB", "AF_LINK", ] # ===================================================================== # --- globals # ===================================================================== CONN_DELETE_TCB = "DELETE_TCB" ERROR_PARTIAL_COPY = 299 PYPY = '__pypy__' in sys.builtin_module_names if enum is None: AF_LINK = -1 else: AddressFamily = enum.IntEnum('AddressFamily', {'AF_LINK': -1}) AF_LINK = AddressFamily.AF_LINK TCP_STATUSES = { cext.MIB_TCP_STATE_ESTAB: _common.CONN_ESTABLISHED, cext.MIB_TCP_STATE_SYN_SENT: _common.CONN_SYN_SENT, cext.MIB_TCP_STATE_SYN_RCVD: _common.CONN_SYN_RECV, cext.MIB_TCP_STATE_FIN_WAIT1: _common.CONN_FIN_WAIT1, cext.MIB_TCP_STATE_FIN_WAIT2: _common.CONN_FIN_WAIT2, cext.MIB_TCP_STATE_TIME_WAIT: _common.CONN_TIME_WAIT, cext.MIB_TCP_STATE_CLOSED: _common.CONN_CLOSE, cext.MIB_TCP_STATE_CLOSE_WAIT: _common.CONN_CLOSE_WAIT, cext.MIB_TCP_STATE_LAST_ACK: _common.CONN_LAST_ACK, cext.MIB_TCP_STATE_LISTEN: _common.CONN_LISTEN, cext.MIB_TCP_STATE_CLOSING: _common.CONN_CLOSING, cext.MIB_TCP_STATE_DELETE_TCB: CONN_DELETE_TCB, cext.PSUTIL_CONN_NONE: _common.CONN_NONE, } if enum is not None: class Priority(enum.IntEnum): ABOVE_NORMAL_PRIORITY_CLASS = ABOVE_NORMAL_PRIORITY_CLASS BELOW_NORMAL_PRIORITY_CLASS = BELOW_NORMAL_PRIORITY_CLASS HIGH_PRIORITY_CLASS = HIGH_PRIORITY_CLASS IDLE_PRIORITY_CLASS = IDLE_PRIORITY_CLASS NORMAL_PRIORITY_CLASS = NORMAL_PRIORITY_CLASS REALTIME_PRIORITY_CLASS = REALTIME_PRIORITY_CLASS globals().update(Priority.__members__) if enum is None: IOPRIO_VERYLOW = 0 IOPRIO_LOW = 1 IOPRIO_NORMAL = 2 IOPRIO_HIGH = 3 else: class IOPriority(enum.IntEnum): IOPRIO_VERYLOW = 0 IOPRIO_LOW = 1 IOPRIO_NORMAL = 2 IOPRIO_HIGH = 3 globals().update(IOPriority.__members__) pinfo_map = dict( num_handles=0, ctx_switches=1, user_time=2, kernel_time=3, create_time=4, num_threads=5, io_rcount=6, io_wcount=7, io_rbytes=8, io_wbytes=9, io_count_others=10, io_bytes_others=11, num_page_faults=12, peak_wset=13, wset=14, peak_paged_pool=15, paged_pool=16, peak_non_paged_pool=17, non_paged_pool=18, pagefile=19, peak_pagefile=20, mem_private=21, ) # ===================================================================== # --- named tuples # ===================================================================== # psutil.cpu_times() scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'interrupt', 'dpc']) # psutil.virtual_memory() svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free']) # psutil.Process.memory_info() pmem = namedtuple( 'pmem', ['rss', 'vms', 'num_page_faults', 'peak_wset', 'wset', 'peak_paged_pool', 'paged_pool', 'peak_nonpaged_pool', 'nonpaged_pool', 'pagefile', 'peak_pagefile', 'private']) # psutil.Process.memory_full_info() pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', )) # psutil.Process.memory_maps(grouped=True) pmmap_grouped = namedtuple('pmmap_grouped', ['path', 'rss']) # psutil.Process.memory_maps(grouped=False) pmmap_ext = namedtuple( 'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields)) # psutil.Process.io_counters() pio = namedtuple('pio', ['read_count', 'write_count', 'read_bytes', 'write_bytes', 'other_count', 'other_bytes']) # ===================================================================== # --- utils # ===================================================================== @lru_cache(maxsize=512) def convert_dos_path(s): r"""Convert paths using native DOS format like: "\Device\HarddiskVolume1\Windows\systemew\file.txt" into: "C:\Windows\systemew\file.txt" """ rawdrive = '\\'.join(s.split('\\')[:3]) driveletter = cext.QueryDosDevice(rawdrive) remainder = s[len(rawdrive):] return os.path.join(driveletter, remainder) def py2_strencode(s): """Encode a unicode string to a byte string by using the default fs encoding + "replace" error handler. """ if PY3: return s else: if isinstance(s, str): return s else: return s.encode(ENCODING, ENCODING_ERRS) @memoize def getpagesize(): return cext.getpagesize() # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): """System virtual memory as a namedtuple.""" mem = cext.virtual_mem() totphys, availphys, totsys, availsys = mem # total = totphys avail = availphys free = availphys used = total - avail percent = usage_percent((total - avail), total, round_=1) return svmem(total, avail, percent, used, free) def swap_memory(): """Swap system memory as a (total, used, free, sin, sout) tuple.""" mem = cext.virtual_mem() total_phys = mem[0] total_system = mem[2] # system memory (commit total/limit) is the sum of physical and swap # thus physical memory values need to be substracted to get swap values total = total_system - total_phys # commit total is incremented immediately (decrementing free_system) # while the corresponding free physical value is not decremented until # pages are accessed, so we can't use free system memory for swap. # instead, we calculate page file usage based on performance counter if (total > 0): percentswap = cext.swap_percent() used = int(0.01 * percentswap * total) else: used = 0 free = total - used percent = round(percentswap, 1) return _common.sswap(total, used, free, percent, 0, 0) # ===================================================================== # --- disk # ===================================================================== disk_io_counters = cext.disk_io_counters def disk_usage(path): """Return disk usage associated with path.""" if PY3 and isinstance(path, bytes): # XXX: do we want to use "strict"? Probably yes, in order # to fail immediately. After all we are accepting input here... path = path.decode(ENCODING, errors="strict") total, free = cext.disk_usage(path) used = total - free percent = usage_percent(used, total, round_=1) return _common.sdiskusage(total, used, free, percent) def disk_partitions(all): """Return disk partitions.""" rawlist = cext.disk_partitions(all) return [_common.sdiskpart(x) for x in rawlist] # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system CPU times as a named tuple.""" user, system, idle = cext.cpu_times() # Internally, GetSystemTimes() is used, and it doesn't return # interrupt and dpc times. cext.per_cpu_times() does, so we # rely on it to get those only. percpu_summed = scputimes([sum(n) for n in zip(cext.per_cpu_times())]) return scputimes(user, system, idle, percpu_summed.interrupt, percpu_summed.dpc) def per_cpu_times(): """Return system per-CPU times as a list of named tuples.""" ret = [] for user, system, idle, interrupt, dpc in cext.per_cpu_times(): item = scputimes(user, system, idle, interrupt, dpc) ret.append(item) return ret def cpu_count_logical(): """Return the number of logical CPUs in the system.""" return cext.cpu_count_logical() def cpu_count_cores(): """Return the number of CPU cores in the system.""" return cext.cpu_count_cores() def cpu_stats(): """Return CPU statistics.""" ctx_switches, interrupts, dpcs, syscalls = cext.cpu_stats() soft_interrupts = 0 return _common.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls) def cpu_freq(): """Return CPU frequency. On Windows per-cpu frequency is not supported. """ curr, max_ = cext.cpu_freq() min_ = 0.0 return [_common.scpufreq(float(curr), min_, float(max_))] _loadavg_inititialized = False def getloadavg(): """Return the number of processes in the system run queue averaged over the last 1, 5, and 15 minutes respectively as a tuple""" global _loadavg_inititialized if not _loadavg_inititialized: cext.init_loadavg_counter() _loadavg_inititialized = True # Drop to 2 decimal points which is what Linux does raw_loads = cext.getloadavg() return tuple([round(load, 2) for load in raw_loads]) # ===================================================================== # --- network # ===================================================================== def net_connections(kind, _pid=-1): """Return socket connections. If pid == -1 return system-wide connections (as opposed to connections opened by one process only). """ if kind not in conn_tmap: raise ValueError("invalid %r kind argument; choose between %s" % (kind, ', '.join([repr(x) for x in conn_tmap]))) families, types = conn_tmap[kind] rawlist = cext.net_connections(_pid, families, types) ret = set() for item in rawlist: fd, fam, type, laddr, raddr, status, pid = item nt = conn_to_ntuple(fd, fam, type, laddr, raddr, status, TCP_STATUSES, pid=pid if _pid == -1 else None) ret.add(nt) return list(ret) def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" ret = {} rawdict = cext.net_if_stats() for name, items in rawdict.items(): if not PY3: assert isinstance(name, unicode), type(name) name = py2_strencode(name) isup, duplex, speed, mtu = items if hasattr(_common, 'NicDuplex'): duplex = _common.NicDuplex(duplex) ret[name] = _common.snicstats(isup, duplex, speed, mtu, '') return ret def net_io_counters(): """Return network I/O statistics for every network interface installed on the system as a dict of raw tuples. """ ret = cext.net_io_counters() return dict([(py2_strencode(k), v) for k, v in ret.items()]) def net_if_addrs(): """Return the addresses associated to each NIC.""" ret = [] for items in cext.net_if_addrs(): items = list(items) items[0] = py2_strencode(items[0]) ret.append(items) return ret # ===================================================================== # --- sensors # ===================================================================== def sensors_battery(): """Return battery information.""" # For constants meaning see: # https://msdn.microsoft.com/en-us/library/windows/desktop/ # aa373232(v=vs.85).aspx acline_status, flags, percent, secsleft = cext.sensors_battery() power_plugged = acline_status == 1 no_battery = bool(flags & 128) charging = bool(flags & 8) if no_battery: return None if power_plugged or charging: secsleft = _common.POWER_TIME_UNLIMITED elif secsleft == -1: secsleft = _common.POWER_TIME_UNKNOWN return _common.sbattery(percent, secsleft, power_plugged) # ===================================================================== # --- other system functions # ===================================================================== _last_btime = 0 def boot_time(): """The system boot time expressed in seconds since the epoch.""" # This dirty hack is to adjust the precision of the returned # value which may have a 1 second fluctuation, see: # https://github.com/giampaolo/psutil/issues/1007 global _last_btime ret = float(cext.boot_time()) if abs(ret - _last_btime) <= 1: return _last_btime else: _last_btime = ret return ret def users(): """Return currently connected users as a list of namedtuples.""" retlist = [] rawlist = cext.users() for item in rawlist: user, hostname, tstamp = item user = py2_strencode(user) nt = _common.suser(user, None, hostname, tstamp, None) retlist.append(nt) return retlist # ===================================================================== # --- Windows services # ===================================================================== def win_service_iter(): """Yields a list of WindowsService instances.""" for name, display_name in cext.winservice_enumerate(): yield WindowsService(py2_strencode(name), py2_strencode(display_name)) def win_service_get(name): """Open a Windows service and return it as a WindowsService instance.""" service = WindowsService(name, None) service._display_name = service._query_config()['display_name'] return service class WindowsService(object): """Represents an installed Windows service.""" def __init__(self, name, display_name): self._name = name self._display_name = display_name def __str__(self): details = "(name=%r, display_name=%r)" % ( self._name, self._display_name) return "%s%s" % (self.__class__.__name__, details) def __repr__(self): return "<%s at %s>" % (self.__str__(), id(self)) def __eq__(self, other): # Test for equality with another WindosService object based # on name. if not isinstance(other, WindowsService): return NotImplemented return self._name == other._name def __ne__(self, other): return not self == other def _query_config(self): with self._wrap_exceptions(): display_name, binpath, username, start_type = \ cext.winservice_query_config(self._name) # XXX - update _self.display_name? return dict( display_name=py2_strencode(display_name), binpath=py2_strencode(binpath), username=py2_strencode(username), start_type=py2_strencode(start_type)) def _query_status(self): with self._wrap_exceptions(): status, pid = cext.winservice_query_status(self._name) if pid == 0: pid = None return dict(status=status, pid=pid) @contextlib.contextmanager def _wrap_exceptions(self): """Ctx manager which translates bare OSError and WindowsError exceptions into NoSuchProcess and AccessDenied. """ try: yield except OSError as err: if is_permission_err(err): raise AccessDenied( pid=None, name=self._name, msg="service %r is not querable (not enough privileges)" % self._name) elif err.winerror in (cext.ERROR_INVALID_NAME, cext.ERROR_SERVICE_DOES_NOT_EXIST): raise NoSuchProcess( pid=None, name=self._name, msg="service %r does not exist)" % self._name) else: raise # config query def name(self): """The service name. This string is how a service is referenced and can be passed to win_service_get() to get a new WindowsService instance. """ return self._name def display_name(self): """The service display name. The value is cached when this class is instantiated. """ return self._display_name def binpath(self): """The fully qualified path to the service binary/exe file as a string, including command line arguments. """ return self._query_config()['binpath'] def username(self): """The name of the user that owns this service.""" return self._query_config()['username'] def start_type(self): """A string which can either be "automatic", "manual" or "disabled". """ return self._query_config()['start_type'] # status query def pid(self): """The process PID, if any, else None. This can be passed to Process class to control the service's process. """ return self._query_status()['pid'] def status(self): """Service status as a string.""" return self._query_status()['status'] def description(self): """Service long description.""" return py2_strencode(cext.winservice_query_descr(self.name())) # utils def as_dict(self): """Utility method retrieving all the information above as a dictionary. """ d = self._query_config() d.update(self._query_status()) d['name'] = self.name() d['display_name'] = self.display_name() d['description'] = self.description() return d # actions # XXX: the necessary C bindings for start() and stop() are # implemented but for now I prefer not to expose them. # I may change my mind in the future. Reasons: # - they require Administrator privileges # - can't implement a timeout for stop() (unless by using a thread, # which sucks) # - would require adding ServiceAlreadyStarted and # ServiceAlreadyStopped exceptions, adding two new APIs. # - we might also want to have modify(), which would basically mean # rewriting win32serviceutil.ChangeServiceConfig, which involves a # lot of stuff (and API constants which would pollute the API), see: # http://pyxr.sourceforge.net/PyXR/c/python24/lib/site-packages/ # win32/lib/win32serviceutil.py.html#0175 # - psutil is typically about "read only" monitoring stuff; # win_service_ APIs should only be used to retrieve a service and # check whether it's running # def start(self, timeout=None): # with self._wrap_exceptions(): # cext.winservice_start(self.name()) # if timeout: # giveup_at = time.time() + timeout # while True: # if self.status() == "running": # return # else: # if time.time() > giveup_at: # raise TimeoutExpired(timeout) # else: # time.sleep(.1) # def stop(self): # # Note: timeout is not implemented because it's just not # # possible, see: # # http://stackoverflow.com/questions/11973228/ # with self._wrap_exceptions(): # return cext.winservice_stop(self.name()) # ===================================================================== # --- processes # ===================================================================== pids = cext.pids pid_exists = cext.pid_exists ppid_map = cext.ppid_map # used internally by Process.children() def is_permission_err(exc): """Return True if this is a permission error.""" assert isinstance(exc, OSError), exc # On Python 2 OSError doesn't always have 'winerror'. Sometimes # it does, in which case the original exception was WindowsError # (which is a subclass of OSError). return exc.errno in (errno.EPERM, errno.EACCES) or \ getattr(exc, "winerror", -1) in (cext.ERROR_ACCESS_DENIED, cext.ERROR_PRIVILEGE_NOT_HELD) def convert_oserror(exc, pid=None, name=None): """Convert OSError into NoSuchProcess or AccessDenied.""" assert isinstance(exc, OSError), exc if is_permission_err(exc): return AccessDenied(pid=pid, name=name) if exc.errno == errno.ESRCH: return NoSuchProcess(pid=pid, name=name) raise exc def wrap_exceptions(fun): """Decorator which converts OSError into NoSuchProcess or AccessDenied.""" @functools.wraps(fun) def wrapper(self, args, kwargs): try: return fun(self, args, *kwargs) except OSError as err: raise convert_oserror(err, pid=self.pid, name=self._name) return wrapper def retry_error_partial_copy(fun): """Workaround for https://github.com/giampaolo/psutil/issues/875. See: https://stackoverflow.com/questions/4457745#4457745 """ @functools.wraps(fun) def wrapper(self, args, *kwargs): delay = 0.0001 times = 33 for _ in range(times): # retries for roughly 1 second try: return fun(self, args, *kwargs) except WindowsError as _: err = _ if err.winerror == ERROR_PARTIAL_COPY: time.sleep(delay) delay = min(delay 2, 0.04) continue else: raise else: msg = "%s retried %s times, converted to AccessDenied as it's " \ "still returning %r" % (fun, times, err) raise AccessDenied(pid=self.pid, name=self._name, msg=msg) return wrapper class Process(object): """Wrapper class around underlying C implementation.""" __slots__ = ["pid", "_name", "_ppid", "_cache"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None # --- oneshot() stuff def oneshot_enter(self): self._proc_info.cache_activate(self) self.exe.cache_activate(self) def oneshot_exit(self): self._proc_info.cache_deactivate(self) self.exe.cache_deactivate(self) @memoize_when_activated def _proc_info(self): """Return multiple information about this process as a raw tuple. """ ret = cext.proc_info(self.pid) assert len(ret) == len(pinfo_map) return ret def name(self): """Return process name, which on Windows is always the final part of the executable. """ # This is how PIDs 0 and 4 are always represented in taskmgr # and process-hacker. if self.pid == 0: return "System Idle Process" if self.pid == 4: return "System" return os.path.basename(self.exe()) @wrap_exceptions @memoize_when_activated def exe(self): if PYPY: try: exe = cext.proc_exe(self.pid) except WindowsError as err: # 24 = ERROR_TOO_MANY_OPEN_FILES. Not sure why this happens # (perhaps PyPy's JIT delaying garbage collection of files?). if err.errno == 24: debug("%r translated into AccessDenied" % err) raise AccessDenied(self.pid, self._name) raise else: exe = cext.proc_exe(self.pid) if not PY3: exe = py2_strencode(exe) if exe.startswith('\\'): return convert_dos_path(exe) return exe # May be "Registry", "MemCompression", ... @wrap_exceptions @retry_error_partial_copy def cmdline(self): if cext.WINVER >= cext.WINDOWS_8_1: # PEB method detects cmdline changes but requires more # privileges: https://github.com/giampaolo/psutil/pull/1398 try: ret = cext.proc_cmdline(self.pid, use_peb=True) except OSError as err: if is_permission_err(err): ret = cext.proc_cmdline(self.pid, use_peb=False) else: raise else: ret = cext.proc_cmdline(self.pid, use_peb=True) if PY3: return ret else: return [py2_strencode(s) for s in ret] @wrap_exceptions @retry_error_partial_copy def environ(self): ustr = cext.proc_environ(self.pid) if ustr and not PY3: assert isinstance(ustr, unicode), type(ustr) return parse_environ_block(py2_strencode(ustr)) def ppid(self): try: return ppid_map()[self.pid] except KeyError: raise NoSuchProcess(self.pid, self._name) def _get_raw_meminfo(self): try: return cext.proc_memory_info(self.pid) except OSError as err: if is_permission_err(err): # TODO: the C ext can probably be refactored in order # to get this from cext.proc_info() info = self._proc_info() return ( info[pinfo_map['num_page_faults']], info[pinfo_map['peak_wset']], info[pinfo_map['wset']], info[pinfo_map['peak_paged_pool']], info[pinfo_map['paged_pool']], info[pinfo_map['peak_non_paged_pool']], info[pinfo_map['non_paged_pool']], info[pinfo_map['pagefile']], info[pinfo_map['peak_pagefile']], info[pinfo_map['mem_private']], ) raise @wrap_exceptions def memory_info(self): # on Windows RSS == WorkingSetSize and VSM == PagefileUsage. # Underlying C function returns fields of PROCESS_MEMORY_COUNTERS # struct. t = self._get_raw_meminfo() rss = t[2] # wset vms = t[7] # pagefile return pmem((rss, vms, ) + t) @wrap_exceptions def memory_full_info(self): basic_mem = self.memory_info() uss = cext.proc_memory_uss(self.pid) uss = getpagesize() return pfullmem(basic_mem + (uss, )) def memory_maps(self): try: raw = cext.proc_memory_maps(self.pid) except OSError as err: # XXX - can't use wrap_exceptions decorator as we're # returning a generator; probably needs refactoring. raise convert_oserror(err, self.pid, self._name) else: for addr, perm, path, rss in raw: path = convert_dos_path(path) if not PY3: path = py2_strencode(path) addr = hex(addr) yield (addr, perm, path, rss) @wrap_exceptions def kill(self): return cext.proc_kill(self.pid) @wrap_exceptions def send_signal(self, sig): if sig == signal.SIGTERM: cext.proc_kill(self.pid) # py >= 2.7 elif sig in (getattr(signal, "CTRL_C_EVENT", object()), getattr(signal, "CTRL_BREAK_EVENT", object())): os.kill(self.pid, sig) else: raise ValueError( "only SIGTERM, CTRL_C_EVENT and CTRL_BREAK_EVENT signals " "are supported on Windows") @wrap_exceptions def wait(self, timeout=None): if timeout is None: cext_timeout = cext.INFINITE else: # WaitForSingleObject() expects time in milliseconds. cext_timeout = int(timeout 1000) timer = getattr(time, 'monotonic', time.time) stop_at = timer() + timeout if timeout is not None else None try: # Exit code is supposed to come from GetExitCodeProcess(). # May also be None if OpenProcess() failed with # ERROR_INVALID_PARAMETER, meaning PID is already gone. exit_code = cext.proc_wait(self.pid, cext_timeout) except cext.TimeoutExpired: # WaitForSingleObject() returned WAIT_TIMEOUT. Just raise. raise TimeoutExpired(timeout, self.pid, self._name) except cext.TimeoutAbandoned: # WaitForSingleObject() returned WAIT_ABANDONED, see: # https://github.com/giampaolo/psutil/issues/1224 # We'll just rely on the internal polling and return None # when the PID disappears. Subprocess module does the same # (return None): # https://github.com/python/cpython/blob/ # be50a7b627d0aa37e08fa8e2d5568891f19903ce/ # Lib/subprocess.py#L1193-L1194 exit_code = None # At this point WaitForSingleObject() returned WAIT_OBJECT_0, # meaning the process is gone. Stupidly there are cases where # its PID may still stick around so we do a further internal # polling. delay = 0.0001 while True: if not pid_exists(self.pid): return exit_code if stop_at and timer() >= stop_at: raise TimeoutExpired(timeout, pid=self.pid, name=self._name) time.sleep(delay) delay = min(delay * 2, 0.04) # incremental delay @wrap_exceptions def username(self): if self.pid in (0, 4): return 'NT AUTHORITY\\SYSTEM' domain, user = cext.proc_username(self.pid) return py2_strencode(domain) + '\\' + py2_strencode(user) @wrap_exceptions def create_time(self): # Note: proc_times() not put under oneshot() 'cause create_time() # is already cached by the main Process class. try: user, system, created = cext.proc_times(self.pid) return created except OSError as err: if is_permission_err(err): return self._proc_info()[pinfo_map['create_time']] raise @wrap_exceptions def num_threads(self): return self._proc_info()[pinfo_map['num_threads']] @wrap_exceptions def threads(self): rawlist = cext.proc_threads(self.pid) retlist = [] for thread_id, utime, stime in rawlist: ntuple = _common.pthread(thread_id, utime, stime) retlist.append(ntuple) return retlist @wrap_exceptions def cpu_times(self): try: user, system, created = cext.proc_times(self.pid) except OSError as err: if not is_permission_err(err): raise info = self._proc_info() user = info[pinfo_map['user_time']] system = info[pinfo_map['kernel_time']] # Children user/system times are not retrievable (set to 0). return _common.pcputimes(user, system, 0.0, 0.0) @wrap_exceptions def suspend(self): cext.proc_suspend_or_resume(self.pid, True) @wrap_exceptions def resume(self): cext.proc_suspend_or_resume(self.pid, False) @wrap_exceptions @retry_error_partial_copy def cwd(self): if self.pid in (0, 4): raise AccessDenied(self.pid, self._name) # return a normalized pathname since the native C function appends # "\\" at the and of the path path = cext.proc_cwd(self.pid) return py2_strencode(os.path.normpath(path)) @wrap_exceptions def open_files(self): if self.pid in (0, 4): return [] ret = set() # Filenames come in in native format like: # "\Device\HarddiskVolume1\Windows\systemew\file.txt" # Convert the first part in the corresponding drive letter # (e.g. "C:\") by using Windows's QueryDosDevice() raw_file_names = cext.proc_open_files(self.pid) for _file in raw_file_names: _file = convert_dos_path(_file) if isfile_strict(_file): if not PY3: _file = py2_strencode(_file) ntuple = _common.popenfile(_file, -1) ret.add(ntuple) return list(ret) @wrap_exceptions def connections(self, kind='inet'): return net_connections(kind, _pid=self.pid) @wrap_exceptions def nice_get(self): value = cext.proc_priority_get(self.pid) if enum is not None: value = Priority(value) return value @wrap_exceptions def nice_set(self, value): return cext.proc_priority_set(self.pid, value) @wrap_exceptions def ionice_get(self): ret = cext.proc_io_priority_get(self.pid) if enum is not None: ret = IOPriority(ret) return ret @wrap_exceptions def ionice_set(self, ioclass, value): if value: raise TypeError("value argument not accepted on Windows") if ioclass not in (IOPRIO_VERYLOW, IOPRIO_LOW, IOPRIO_NORMAL, IOPRIO_HIGH): raise ValueError("%s is not a valid priority" % ioclass) cext.proc_io_priority_set(self.pid, ioclass) @wrap_exceptions def io_counters(self): try: ret = cext.proc_io_counters(self.pid) except OSError as err: if not is_permission_err(err): raise info = self._proc_info() ret = ( info[pinfo_map['io_rcount']], info[pinfo_map['io_wcount']], info[pinfo_map['io_rbytes']], info[pinfo_map['io_wbytes']], info[pinfo_map['io_count_others']], info[pinfo_map['io_bytes_others']], ) return pio(ret) @wrap_exceptions def status(self): suspended = cext.proc_is_suspended(self.pid) if suspended: return _common.STATUS_STOPPED else: return _common.STATUS_RUNNING @wrap_exceptions def cpu_affinity_get(self): def from_bitmask(x): return [i for i in range(64) if (1 << i) & x] bitmask = cext.proc_cpu_affinity_get(self.pid) return from_bitmask(bitmask) @wrap_exceptions def cpu_affinity_set(self, value): def to_bitmask(ls): if not ls: raise ValueError("invalid argument %r" % ls) out = 0 for b in ls: out \|= 2 * b return out # SetProcessAffinityMask() states that ERROR_INVALID_PARAMETER # is returned for an invalid CPU but this seems not to be true, # therefore we check CPUs validy beforehand. allcpus = list(range(len(per_cpu_times()))) for cpu in value: if cpu not in allcpus: if not isinstance(cpu, (int, long)): raise TypeError( "invalid CPU %r; an integer is required" % cpu) else: raise ValueError("invalid CPU %r" % cpu) bitmask = to_bitmask(value) cext.proc_cpu_affinity_set(self.pid, bitmask) @wrap_exceptions def num_handles(self): try: return cext.proc_num_handles(self.pid) except OSError as err: if is_permission_err(err): return self._proc_info()[pinfo_map['num_handles']] raise @wrap_exceptions def num_ctx_switches(self): ctx_switches = self._proc_info()[pinfo_map['ctx_switches']] # only voluntary ctx switches are supported return _common.pctxsw(ctx_switches, 0)	36.55 KB	2026-01-20 12:58
📁 tests	-	2026-03-21 15:45

Terminal