Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/psutil/_pssunos.py @ 0:26e78fe6e8c4 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload commit c699937486c35866861690329de38ec1a5d9f783"
author shellac
date Sat, 02 May 2020 07:14:21 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:26e78fe6e8c4
1 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
2 # Use of this source code is governed by a BSD-style license that can be
3 # found in the LICENSE file.
4
5 """Sun OS Solaris platform implementation."""
6
7 import errno
8 import functools
9 import os
10 import socket
11 import subprocess
12 import sys
13 from collections import namedtuple
14 from socket import AF_INET
15
16 from . import _common
17 from . import _psposix
18 from . import _psutil_posix as cext_posix
19 from . import _psutil_sunos as cext
20 from ._common import AccessDenied
21 from ._common import AF_INET6
22 from ._common import debug
23 from ._common import get_procfs_path
24 from ._common import isfile_strict
25 from ._common import memoize_when_activated
26 from ._common import NoSuchProcess
27 from ._common import sockfam_to_enum
28 from ._common import socktype_to_enum
29 from ._common import usage_percent
30 from ._common import ZombieProcess
31 from ._compat import b
32 from ._compat import FileNotFoundError
33 from ._compat import PermissionError
34 from ._compat import ProcessLookupError
35 from ._compat import PY3
36
37
38 __extra__all__ = ["CONN_IDLE", "CONN_BOUND", "PROCFS_PATH"]
39
40
41 # =====================================================================
42 # --- globals
43 # =====================================================================
44
45
46 PAGE_SIZE = os.sysconf('SC_PAGE_SIZE')
47 AF_LINK = cext_posix.AF_LINK
48 IS_64_BIT = sys.maxsize > 2**32
49
50 CONN_IDLE = "IDLE"
51 CONN_BOUND = "BOUND"
52
53 PROC_STATUSES = {
54 cext.SSLEEP: _common.STATUS_SLEEPING,
55 cext.SRUN: _common.STATUS_RUNNING,
56 cext.SZOMB: _common.STATUS_ZOMBIE,
57 cext.SSTOP: _common.STATUS_STOPPED,
58 cext.SIDL: _common.STATUS_IDLE,
59 cext.SONPROC: _common.STATUS_RUNNING, # same as run
60 cext.SWAIT: _common.STATUS_WAITING,
61 }
62
63 TCP_STATUSES = {
64 cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
65 cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
66 cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV,
67 cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
68 cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
69 cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
70 cext.TCPS_CLOSED: _common.CONN_CLOSE,
71 cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
72 cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
73 cext.TCPS_LISTEN: _common.CONN_LISTEN,
74 cext.TCPS_CLOSING: _common.CONN_CLOSING,
75 cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
76 cext.TCPS_IDLE: CONN_IDLE, # sunos specific
77 cext.TCPS_BOUND: CONN_BOUND, # sunos specific
78 }
79
80 proc_info_map = dict(
81 ppid=0,
82 rss=1,
83 vms=2,
84 create_time=3,
85 nice=4,
86 num_threads=5,
87 status=6,
88 ttynr=7,
89 uid=8,
90 euid=9,
91 gid=10,
92 egid=11)
93
94
95 # =====================================================================
96 # --- named tuples
97 # =====================================================================
98
99
100 # psutil.cpu_times()
101 scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait'])
102 # psutil.cpu_times(percpu=True)
103 pcputimes = namedtuple('pcputimes',
104 ['user', 'system', 'children_user', 'children_system'])
105 # psutil.virtual_memory()
106 svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
107 # psutil.Process.memory_info()
108 pmem = namedtuple('pmem', ['rss', 'vms'])
109 pfullmem = pmem
110 # psutil.Process.memory_maps(grouped=True)
111 pmmap_grouped = namedtuple('pmmap_grouped',
112 ['path', 'rss', 'anonymous', 'locked'])
113 # psutil.Process.memory_maps(grouped=False)
114 pmmap_ext = namedtuple(
115 'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
116
117
118 # =====================================================================
119 # --- memory
120 # =====================================================================
121
122
123 def virtual_memory():
124 """Report virtual memory metrics."""
125 # we could have done this with kstat, but IMHO this is good enough
126 total = os.sysconf('SC_PHYS_PAGES') * PAGE_SIZE
127 # note: there's no difference on Solaris
128 free = avail = os.sysconf('SC_AVPHYS_PAGES') * PAGE_SIZE
129 used = total - free
130 percent = usage_percent(used, total, round_=1)
131 return svmem(total, avail, percent, used, free)
132
133
134 def swap_memory():
135 """Report swap memory metrics."""
136 sin, sout = cext.swap_mem()
137 # XXX
138 # we are supposed to get total/free by doing so:
139 # http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/
140 # usr/src/cmd/swap/swap.c
141 # ...nevertheless I can't manage to obtain the same numbers as 'swap'
142 # cmdline utility, so let's parse its output (sigh!)
143 p = subprocess.Popen(['/usr/bin/env', 'PATH=/usr/sbin:/sbin:%s' %
144 os.environ['PATH'], 'swap', '-l'],
145 stdout=subprocess.PIPE)
146 stdout, stderr = p.communicate()
147 if PY3:
148 stdout = stdout.decode(sys.stdout.encoding)
149 if p.returncode != 0:
150 raise RuntimeError("'swap -l' failed (retcode=%s)" % p.returncode)
151
152 lines = stdout.strip().split('\n')[1:]
153 if not lines:
154 raise RuntimeError('no swap device(s) configured')
155 total = free = 0
156 for line in lines:
157 line = line.split()
158 t, f = line[-2:]
159 total += int(int(t) * 512)
160 free += int(int(f) * 512)
161 used = total - free
162 percent = usage_percent(used, total, round_=1)
163 return _common.sswap(total, used, free, percent,
164 sin * PAGE_SIZE, sout * PAGE_SIZE)
165
166
167 # =====================================================================
168 # --- CPU
169 # =====================================================================
170
171
172 def cpu_times():
173 """Return system-wide CPU times as a named tuple"""
174 ret = cext.per_cpu_times()
175 return scputimes(*[sum(x) for x in zip(*ret)])
176
177
178 def per_cpu_times():
179 """Return system per-CPU times as a list of named tuples"""
180 ret = cext.per_cpu_times()
181 return [scputimes(*x) for x in ret]
182
183
184 def cpu_count_logical():
185 """Return the number of logical CPUs in the system."""
186 try:
187 return os.sysconf("SC_NPROCESSORS_ONLN")
188 except ValueError:
189 # mimic os.cpu_count() behavior
190 return None
191
192
193 def cpu_count_physical():
194 """Return the number of physical CPUs in the system."""
195 return cext.cpu_count_phys()
196
197
198 def cpu_stats():
199 """Return various CPU stats as a named tuple."""
200 ctx_switches, interrupts, syscalls, traps = cext.cpu_stats()
201 soft_interrupts = 0
202 return _common.scpustats(ctx_switches, interrupts, soft_interrupts,
203 syscalls)
204
205
206 # =====================================================================
207 # --- disks
208 # =====================================================================
209
210
211 disk_io_counters = cext.disk_io_counters
212 disk_usage = _psposix.disk_usage
213
214
215 def disk_partitions(all=False):
216 """Return system disk partitions."""
217 # TODO - the filtering logic should be better checked so that
218 # it tries to reflect 'df' as much as possible
219 retlist = []
220 partitions = cext.disk_partitions()
221 for partition in partitions:
222 device, mountpoint, fstype, opts = partition
223 if device == 'none':
224 device = ''
225 if not all:
226 # Differently from, say, Linux, we don't have a list of
227 # common fs types so the best we can do, AFAIK, is to
228 # filter by filesystem having a total size > 0.
229 try:
230 if not disk_usage(mountpoint).total:
231 continue
232 except OSError as err:
233 # https://github.com/giampaolo/psutil/issues/1674
234 debug("skipping %r: %r" % (mountpoint, err))
235 continue
236 ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
237 retlist.append(ntuple)
238 return retlist
239
240
241 # =====================================================================
242 # --- network
243 # =====================================================================
244
245
246 net_io_counters = cext.net_io_counters
247 net_if_addrs = cext_posix.net_if_addrs
248
249
250 def net_connections(kind, _pid=-1):
251 """Return socket connections. If pid == -1 return system-wide
252 connections (as opposed to connections opened by one process only).
253 Only INET sockets are returned (UNIX are not).
254 """
255 cmap = _common.conn_tmap.copy()
256 if _pid == -1:
257 cmap.pop('unix', 0)
258 if kind not in cmap:
259 raise ValueError("invalid %r kind argument; choose between %s"
260 % (kind, ', '.join([repr(x) for x in cmap])))
261 families, types = _common.conn_tmap[kind]
262 rawlist = cext.net_connections(_pid)
263 ret = set()
264 for item in rawlist:
265 fd, fam, type_, laddr, raddr, status, pid = item
266 if fam not in families:
267 continue
268 if type_ not in types:
269 continue
270 # TODO: refactor and use _common.conn_to_ntuple.
271 if fam in (AF_INET, AF_INET6):
272 if laddr:
273 laddr = _common.addr(*laddr)
274 if raddr:
275 raddr = _common.addr(*raddr)
276 status = TCP_STATUSES[status]
277 fam = sockfam_to_enum(fam)
278 type_ = socktype_to_enum(type_)
279 if _pid == -1:
280 nt = _common.sconn(fd, fam, type_, laddr, raddr, status, pid)
281 else:
282 nt = _common.pconn(fd, fam, type_, laddr, raddr, status)
283 ret.add(nt)
284 return list(ret)
285
286
287 def net_if_stats():
288 """Get NIC stats (isup, duplex, speed, mtu)."""
289 ret = cext.net_if_stats()
290 for name, items in ret.items():
291 isup, duplex, speed, mtu = items
292 if hasattr(_common, 'NicDuplex'):
293 duplex = _common.NicDuplex(duplex)
294 ret[name] = _common.snicstats(isup, duplex, speed, mtu)
295 return ret
296
297
298 # =====================================================================
299 # --- other system functions
300 # =====================================================================
301
302
303 def boot_time():
304 """The system boot time expressed in seconds since the epoch."""
305 return cext.boot_time()
306
307
308 def users():
309 """Return currently connected users as a list of namedtuples."""
310 retlist = []
311 rawlist = cext.users()
312 localhost = (':0.0', ':0')
313 for item in rawlist:
314 user, tty, hostname, tstamp, user_process, pid = item
315 # note: the underlying C function includes entries about
316 # system boot, run level and others. We might want
317 # to use them in the future.
318 if not user_process:
319 continue
320 if hostname in localhost:
321 hostname = 'localhost'
322 nt = _common.suser(user, tty, hostname, tstamp, pid)
323 retlist.append(nt)
324 return retlist
325
326
327 # =====================================================================
328 # --- processes
329 # =====================================================================
330
331
332 def pids():
333 """Returns a list of PIDs currently running on the system."""
334 return [int(x) for x in os.listdir(b(get_procfs_path())) if x.isdigit()]
335
336
337 def pid_exists(pid):
338 """Check for the existence of a unix pid."""
339 return _psposix.pid_exists(pid)
340
341
342 def wrap_exceptions(fun):
343 """Call callable into a try/except clause and translate ENOENT,
344 EACCES and EPERM in NoSuchProcess or AccessDenied exceptions.
345 """
346 @functools.wraps(fun)
347 def wrapper(self, *args, **kwargs):
348 try:
349 return fun(self, *args, **kwargs)
350 except (FileNotFoundError, ProcessLookupError):
351 # ENOENT (no such file or directory) gets raised on open().
352 # ESRCH (no such process) can get raised on read() if
353 # process is gone in meantime.
354 if not pid_exists(self.pid):
355 raise NoSuchProcess(self.pid, self._name)
356 else:
357 raise ZombieProcess(self.pid, self._name, self._ppid)
358 except PermissionError:
359 raise AccessDenied(self.pid, self._name)
360 except OSError:
361 if self.pid == 0:
362 if 0 in pids():
363 raise AccessDenied(self.pid, self._name)
364 else:
365 raise
366 raise
367 return wrapper
368
369
370 class Process(object):
371 """Wrapper class around underlying C implementation."""
372
373 __slots__ = ["pid", "_name", "_ppid", "_procfs_path", "_cache"]
374
375 def __init__(self, pid):
376 self.pid = pid
377 self._name = None
378 self._ppid = None
379 self._procfs_path = get_procfs_path()
380
381 def _assert_alive(self):
382 """Raise NSP if the process disappeared on us."""
383 # For those C function who do not raise NSP, possibly returning
384 # incorrect or incomplete result.
385 os.stat('%s/%s' % (self._procfs_path, self.pid))
386
387 def oneshot_enter(self):
388 self._proc_name_and_args.cache_activate(self)
389 self._proc_basic_info.cache_activate(self)
390 self._proc_cred.cache_activate(self)
391
392 def oneshot_exit(self):
393 self._proc_name_and_args.cache_deactivate(self)
394 self._proc_basic_info.cache_deactivate(self)
395 self._proc_cred.cache_deactivate(self)
396
397 @wrap_exceptions
398 @memoize_when_activated
399 def _proc_name_and_args(self):
400 return cext.proc_name_and_args(self.pid, self._procfs_path)
401
402 @wrap_exceptions
403 @memoize_when_activated
404 def _proc_basic_info(self):
405 if self.pid == 0 and not \
406 os.path.exists('%s/%s/psinfo' % (self._procfs_path, self.pid)):
407 raise AccessDenied(self.pid)
408 ret = cext.proc_basic_info(self.pid, self._procfs_path)
409 assert len(ret) == len(proc_info_map)
410 return ret
411
412 @wrap_exceptions
413 @memoize_when_activated
414 def _proc_cred(self):
415 return cext.proc_cred(self.pid, self._procfs_path)
416
417 @wrap_exceptions
418 def name(self):
419 # note: max len == 15
420 return self._proc_name_and_args()[0]
421
422 @wrap_exceptions
423 def exe(self):
424 try:
425 return os.readlink(
426 "%s/%s/path/a.out" % (self._procfs_path, self.pid))
427 except OSError:
428 pass # continue and guess the exe name from the cmdline
429 # Will be guessed later from cmdline but we want to explicitly
430 # invoke cmdline here in order to get an AccessDenied
431 # exception if the user has not enough privileges.
432 self.cmdline()
433 return ""
434
435 @wrap_exceptions
436 def cmdline(self):
437 return self._proc_name_and_args()[1].split(' ')
438
439 @wrap_exceptions
440 def environ(self):
441 return cext.proc_environ(self.pid, self._procfs_path)
442
443 @wrap_exceptions
444 def create_time(self):
445 return self._proc_basic_info()[proc_info_map['create_time']]
446
447 @wrap_exceptions
448 def num_threads(self):
449 return self._proc_basic_info()[proc_info_map['num_threads']]
450
451 @wrap_exceptions
452 def nice_get(self):
453 # Note #1: getpriority(3) doesn't work for realtime processes.
454 # Psinfo is what ps uses, see:
455 # https://github.com/giampaolo/psutil/issues/1194
456 return self._proc_basic_info()[proc_info_map['nice']]
457
458 @wrap_exceptions
459 def nice_set(self, value):
460 if self.pid in (2, 3):
461 # Special case PIDs: internally setpriority(3) return ESRCH
462 # (no such process), no matter what.
463 # The process actually exists though, as it has a name,
464 # creation time, etc.
465 raise AccessDenied(self.pid, self._name)
466 return cext_posix.setpriority(self.pid, value)
467
468 @wrap_exceptions
469 def ppid(self):
470 self._ppid = self._proc_basic_info()[proc_info_map['ppid']]
471 return self._ppid
472
473 @wrap_exceptions
474 def uids(self):
475 try:
476 real, effective, saved, _, _, _ = self._proc_cred()
477 except AccessDenied:
478 real = self._proc_basic_info()[proc_info_map['uid']]
479 effective = self._proc_basic_info()[proc_info_map['euid']]
480 saved = None
481 return _common.puids(real, effective, saved)
482
483 @wrap_exceptions
484 def gids(self):
485 try:
486 _, _, _, real, effective, saved = self._proc_cred()
487 except AccessDenied:
488 real = self._proc_basic_info()[proc_info_map['gid']]
489 effective = self._proc_basic_info()[proc_info_map['egid']]
490 saved = None
491 return _common.puids(real, effective, saved)
492
493 @wrap_exceptions
494 def cpu_times(self):
495 try:
496 times = cext.proc_cpu_times(self.pid, self._procfs_path)
497 except OSError as err:
498 if err.errno == errno.EOVERFLOW and not IS_64_BIT:
499 # We may get here if we attempt to query a 64bit process
500 # with a 32bit python.
501 # Error originates from read() and also tools like "cat"
502 # fail in the same way (!).
503 # Since there simply is no way to determine CPU times we
504 # return 0.0 as a fallback. See:
505 # https://github.com/giampaolo/psutil/issues/857
506 times = (0.0, 0.0, 0.0, 0.0)
507 else:
508 raise
509 return _common.pcputimes(*times)
510
511 @wrap_exceptions
512 def cpu_num(self):
513 return cext.proc_cpu_num(self.pid, self._procfs_path)
514
515 @wrap_exceptions
516 def terminal(self):
517 procfs_path = self._procfs_path
518 hit_enoent = False
519 tty = wrap_exceptions(
520 self._proc_basic_info()[proc_info_map['ttynr']])
521 if tty != cext.PRNODEV:
522 for x in (0, 1, 2, 255):
523 try:
524 return os.readlink(
525 '%s/%d/path/%d' % (procfs_path, self.pid, x))
526 except FileNotFoundError:
527 hit_enoent = True
528 continue
529 if hit_enoent:
530 self._assert_alive()
531
532 @wrap_exceptions
533 def cwd(self):
534 # /proc/PID/path/cwd may not be resolved by readlink() even if
535 # it exists (ls shows it). If that's the case and the process
536 # is still alive return None (we can return None also on BSD).
537 # Reference: http://goo.gl/55XgO
538 procfs_path = self._procfs_path
539 try:
540 return os.readlink("%s/%s/path/cwd" % (procfs_path, self.pid))
541 except FileNotFoundError:
542 os.stat("%s/%s" % (procfs_path, self.pid)) # raise NSP or AD
543 return None
544
545 @wrap_exceptions
546 def memory_info(self):
547 ret = self._proc_basic_info()
548 rss = ret[proc_info_map['rss']] * 1024
549 vms = ret[proc_info_map['vms']] * 1024
550 return pmem(rss, vms)
551
552 memory_full_info = memory_info
553
554 @wrap_exceptions
555 def status(self):
556 code = self._proc_basic_info()[proc_info_map['status']]
557 # XXX is '?' legit? (we're not supposed to return it anyway)
558 return PROC_STATUSES.get(code, '?')
559
560 @wrap_exceptions
561 def threads(self):
562 procfs_path = self._procfs_path
563 ret = []
564 tids = os.listdir('%s/%d/lwp' % (procfs_path, self.pid))
565 hit_enoent = False
566 for tid in tids:
567 tid = int(tid)
568 try:
569 utime, stime = cext.query_process_thread(
570 self.pid, tid, procfs_path)
571 except EnvironmentError as err:
572 if err.errno == errno.EOVERFLOW and not IS_64_BIT:
573 # We may get here if we attempt to query a 64bit process
574 # with a 32bit python.
575 # Error originates from read() and also tools like "cat"
576 # fail in the same way (!).
577 # Since there simply is no way to determine CPU times we
578 # return 0.0 as a fallback. See:
579 # https://github.com/giampaolo/psutil/issues/857
580 continue
581 # ENOENT == thread gone in meantime
582 if err.errno == errno.ENOENT:
583 hit_enoent = True
584 continue
585 raise
586 else:
587 nt = _common.pthread(tid, utime, stime)
588 ret.append(nt)
589 if hit_enoent:
590 self._assert_alive()
591 return ret
592
593 @wrap_exceptions
594 def open_files(self):
595 retlist = []
596 hit_enoent = False
597 procfs_path = self._procfs_path
598 pathdir = '%s/%d/path' % (procfs_path, self.pid)
599 for fd in os.listdir('%s/%d/fd' % (procfs_path, self.pid)):
600 path = os.path.join(pathdir, fd)
601 if os.path.islink(path):
602 try:
603 file = os.readlink(path)
604 except FileNotFoundError:
605 hit_enoent = True
606 continue
607 else:
608 if isfile_strict(file):
609 retlist.append(_common.popenfile(file, int(fd)))
610 if hit_enoent:
611 self._assert_alive()
612 return retlist
613
614 def _get_unix_sockets(self, pid):
615 """Get UNIX sockets used by process by parsing 'pfiles' output."""
616 # TODO: rewrite this in C (...but the damn netstat source code
617 # does not include this part! Argh!!)
618 cmd = "pfiles %s" % pid
619 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
620 stderr=subprocess.PIPE)
621 stdout, stderr = p.communicate()
622 if PY3:
623 stdout, stderr = [x.decode(sys.stdout.encoding)
624 for x in (stdout, stderr)]
625 if p.returncode != 0:
626 if 'permission denied' in stderr.lower():
627 raise AccessDenied(self.pid, self._name)
628 if 'no such process' in stderr.lower():
629 raise NoSuchProcess(self.pid, self._name)
630 raise RuntimeError("%r command error\n%s" % (cmd, stderr))
631
632 lines = stdout.split('\n')[2:]
633 for i, line in enumerate(lines):
634 line = line.lstrip()
635 if line.startswith('sockname: AF_UNIX'):
636 path = line.split(' ', 2)[2]
637 type = lines[i - 2].strip()
638 if type == 'SOCK_STREAM':
639 type = socket.SOCK_STREAM
640 elif type == 'SOCK_DGRAM':
641 type = socket.SOCK_DGRAM
642 else:
643 type = -1
644 yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE)
645
646 @wrap_exceptions
647 def connections(self, kind='inet'):
648 ret = net_connections(kind, _pid=self.pid)
649 # The underlying C implementation retrieves all OS connections
650 # and filters them by PID. At this point we can't tell whether
651 # an empty list means there were no connections for process or
652 # process is no longer active so we force NSP in case the PID
653 # is no longer there.
654 if not ret:
655 # will raise NSP if process is gone
656 os.stat('%s/%s' % (self._procfs_path, self.pid))
657
658 # UNIX sockets
659 if kind in ('all', 'unix'):
660 ret.extend([_common.pconn(*conn) for conn in
661 self._get_unix_sockets(self.pid)])
662 return ret
663
664 nt_mmap_grouped = namedtuple('mmap', 'path rss anon locked')
665 nt_mmap_ext = namedtuple('mmap', 'addr perms path rss anon locked')
666
667 @wrap_exceptions
668 def memory_maps(self):
669 def toaddr(start, end):
670 return '%s-%s' % (hex(start)[2:].strip('L'),
671 hex(end)[2:].strip('L'))
672
673 procfs_path = self._procfs_path
674 retlist = []
675 try:
676 rawlist = cext.proc_memory_maps(self.pid, procfs_path)
677 except OSError as err:
678 if err.errno == errno.EOVERFLOW and not IS_64_BIT:
679 # We may get here if we attempt to query a 64bit process
680 # with a 32bit python.
681 # Error originates from read() and also tools like "cat"
682 # fail in the same way (!).
683 # Since there simply is no way to determine CPU times we
684 # return 0.0 as a fallback. See:
685 # https://github.com/giampaolo/psutil/issues/857
686 return []
687 else:
688 raise
689 hit_enoent = False
690 for item in rawlist:
691 addr, addrsize, perm, name, rss, anon, locked = item
692 addr = toaddr(addr, addrsize)
693 if not name.startswith('['):
694 try:
695 name = os.readlink(
696 '%s/%s/path/%s' % (procfs_path, self.pid, name))
697 except OSError as err:
698 if err.errno == errno.ENOENT:
699 # sometimes the link may not be resolved by
700 # readlink() even if it exists (ls shows it).
701 # If that's the case we just return the
702 # unresolved link path.
703 # This seems an incosistency with /proc similar
704 # to: http://goo.gl/55XgO
705 name = '%s/%s/path/%s' % (procfs_path, self.pid, name)
706 hit_enoent = True
707 else:
708 raise
709 retlist.append((addr, perm, name, rss, anon, locked))
710 if hit_enoent:
711 self._assert_alive()
712 return retlist
713
714 @wrap_exceptions
715 def num_fds(self):
716 return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid)))
717
718 @wrap_exceptions
719 def num_ctx_switches(self):
720 return _common.pctxsw(
721 *cext.proc_num_ctx_switches(self.pid, self._procfs_path))
722
723 @wrap_exceptions
724 def wait(self, timeout=None):
725 return _psposix.wait_pid(self.pid, timeout, self._name)