/usr/lib/python3.9/site-packages/procfs/__pycache__
Edit: /usr/lib/python3.9/site-packages/procfs/__pycache__/procfs.cpython-39.pyc (36571B)
a
]h @ s d dl Z d dlZd dlZd dlZd dlmZ d dlmZ dZdd Z dd Z
G d d
d
Z d d Z d
d Z
G dd dZG dd dZG dd dZG dd dZG dd dZG dd dZG dd d ZG d d d ZG d d d ZG d!d" d"Zed#krd dlZe Zeej D ] Z e e d$eje q e Z ee j D ] Z e e d$e j e qPe Z!e d%e!j" d& ee! D ] Z#e e# d'e!e# qe d( ee$ej%d) Z&e'e&j(D ]*Z e e&j)e j*d*d+e&j)e j+ qe d, e&,ej%d- D ]Z-e e-d. qe Z.e e.d) e Z/e0d) e/1 e/D ] Z!e e! d$e/e! q\e d/ qFdS )0 N)reduce) bitmasklistz0.7.4c C s t } ttd| S )z) Return True if running on s390 or s390x Zs390)platformmachineboolresearch)r r 1/usr/lib/python3.9/site-packages/procfs/procfs.pyis_s390 s r c C s@ | d r t dd | d S z| d d W S Y dS 0 dS )z
Returns the process command line, if available in the given `process' class,
if not available, falls back to using the comm (short process name) in its
pidstat key.
cmdlinec S s | d| S )Nz %sr )abr r r
! z!process_cmdline..statcommN)r strip)Zpid_infor r r
process_cmdline s r c @ s e Zd ZdZdZdZdZdZdZdZ dZ
d Z d
Z d Z
d Zd
ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ dZ dZ d Z d Z!d Z"d Z#d Z$d Z%d!Z&d!Z'g d"Z(d9d$d%Z)d&d' Z*d(d) Z+d*d+ Z,d,d- Z-d.d/ Z.d0d1 Z/d:d2d3Z0d4d5 Z1d6d7 Z2d8S );pidstatam
Provides a dictionary to access the fields in the
per process /proc/PID/stat files.
One can obtain the available fields by asking for the keys of the
dictionary, e.g.:
>>> p = procfs.pidstat(1)
>>> print p.keys()
['majflt', 'rss', 'cnswap', 'cstime', 'pid', 'session', 'startstack', 'startcode', 'cmajflt', 'blocked', 'exit_signal', 'minflt', 'nswap', 'environ', 'priority', 'state', 'delayacct_blkio_ticks', 'policy', 'rt_priority', 'ppid', 'nice', 'cutime', 'endcode', 'wchan', 'num_threads', 'sigcatch', 'comm', 'stime', 'sigignore', 'tty_nr', 'kstkeip', 'utime', 'tpgid', 'itrealvalue', 'kstkesp', 'rlim', 'signal', 'pgrp', 'flags', 'starttime', 'cminflt', 'vsize', 'processor']
And then access the various process properties using it as a dictionary:
>>> print p['comm']
systemd
>>> print p['priority']
20
>>> print p['state']
S
Please refer to the 'procfs(5)' man page, by using:
$ man 5 procfs
To see information for each of the above fields, it is part of the
'man-pages' RPM package.
@ i i i i i i @ i i i i i i i i @ i i i i i i i @l )+pidr stateZppidZpgrpZsessionZtty_nrZtpgidflagsZminfltZcminfltZmajfltZcmajfltutimeZstimeZcutimeZcstimepriorityniceZ num_threadsZ itrealvalueZ starttimeZvsizeZrssZrlimZ startcodeZendcodeZ
startstackZkstkespZkstkeipsignalZblockedZ sigignoreZsigcatchZwchanZnswapZcnswapZ exit_signal processor rt_priorityZpolicyZdelayacct_blkio_ticksenviron/procc C s. || _ z| | W n ty( Y n0 d S N)r loadFileNotFoundErrorselfr basedirr r r
__init__~ s
zpidstat.__init__c C s
| j | S r+ fieldsr/ Z fieldnamer r r
__getitem__ s zpidstat.__getitem__c C s t | j S r+ listr3 keysr/ r r r
r8 s z pidstat.keysc C s t | j S r+ r7 r3 valuesr9 r r r
r; s zpidstat.valuesc C s
|| j v S r+ r2 r4 r r r
has_key s zpidstat.has_keyc C s | j S r+ r2 r9 r r r
items s z
pidstat.itemsc C s
|| j v S r+ r2 r4 r r r
__contains__ s zpidstat.__contains__c C s zt | d| j d}W n ty. Y n0 | d}| |d d|d }i | _tt |t | j
}t |D ]Z}| j
| }|| }|dkr|d| jd< qzt || j|< W q || j|< Y q0 qd S ) N/z/statz) r z (r r z())
openr r- readliner splitcloser3 minlenproc_stat_fieldsrangeint)r/ r0 fr3 nr_fieldsiattrnamevaluer r r
r, s$
z pidstat.loadc C s t | jd | j@ S )z
Returns true if this process has a fixed smp affinity mask,
not allowing it to be moved to a different set of CPUs.
r" )r r3 PF_THREAD_BOUNDr9 r r r
is_bound_to_cpu s zpidstat.is_bound_to_cpuc C sJ g }t | D ]8}|dd dkr"q t| |}|| jd @ r || q |S )a
Returns a list with all the process flags known, details depend
on kernel version, declared in the file include/linux/sched.h in
the kernel sources.
As of v4.2-rc7 these include (from include/linux/sched.h comments):
PF_EXITING Getting shut down
PF_EXITPIDONE Pi exit done on shut down
PF_VCPU I'm a virtual CPU
PF_WQ_WORKER I'm a workqueue worker
PF_FORKNOEXEC Forked but didn't exec
PF_MCE_PROCESS Process policy on mce errors
PF_SUPERPRIV Used super-user privileges
PF_DUMPCORE Dumped core
PF_SIGNALED Killed by a signal
PF_MEMALLOC Allocating memory
PF_NPROC_EXCEEDED Set_user noticed that RLIMIT_NPROC was exceeded
PF_USED_MATH If unset the fpu must be initialized before use
PF_USED_ASYNC Used async_schedule*(), used by module init
PF_NOFREEZE This thread should not be frozen
PF_FROZEN Frozen for system suspend
PF_FSTRANS Inside a filesystem transaction
PF_KSWAPD I am kswapd
PF_MEMALLOC_NOIO Allocating memory without IO involved
PF_LESS_THROTTLE Throttle me less: I clean memory
PF_KTHREAD I am a kernel thread
PF_RANDOMIZE Randomize virtual address space
PF_SWAPWRITE Allowed to write to swap
PF_NO_SETAFFINITY Userland is not allowed to meddle with cpus_allowed
PF_MCE_EARLY Early kill for mce process policy
PF_MUTEX_TESTER Thread belongs to the rt mutex tester
PF_FREEZER_SKIP Freezer should not count it as freezable
PF_SUSPEND_TASK This thread called freeze_processes and
should not be frozen
N ZPF_r" )dirgetattrr3 append)r/ ZsflagsattrrM r r r
process_flags s &
zpidstat.process_flagsN)r* )r* )3__name__
__module__ __qualname____doc__Z PF_ALIGNWARNZ PF_STARTINGZ
PF_EXITINGZ
PF_EXITPIDONEZPF_VCPUZ PF_WQ_WORKERZ
PF_FORKNOEXECZPF_MCE_PROCESSZ PF_SUPERPRIVZ PF_DUMPCOREZ PF_SIGNALEDZ PF_MEMALLOCZPF_NPROC_EXCEEDEDZ
PF_FLUSHERZ PF_USED_MATHZ
PF_USED_ASYNCZ PF_NOFREEZEZ PF_FROZENZ
PF_FSTRANSZ PF_KSWAPDZPF_MEMALLOC_NOIOZ
PF_SWAPOFFZPF_LESS_THROTTLEZ
PF_KTHREADZ PF_RANDOMIZEZ PF_SWAPWRITEZPF_SPREAD_PAGEZPF_SPREAD_SLABrN PF_NO_SETAFFINITYZ PF_MCE_EARLYZ PF_MEMPOLICYZPF_MUTEX_TESTERZPF_FREEZER_SKIPZPF_FREEZER_NOSIGZPF_SUSPEND_TASKrF r1 r5 r8 r; r< r= r> r, rO rU r r r r
r * s`
r c C s8 d}z t t| j| d d |@ W S Y dS 0 d S Nr r r" T)r rH processes)r/ r rZ r r r
cannot_set_affinity s r] c C s> d}z&t t| j| j| d d |@ W S Y dS 0 d S r[ )r rH r\ threads)r/ r tidrZ r r r
cannot_set_thread_affinity s r` c @ sT e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dddZ dS ) pidstatusa
Provides a dictionary to access the fields
in the per process /proc/PID/status files.
This provides additional information about processes and threads to
what can be obtained with the procfs.pidstat() class.
One can obtain the available fields by asking for the keys of the
dictionary, e.g.:
>>> import procfs
>>> p = procfs.pidstatus(1)
>>> print p.keys()
['VmExe', 'CapBnd', 'NSpgid', 'Tgid', 'NSpid', 'VmSize', 'VmPMD', 'ShdPnd', 'State', 'Gid', 'nonvoluntary_ctxt_switches', 'SigIgn', 'VmStk', 'VmData', 'SigCgt', 'CapEff', 'VmPTE', 'Groups', 'NStgid', 'Threads', 'PPid', 'VmHWM', 'NSsid', 'VmSwap', 'Name', 'SigBlk', 'Mems_allowed_list', 'VmPeak', 'Ngid', 'VmLck', 'SigQ', 'VmPin', 'Mems_allowed', 'CapPrm', 'Seccomp', 'VmLib', 'Cpus_allowed', 'Uid', 'SigPnd', 'Pid', 'Cpus_allowed_list', 'TracerPid', 'CapInh', 'voluntary_ctxt_switches', 'VmRSS', 'FDSize']
>>> print p["Pid"]
1
>>> print p["Threads"]
1
>>> print p["VmExe"]
1248 kB
>>> print p["Cpus_allowed"]
f
>>> print p["SigQ"]
0/30698
>>> print p["VmPeak"]
320300 kB
>>>
Please refer to the 'procfs(5)' man page, by using:
$ man 5 procfs
To see information for each of the above fields, it is part of the
'man-pages' RPM package.
In the man page there will be references to further documentation, like
referring to the "getrlimit(2)" man page when explaining the "SigQ"
line/field.
r* c C s || _ | | d S r+ )r r, r. r r r
r1 ! s zpidstatus.__init__c C s
| j | S r+ r2 r4 r r r
r5 % s zpidstatus.__getitem__c C s t | j S r+ r6 r9 r r r
r8 ( s zpidstatus.keysc C s t | j S r+ r: r9 r r r
r; + s zpidstatus.valuesc C s
|| j v S r+ r2 r4 r r r
r< . s zpidstatus.has_keyc C s | j S r+ r2 r9 r r r
r= 1 s zpidstatus.itemsc C s
|| j v S r+ r2 r4 r r r
r> 4 s zpidstatus.__contains__c C s i | _ t| d| j dt}| D ]Z}|d}t|dkrBq&|d }|d }zt|| j |< W q& || j |< Y q&0 q&W d n1 s0 Y d S )Nr? z/status:r r r )r3 r@ r readlinesrB rE r rH )r/ r0 rI liner3 namerM r r r
r, 7 s
zpidstatus.loadN)r* )r* ) rV rW rX rY r1 r5 r8 r; r< r= r> r, r r r r
ra s '
ra c @ sR e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS )processa+
Information about a process with a given pid, provides a dictionary with
two entries, instances of different wrappers for /proc/ process related
meta files: "stat" and "status", see the documentation for procfs.pidstat
and procfs.pidstatus for further info about those classes.
r* c C s || _ || _d S r+ )r r0 r. r r r
r1 N s zprocess.__init__c C s t | |s|dv rV|dkr t}nt}zt| ||| j| j W q tyR Y q0 nF|dkrh| n4|dkrz| n"|dkr| n|dkr|
t | |S )N)r statusr r r^ cgroupsr) ) hasattrr ra setattrr r0 r- load_cmdline load_threads load_cgroups load_environrR )r/ rT Zsclassr r r
r5 R s$
zprocess.__getitem__c C s
t | |S r+ ri r/ rT r r r
r< j s zprocess.has_keyc C s
t | |S r+ ro rp r r r
r> m s zprocess.__contains__c C s zRt d| j d,}| dd d | _W d n1 sF0 Y W n. tyj d | _Y n ty d | _Y n0 d S )N/proc/z/cmdline )r@ r rA r rB r r- UnicodeDecodeError)r/ rI r r r
rk p s >
zprocess.load_cmdlinec C s" t d| j d| _| j| j= d S )Nrq z/task/)pidstatsr r^ r9 r r r
rl { s zprocess.load_threadsc C s d| _ td| j dX}t| D ]:}t| j dkrR| j d |d d | _ q&|d d | _ q&W d n1 sv0 Y d S )N rq z/cgroupr ,rs )rh r@ r reversedrc rE )r/ rI rd r r r
rm s zprocess.load_cgroupsc C sx i | _ td| j dL}| dD ],}t|dkr(|d}|d | j |d < q(W d n1 sj0 Y dS )aD
Loads the environment variables for this process. The entries then
become available via the 'environ' member, or via the 'environ'
dict key when accessing as p["environ"].
E.g.:
>>> all_processes = procfs.pidstats()
>>> firefox_pid = all_processes.find_by_name("firefox")
>>> firefox_process = all_processes[firefox_pid[0]]
>>> print firefox_process["environ"]["PWD"]
/home/acme
>>> print len(firefox_process.environ.keys())
66
>>> print firefox_process["environ"]["SHELL"]
/bin/bash
>>> print firefox_process["environ"]["USERNAME"]
acme
>>> print firefox_process["environ"]["HOME"]
/home/acme
>>> print firefox_process["environ"]["MAIL"]
/var/spool/mail/acme
>>>
rq z/environrr r =r N)r) r@ r rA rB rE )r/ rI xyr r r
rn s
zprocess.load_environN)r* ) rV rW rX rY r1 r5 r< r> rk rl rm rn r r r r
rf F s
rf c @ s e Zd ZdZd$ddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zd d Zd d Zd!d" Zd#S )%ru a#
Provides access to all the processes in the system, to get a picture of
how many processes there are at any given moment.
The entries can be accessed as a dictionary, keyed by pid. Also there are
methods to find processes that match a given COMM or regular expression.
r* c C s || _ i | _| d S r+ )r0 r\ reload)r/ r0 r r r
r1 s zpidstats.__init__c C s
| j | S r+ r\ r/ keyr r r
r5 s zpidstats.__getitem__c C s z | j |= W n Y n0 d S r+ r} r~ r r r
__delitem__ s zpidstats.__delitem__c C s t | j S r+ )r7 r\ r8 r9 r r r
r8 s z
pidstats.keysc C s t | j S r+ )r7 r\ r; r9 r r r
r; s zpidstats.valuesc C s
|| j v S r+ r} r~ r r r
r< s zpidstats.has_keyc C s | j S r+ r} r9 r r r
r= s zpidstats.itemsc C s
|| j v S r+ r} r~ r r r
r> s zpidstats.__contains__c C sT | ` i | _ t| j}|D ]4}z t|}W n Y qY n0 t|| j| j |< qdS )a'
This operation will throw away the current dictionary contents,
if any, and read all the pid files from /proc/, instantiating a
'process' instance for each of them.
This is a high overhead operation, and should be avoided if the
perf python binding can be used to detect when new threads appear
and existing ones terminate.
In RHEL it is found in the python-perf rpm package.
More information about the perf facilities can be found in the
'perf_event_open' man page.
N)r\ oslistdirr0 rH rf )r/ pidsZspidr r r r
r| s
zpidstats.reloadc C s^ g }t | j D ]4}z| j| W q tyD || Y q0 q|D ] }| j|= qLd S r+ )r7 r\ r8 rl OSErrorrS )r/ to_remover r r r
reload_threads s zpidstats.reload_threadsc C sh |d d }g }t | j D ]D}z$|| j| d d krD|| W q ty` | j|= Y q 0 q |S )N r r )r7 r\ r8 rS IOError)r/ re r r r r r
find_by_name s zpidstats.find_by_namec C s^ g }t | j D ]F}z&|| j| d d r:|| W q tyV | j|= Y q0 q|S )Nr r )r7 r\ r8 matchrS r r/ regexr r r r r
find_by_regex s zpidstats.find_by_regexc C sZ g }t | j D ]B}z"|t| j| r6|| W q tyR | j|= Y q0 q|S r+ )r7 r\ r8 r r rS r r r r r
find_by_cmdline_regex s z pidstats.find_by_cmdline_regexc s d}d}g | d| }| |}|rt fdd|D dkrDq|D ]<}z || j| d d 7 }W qH ty | j|= Y qH0 qH |7 |d7 }q |d }|S )
Nr rv r? c s g | ]}| vr|qS r r .0nZprocessed_pidsr r
' r z0pidstats.get_per_cpu_rtprios..r r( r rw r rE r\ r r )r/ basenamecpu
prioritiesre r r r r r
get_per_cpu_rtprios s
z pidstats.get_per_cpu_rtpriosc s d}d}g | |}|rt fdd|D dkr6q|D ]<}z || j| d d 7 }W q: tyt | j|= Y q:0 q: |7 |d7 }q |d}|S ) Nr rv c s g | ]}| vr|qS r r r r r r
r = r z(pidstats.get_rtprios..r r( r rw r )r/ re r r r r r r r
get_rtprios7 s
zpidstats.get_rtpriosc C s | j | d S )zQ
Checks if a given pid can't have its SMP affinity mask changed.
r )r\ rO r/ r r r r
rO M s zpidstats.is_bound_to_cpuN)r* )rV rW rX rY r1 r5 r r8 r; r< r= r> r| r r r r r r rO r r r r
ru s"
ru c @ sp e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd ZdS )
interruptsam
Information about IRQs in the system. A dictionary keyed by IRQ number
will have as its value another dictionary with "cpu", "type" and "users"
keys, with the SMP affinity mask, type of IRQ and the drivers associated
with each interrupt.
The information comes from the /proc/interrupts file, documented in
'man procfs(5)', for instance, the 'cpu' dict is an array with one entry
per CPU present in the system, each value being the number of interrupts
that took place per CPU.
E.g.:
>>> import procfs
>>> interrupts = procfs.interrupts()
>>> thunderbolt_irq = interrupts.find_by_user("thunderbolt")
>>> print thunderbolt_irq
34
>>> thunderbolt = interrupts[thunderbolt_irq]
>>> print thunderbolt
{'affinity': [0, 1, 2, 3], 'type': 'PCI-MSI', 'cpu': [3495, 0, 81, 0], 'users': ['thunderbolt']}
>>>
c C s i | _ | d S r+ )r r| r9 r r r
r1 m s zinterrupts.__init__c C s | j t| S r+ )r strr~ r r r
r5 q s zinterrupts.__getitem__c C s t | j S r+ r7 r r8 r9 r r r
r8 t s zinterrupts.keysc C s t | j S r+ )r7 r r; r9 r r r
r; w s zinterrupts.valuesc C s t || jv S r+ r r r~ r r r
r< z s zinterrupts.has_keyc C s | j S r+ )r r9 r r r
r= } s zinterrupts.itemsc C s t || jv S r+ r r~ r r r
r> s zinterrupts.__contains__c C s | ` i | _ td}| D ]}| }| }|d d d dkrPt|| _q |d d}i | j |< | |dd || j |< z t|}W n Y q Y n0 | || j | d< q W d n1 s0 Y d S )Nz/proc/interruptsr rP ZCPUrb r Zaffinity)
r r@ rc r rB rE nr_cpus parse_entryrH parse_affinity)r/ rI rd r3 irqZnirqr r r
r| s"
zinterrupts.reloadc C s i }g |d< |d t|d t|}|| jkr|d dd |d| j D 7 < || jkr|| j |d< || jd krdd ||d dD |d < ng |d < |S )
Nr r c S s g | ] }t |qS r rH r rK r r r
r r z*interrupts.parse_entry..r typec S s g | ] }| qS r )r r r
r r r
r s rw users)rS rH rE r rB )r/ r3 rd dictrJ r r r
r s
$
zinterrupts.parse_entryc C sd zFt d| d}| }W d n1 s00 Y t|| jW S ty^ dg Y S 0 d S )Nz
/proc/irq/z
/smp_affinityr )r@ rA r r r )r/ r rI rd r r r
r s & zinterrupts.parse_affinityc C s@ t | j D ],}d| j| v r|| j| d v r| S qdS )a
Looks up a interrupt number by the name of one of its users"
E.g.:
>>> import procfs
>>> interrupts = procfs.interrupts()
>>> thunderbolt_irq = interrupts.find_by_user("thunderbolt")
>>> print thunderbolt_irq
34
>>> thunderbolt = interrupts[thunderbolt_irq]
>>> print thunderbolt
{'affinity': [0, 1, 2, 3], 'type': 'PCI-MSI', 'cpu': [3495, 0, 81, 0], 'users': ['thunderbolt']}
>>>
r Nr )r/ userrK r r r
find_by_user s
zinterrupts.find_by_userc C sX g }t | j D ]@}d| j| vr&q| j| d D ] }||r4|| qq4q|S )a
Looks up a interrupt number by a regex that matches names of its users"
E.g.:
>>> import procfs
>>> import re
>>> interrupts = procfs.interrupts()
>>> usb_controllers = interrupts.find_by_user_regex(re.compile(".*hcd"))
>>> print usb_controllers
['22', '23', '31']
>>> print [ interrupts[irq]["users"] for irq in usb_controllers ]
[['ehci_hcd:usb4'], ['ehci_hcd:usb3'], ['xhci_hcd']]
>>>
r )r7 r r8 r rS )r/ r ZirqsrK r r r r
find_by_user_regex s
z interrupts.find_by_user_regexN)rV rW rX rY r1 r5 r8 r; r< r= r> r| r r r r r r r r
r T s r c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dS )r a9
Parses the kernel command line (/proc/cmdline), turning it into a dictionary."
Useful to figure out if some kernel boolean knob has been turned on,
as well as to find the value associated to other kernel knobs.
It can also be used to find out about parameters passed to the
init process, such as 'BOOT_IMAGE', etc.
E.g.:
>>> import procfs
>>> kcmd = procfs.cmdline()
>>> print kcmd.keys()
['LANG', 'BOOT_IMAGE', 'quiet', 'rhgb', 'rd.lvm.lv', 'ro', 'root']
>>> print kcmd["BOOT_IMAGE"]
/vmlinuz-4.3.0-rc1+
>>>
c C s i | _ | d S r+ )optionsparser9 r r r
r1 s zcmdline.__init__c C sz t d^}| D ]<}|d}t|dkrDd| j|d < q|d | j|d < qW d n1 sl0 Y d S )Nz
/proc/cmdlinery r Tr )r@ rA r rB rE r )r/ rI optionr3 r r r
r s
z
cmdline.parsec C s
| j | S r+ r r~ r r r
r5 s zcmdline.__getitem__c C s t | j S r+ )r7 r r8 r9 r r r
r8 s z cmdline.keysc C s t | j S r+ )r7 r r; r9 r r r
r; s zcmdline.valuesc C s | j S r+ r r9 r r r
r=
s z
cmdline.itemsN)
rV rW rX rY r1 r r5 r8 r; r= r r r r
r s r c @ sB e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dS )cpuinfoa
Dictionary with information about CPUs in the system.
Please refer to 'man procfs(5)' for further information about the
'/proc/cpuinfo' file, that is the source of the information provided
by this class. The 'man lscpu(1)' also has information about a program that
uses the '/proc/cpuinfo' file.
Using this class one can obtain the number of CPUs in a system:
>>> cpus = procfs.cpuinfo()
>>> print cpus.nr_cpus
4
It is also possible to figure out aspects of the CPU topology, such as
how many CPU physical sockets exists, i.e. groups of CPUs sharing
components such as CPU memory caches:
>>> print len(cpus.sockets)
1
Additionally dictionary with information common to all CPUs in the system
is available:
>>> print cpus["model name"]
Intel(R) Core(TM) i7-3667U CPU @ 2.00GHz
>>> print cpus["cache size"]
4096 KB
>>>
/proc/cpuinfoc C s i | _ d| _g | _| | d S Nr )tagsr socketsr r/ filenamer r r
r1 . s zcpuinfo.__init__c C s | j | S r+ r lowerr~ r r r
r5 4 s zcpuinfo.__getitem__c C s t | j S r+ r7 r r8 r9 r r r
r8 7 s z cpuinfo.keysc C s t | j S r+ r7 r r; r9 r r r
r; : s zcpuinfo.valuesc C s | j S r+ r r9 r r r
r= = s z
cpuinfo.itemsc C s> t |}| D ]}| }|s$q|d}|d }|dkrV| jd7 _qt rt|dkrt| jd7 _q|dkr~q|d | j|< |dkr| j| }|| jvr| j | qW d n1 s0 Y | jrt
| jp| jd| jv r
t | jd p d | _ d | jv r.t | jd p0d| j | _
d S )
Nrb r r' r z
cpu numberzcore idz physical idZsiblingsz cpu cores)r@ rc r rB r r r r r rS rE rH Z
nr_socketsZnr_cores)r/ r rI rd r3 ZtagnameZ socket_idr r r
r @ s<
, z
cpuinfo.parseN)r )
rV rW rX rY r1 r5 r8 r; r= r r r r r
r s
r c @ s8 e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd S )
smaps_libat
Representation of an mmap in place for a process. Can be used to figure
out which processes have an library mapped, etc.
The 'perm' member can be used to figure out executable mmaps,
i.e. libraries.
The 'vm_start' and 'vm_end' in turn can be used when trying to resolve
processor instruction pointer addresses to a symbol name in a library.
c C s |d }dd |d dD \| _| _|d | _t|d d| _|d d \| _| _t|d
| _t |d kr|d | _
nd | _
i | _ |dd D ]N}| }|d d d }zt|d | j |< W q || j |< Y q0 qd S )
Nr c S s g | ]}t |d qS )r r r r r r
r j r z&smaps_lib.__init__..-r r r rP rb r rs )
rB vm_startZvm_endZpermsrH offsetmajorminorinoderE re r r )r/ linesr3 rd tagr r r
r1 h s"
zsmaps_lib.__init__c C s | j | S r+ r r~ r r r
r5 } s zsmaps_lib.__getitem__c C s t | j S r+ r r9 r r r
r8 s zsmaps_lib.keysc C s t | j S r+ r r9 r r r
r; s zsmaps_lib.valuesc C s | j S r+ r r9 r r r
r= s zsmaps_lib.itemsN) rV rW rX rY r1 r5 r8 r; r= r r r r
r \ s r c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dS )smapsa~
List of libraries mapped by a process. Parses the lines in
the /proc/PID/smaps file, that is further documented in the
procfs(5) man page.
Example: Listing the executable maps for the 'sshd' process:
>>> import procfs
>>> processes = procfs.pidstats()
>>> sshd = processes.find_by_name("sshd")
>>> sshd_maps = procfs.smaps(sshd[0])
>>> for i in range(len(sshd_maps)):
... if 'x' in sshd_maps[i].perms:
... print "%s: %s" % (sshd_maps[i].name, sshd_maps[i].perms)
...
/usr/sbin/sshd: r-xp
/usr/lib64/libnss_files-2.20.so: r-xp
/usr/lib64/librt-2.20.so: r-xp
/usr/lib64/libkeyutils.so.1.5: r-xp
/usr/lib64/libkrb5support.so.0.1: r-xp
/usr/lib64/libfreebl3.so: r-xp
/usr/lib64/libpthread-2.20.so: r-xp
...
c C s || _ g | _| d S r+ )r entriesr| r r r r
r1 s zsmaps.__init__c C st g }|s| }|s d S || | }|s4q`| }| d d dkr`|| q&q`q&| jt| |S )Nr rs rb )rA r rS rB r r )r/ rI rd r r r r
r s
zsmaps.parse_entryc C s
t | jS r+ )rE r r9 r r r
__len__ s z
smaps.__len__c C s
| j | S r+ r )r/ indexr r r
r5 s zsmaps.__getitem__c C sZ d }t d| j d$}| ||}|sq,qW d n1 s@0 Y t| j| _d S )Nrq z/smaps)r@ r r rE r
nr_entries)r/ rd rI r r r
r| s "z smaps.reloadc C sJ g }t | jD ]6}| j| jr| j| j|dkr|| j| q|S r )rG r r re findrS )r/ fragmentresultrK r r r
find_by_name_fragment s zsmaps.find_by_name_fragmentN)
rV rW rX rY r1 r r r5 r| r r r r r
r s r c @ s e Zd ZdZdd Zdd ZdS )cpustatz
CPU statistics, obtained from a line in the '/proc/stat' file, Please
refer to 'man procfs(5)' for further information about the '/proc/stat'
file, that is the source of the information provided by this class.
c C st |d | _ dd |dd D \| _| _| _| _| _| _| _t|dkrpt |d | _
t|dkrpt |d | _ d S )Nr c S s g | ] }t |qS r r r r r r
r r z$cpustat.__init__..r r ) re r r% systemidleiowaitr softirqrE rH stealguest)r/ r3 r r r
r1 s
zcpustat.__init__c C sx d| j d| j d| j d| j d| j d| j d| j }t| drV|d | j 7 }t| d
rp|d | j 7 }|d S )
Nz< user: z, nice: z
, system: z, idle: z
, iowait: z, irq: z , softirq: r z , steal: r z , guest: >)
r r% r r r r r ri r r )r/ sr r r
__repr__ s <
zcpustat.__repr__N)rV rW rX rY r1 r r r r r
r s r c @ sR e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dS ) cpusstatsaN
Dictionary with information about CPUs in the system. First entry in the
dictionary gives an aggregate view of all CPUs, each other entry is about
separate CPUs. Please refer to 'man procfs(5)' for further information
about the '/proc/stat' file, that is the source of the information provided
by this class.
/proc/statc C s* i | _ d | _td| _|| _| d S )Nr )r timer sysconfhertzr r| r r r r
r1 s
zcpusstats.__init__c C s
t | jS r+ )iterr r9 r r r
__iter__ s zcpusstats.__iter__c C s
| j | S r+ r r~ r r r
r5 s zcpusstats.__getitem__c C s t t| j S r+ )rE r7 r r8 r9 r r r
r s zcpusstats.__len__c C s t | j S r+ )r7 r r8 r9 r r r
r8 s zcpusstats.keysc C s t | j S r+ )r7 r r; r9 r r r
r; s zcpusstats.valuesc C s | j S r+ r r9 r r r
r= s zcpusstats.itemsc C sF | j }i | _ t| j|}| D ]b}| }|d d d dkrJq t|}|jdkrbd}nt |jdd d }|| j |< q W d n1 s0 Y | j
}t
| _
|rB| j
| }|| j } t | j
D ]f}
|
|vrd| _q| j |
} ||
} | j| j | j| j | j| j }
|
| d | _t| jd| _qd S )Nr rP r r d )r r@ r rc r rB r r re rH r r r7 r8 usager r% r rD )r/ Z last_entriesrI rd r3 cidxZ last_timeZ delta_secZ interval_hzr ZcurrprevZdeltar r r
r| s<
*
zcpusstats.reloadN)r ) rV rW rX rY r1 r r5 r r8 r; r= r| r r r r
r s
r __main__z: z
cpuinfo data: z processorsry z/smaps:
----------------------------------------r z#x z(----------------------------------------r ZSizez
----------)2r r r r functoolsr Zprocfs.utilistr ZVERSIONr r r r] r` ra rf ru r r r r r r r rV sysZintsr7 r8 rK printr or r r rH argvr rG r r r re r r
Zpscssleepr| r r r r
sf > Me *
.N.K B
(