Solaris: Navegando en el /proc (I)

Kernel, OpenSolaris Dejar un comentario

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) :

Los comentarios están cerrados.

My name is null, /dev/null
Algunos derechos reservados. Licencia Creative Commons