You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
724 lines
25 KiB
724 lines
25 KiB
# 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 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 b
|
|
from ._compat import PY3
|
|
|
|
|
|
__extra__all__ = ["CONN_IDLE", "CONN_BOUND", "PROCFS_PATH"]
|
|
|
|
|
|
# =====================================================================
|
|
# --- globals
|
|
# =====================================================================
|
|
|
|
|
|
PAGE_SIZE = os.sysconf('SC_PAGE_SIZE')
|
|
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)
|
|
|
|
# These objects get set on "import psutil" from the __init__.py
|
|
# file, see: https://github.com/giampaolo/psutil/issues/1402
|
|
NoSuchProcess = None
|
|
ZombieProcess = None
|
|
AccessDenied = None
|
|
TimeoutExpired = None
|
|
|
|
|
|
# =====================================================================
|
|
# --- 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, stderr = 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[-2:]
|
|
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_physical():
|
|
"""Return the number of physical CPUs in the system."""
|
|
return cext.cpu_count_phys()
|
|
|
|
|
|
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.
|
|
if not disk_usage(mountpoint).total:
|
|
continue
|
|
ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
|
|
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
|
|
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 EnvironmentError as err:
|
|
if self.pid == 0:
|
|
if 0 in pids():
|
|
raise AccessDenied(self.pid, self._name)
|
|
else:
|
|
raise
|
|
# 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 err.errno in (errno.ENOENT, errno.ESRCH):
|
|
if not pid_exists(self.pid):
|
|
raise NoSuchProcess(self.pid, self._name)
|
|
else:
|
|
raise ZombieProcess(self.pid, self._name, self._ppid)
|
|
if err.errno in (errno.EPERM, errno.EACCES):
|
|
raise AccessDenied(self.pid, self._name)
|
|
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):
|
|
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 OSError as err:
|
|
if err.errno == errno.ENOENT:
|
|
hit_enoent = True
|
|
continue
|
|
raise
|
|
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 OSError as err:
|
|
if err.errno == errno.ENOENT:
|
|
os.stat("%s/%s" % (procfs_path, self.pid)) # raise NSP or AD
|
|
return None
|
|
raise
|
|
|
|
@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 OSError as err:
|
|
# ENOENT == file which is gone in the meantime
|
|
if err.errno == errno.ENOENT:
|
|
hit_enoent = True
|
|
continue
|
|
raise
|
|
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)
|