Todos los sistemas Unix disponen de una serie de ficheros, los cuales mantienen información sobre los distintos procesos que se están ejecutando en la máquina, Solaris utiliza un pseudo sistemas de ficheros llamado Procfs, en el cual, el kernel mantiene información sobre los procesos que está corriendo.
El sistema de archivos procfs está organizado en directorios, uno por cada proceso en que se ejecuta en la máquina, los directorios se llaman con el PID del proceso del cual mantienen la información.
(root@huelva)# cd /proc (root@huelva)# ls 0 14470 18279 19575 22216 2496 28190 3782 4622 605 1 1464 18340 19604 22610 25190 28252 398 4636 606 10192 1465 18709 19634 22645 25229 285 421 472 6347 10622 14896 18779 2 23054 25479 28610 4210 476 664 11058 15321 18973 20009 23072 25626 28685 439 496 6775 11478 15751 18983 20063 23484 25656 29038 442 5021 678 11906 16187 19031 20450 23505 26047 29039 4428 505 679 1215 1646 19047 20490 23785 26089 29124 445 5061 680 12332 16460 19059 2072 23909 26474 2926 4608 507 7077 127 16611 19064 20881 23945 26528 29464 4609 508 7082 12756 16959 19086 20923 24099 26900 29888 4610 520 7204 13186 17051 19092 21312 24121 26951 3 4611 523 73 13622 17405 19100 21362 24336 27324 326 4613 5491 7628 1372 17480 19105 21744 24369 27382 3362 4614 552 784 14 17849 19141 21785 24764 27754 353 4619 554 789 14042 17907 19202 22178 24800 27811 371 4621 5927 8058 (root@huelva)#
Cada uno de estos ficheros que representa a un proceso contiene un a serie de ficheros y directorios, de los cuales podemos obtener información sobre el proceso y todos sus LWP.
(root@huelva)# cd 29039 (root@huelva)# ls -l total 5933 -rw------- 1 nagios nagios 2998272 Apr 11 12:13 as -r-------- 1 nagios nagios 152 Apr 11 12:13 auxv -r-------- 1 nagios nagios 36 Apr 11 12:13 cred --w------- 1 nagios nagios 0 Apr 11 12:13 ctl lr-x------ 1 nagios nagios 0 Apr 11 12:13 cwd -> dr-x------ 2 nagios nagios 8208 Apr 11 12:13 fd -r--r--r-- 1 nagios nagios 344 Apr 11 12:13 lpsinfo -r-------- 1 nagios nagios 2720 Apr 11 12:13 lstatus -r--r--r-- 1 nagios nagios 1064 Apr 11 12:13 lusage dr-xr-xr-x 5 nagios nagios 80 Apr 11 12:13 lwp -r-------- 1 nagios nagios 3744 Apr 11 12:13 map dr-x------ 2 nagios nagios 800 Apr 11 12:13 object -r-------- 1 nagios nagios 4336 Apr 11 12:13 pagedata -r--r--r-- 1 nagios nagios 336 Apr 11 12:13 psinfo -r-------- 1 nagios nagios 3744 Apr 11 12:13 rmap lr-x------ 1 nagios nagios 0 Apr 11 12:13 root -> -r-------- 1 nagios nagios 1472 Apr 11 12:13 sigact -r-------- 1 nagios nagios 1232 Apr 11 12:13 status -r--r--r-- 1 nagios nagios 256 Apr 11 12:13 usage -r-------- 1 nagios nagios 0 Apr 11 12:13 watch -r-------- 1 nagios nagios 5928 Apr 11 12:13 xmap (root@huelva)#
/proc/< pid >/as
Este fichero contiene una imagen del espacio de direcciones del proceso, podemos abrirlo para realizar tanto lecturas como escrituras.
/proc/< pid >/auxv
Contiene una array de elementos de tipo auxv_t los cuales son pasados al linkador dinámico en el momento en el que se arrancó el proceso.
/proc/< pid >/cred
Este fichero contiene la descripción de las credenciales del proceso. Las credenciales del proceso las define la estructura de datos struct prcred que podemos encontrar el fichero de cabecera sys/procfs.h
/proc/< pid >/ctl
Este fichero es solo de lectura y lo podemos utilizar para enviar mensajes de control al proceso.
/proc/< pid >/cwd
Es un enlace simbólico al directorio actual de trabajo del proceso.
/proc/< pid >/fd/
Este directorio contiene una referencia a cada uno de los descriptores de ficheros que tiene abierto el proceso.
/proc/< pid >/psinfo
Este fichero contiene información del proceso, tal como el PID del su proceso padre, la lista de argumentos, el tamaño de la imagen del proceso en memoria. Para obtener la información de este fichero debemos utilizar una estructura de datos de tipo struct psinfo que está definida en el fichero sys/procfs.h.
typedef struct psinfo {
int pr_flag; /* process flags */
int pr_nlwp; /* number of lwps in process */
pid_t pr_pid; /* unique process id */
pid_t pr_ppid; /* process id of parent */
pid_t pr_pgid; /* pid of process group leader */
pid_t pr_sid; /* session id */
uid_t pr_uid; /* real user id */
uid_t pr_euid; /* effective user id */
gid_t pr_gid; /* real group id */
gid_t pr_egid; /* effective group id */
uintptr_t pr_addr; /* address of process */
size_t pr_size; /* size of process image in Kbytes */
size_t pr_rssize; /* resident set size in Kbytes */
size_t pr_pad1;
dev_t pr_ttydev; /* controlling tty device (or PRNODEV) */
/* The following percent numbers are 16-bit binary */
/* fractions [0 .. 1] with the binary point to the */
/* right of the high-order bit (1.0 == 0x8000) */
ushort_t pr_pctcpu; /* % of recent cpu time used by all lwps */
ushort_t pr_pctmem; /* % of system memory used by process */
timestruc_t pr_start; /* process start time, from the epoch */
timestruc_t pr_time; /* usr+sys cpu time for this process */
timestruc_t pr_ctime; /* usr+sys cpu time for reaped children */
char pr_fname[PRFNSZ]; /* name of execed file */
char pr_psargs[PRARGSZ]; /* initial characters of arg list */
int pr_wstat; /* if zombie, the wait() status */
int pr_argc; /* initial argument count */
uintptr_t pr_argv; /* address of initial argument vector */
uintptr_t pr_envp; /* address of initial environment vector */
char pr_dmodel; /* data model of the process */
char pr_pad2[3];
taskid_t pr_taskid; /* task id */
projid_t pr_projid; /* project id */
int pr_filler[5]; /* reserved for future use */
lwpsinfo_t pr_lwp; /* information for representative lwp */
} psinfo_t;
/proc/< pid >/map
Consiste en un array de elementos del tipo struct prmap los cuales representan un mapa del
espacio de direcciones del proceso.
/proc/< pid >/rmap
Exactamente igual que ocurría con el fichero map, el fichero rmap contien un array de elementos de tipo struct prmap los cuales representan los rangos de direcciones reservadas del proceso dentro de su espacio de direcciones.
/proc/< pid >/xmap
Contiene información extendida sobre el espacio de direcciones del proceso. Para poder leer correctamente el contenido de este fichero necesitaremos utilizar un elemento de tipo struct prxmap, cuya definición podemos encontrar en sys/procfs.h
/proc/< pid >/object/
Es un directorio que contiene los objetos binarios que han sido linkados en el arranque del proceso.
/proc/< pid >/pagedata
Contiene una representación del espacio de direcciones del proceso, de las cual podemos sacar información como el número de páginas que conforman un mapeo de memoria concreto.
/proc/< pid >/sigact
Contiene información sobre las acciones asignadas a las señales que serán tratadas por el proceso.
/proc/< pid >/status
Contiene información de estado del proceso, para poder leer esta información correctamente, debemos utilizar un elemento de tipo struct pstatus que está definido en el fichero sys/procfs.h
typedef struct pstatus {
int pr_flags; /* flags (see below) */
int pr_nlwp; /* number of lwps in the process */
pid_t pr_pid; /* process id */
pid_t pr_ppid; /* parent process id */
pid_t pr_pgid; /* process group id */
pid_t pr_sid; /* session id */
id_t pr_aslwpid; /* lwp id of the aslwp, if any */
id_t pr_agentid; /* lwp id of the /proc agent lwp, if any */
sigset_t pr_sigpend; /* set of process pending signals */
uintptr_t pr_brkbase; /* address of the process heap */
size_t pr_brksize; /* size of the process heap, in bytes */
uintptr_t pr_stkbase; /* address of the process stack */
size_t pr_stksize; /* size of the process stack, in bytes */
timestruc_t pr_utime; /* process user cpu time */
timestruc_t pr_stime; /* process system cpu time */
timestruc_t pr_cutime; /* sum of children's user times */
timestruc_t pr_cstime; /* sum of children's system times */
sigset_t pr_sigtrace; /* set of traced signals */
fltset_t pr_flttrace; /* set of traced faults */
sysset_t pr_sysentry; /* set of system calls traced on entry */
sysset_t pr_sysexit; /* set of system calls traced on exit */
char pr_dmodel; /* data model of the process (see below) */
char pr_pad[3];
taskid_t pr_taskid; /* task id */
projid_t pr_projid; /* project id */
int pr_filler[17]; /* reserved for future use */
lwpstatus_t pr_lwp; /* status of the representative lwp */
} pstatus_t;
/proc/< pid >/usage
Este fichero contiene información sobre estadísticas del proceso, tales como tiempos de uso de CPU, tiempos de fallos de páginas, número de llamadas a sistema, etc. Para poder leer toda esta información necesitamos utilizar la estructura de datos struct prusage, la cual está definida en el fichero sys/procfs.h.
/proc/< pid >/watch
Contiene un array con todos los watchpoints activos en el proceso.
/proc/< pid >/lwp/
Este directorio contiene a su vez un subdirectorio por cada LWP del proceso, el nombre de este subdirectorio corresponde con el ID del LWP.
/proc/< pid >/lwp/< lwpid >/lwpctl
Al igual que podemos enviar mensajes de control al proceso, podemos hacer lo mismo con cada LWP, mediante este fichero que es de solo escritura.
/proc/< pid >/lwp/< lwpid >/lwpsinfo
Contiene información del LWP tal como el id del procesador en el que ha corrido, uso de CPU o la dirección de la WCHAN que tiene asociado el LWP. Para poder leer toda esta información necesitamos un elemento de tipo struct lwpsinfo, cuya definición podemos encontrarla en el fichero sys/procfs.h.
/proc/< pid >/lwp/< lwpid >/lwpstatus
Contiene información de estado del LWP, para acceder a esta información necesitamos un elemento de tipo struct lwpstatus.
typedef struct lwpstatus {
int pr_flags; /* flags (see below) */
id_t pr_lwpid; /* specific lwp identifier */
short pr_why; /* reason for lwp stop, if stopped */
short pr_what; /* more detailed reason */
short pr_cursig; /* current signal, if any */
short pr_pad1;
siginfo_t pr_info; /* info associated with signal or fault */
sigset_t pr_lwppend; /* set of signals/ pending to the lwp */
sigset_t pr_lwphold; /* set of signals blocked by the lwp */
struct sigaction pr_action; /* signal action for current signal */
stack_t pr_altstack; /* alternate signal stack info */
uintptr_t pr_oldcontext; /* address of previous ucontext */
short pr_syscall; /* system call number (if in syscall) */
short pr_nsysarg; /* number of arguments to this syscall */
int pr_errno; /* errno for failed syscall, 0 if successful */
long pr_sysarg[PRSYSARGS]; /* arguments to this syscall */
long pr_rval1; /* primary syscall return value */
long pr_rval2; /* second syscall return value, if any */
char pr_clname[PRCLSZ]; /* scheduling class name */
timestruc_t pr_tstamp; /* real-time time stamp of stop */
timestruc_t pr_utime; /* lwp user cpu time */
timestruc_t pr_stime; /* lwp system cpu time */
int pr_filler[12 - 2 * sizeof (timestruc_t) / sizeof (int)];
uintptr_t pr_ustack; /* address of stack boundary data (stack_t) */
ulong_t pr_instr; /* current instruction */
prgregset_t pr_reg; /* general registers */
prfpregset_t pr_fpreg; /* floating-point registers */
} lwpstatus_t;
/proc/< pid >/lwp/< lwpid >/lwpusage
Al igual que la información de uso del proceso, cada LWP dispone de una fichero del que podemos obtener información sobre el uso de CPU, tiempo de fallo de página, señales recibidas. Para leer el fichero necesitamos utilizar un elemento de tipo struct prusage, la definición de este tipo la podemos encontrar en el fichero sys/procfs.h
/proc/< pid >/lpsinfo
El fichero está formado por una cabecera, la cual tiene un estructura de tipo struct prheader, dicha cabecera está formada por 2 campos, uno con el número de elementos y otro con el tamaño de cada elemento. A la cabecera le sigue el cuerpo que está formado por un arrays de elementos, uno por cada LWP del proceso, estos elementos son del tipo struct lwpsinfo.
/proc/< pid >/lstatus
Al igual que en el caso anterior, este fichero contiene información de estado de todos los LWP que tiene el proceso, para ello se utiliza una cabecera de tipo struct prheader, dicha cabecera está formada por 2 campos, uno con el número de elementos y otro con el tamaño de cada elemento. A la cabecera le sigue el cuerpo que está formado por un arrays de elementos, uno por cada LWP del proceso, estos elementos son del tipo struct lwpstatus.
/proc/< pid >/lusage
El fichero está formado por una cabecera, la cual tiene un estructura de tipo struct prheader, dicha cabecera está formada por 2 campos, uno con el número de elementos y otro con el tamaño de cada elemento. A la cabecera le sigue el cuerpo que está formado por un arrays de elementos, uno por cada LWP del proceso, estos elementos son del tipo struct prusage.
La definición de la estructura de datos prheader, la podemos encontrar en el fichero sys/procfs.h
typedef struct prheader {
long pr_nent; /* number of entries */
long pr_entsize; /* size of each entry, in bytes */
} prheader_t;
<< | >> Navegando en el /proc (II)
Technorati Tag(s) : Solaris OpenSolaris MDB