File /proc

Finalità

Contiene informazioni di stato relative ai processi e ai thread nel sistema.

Sintassi

   #include <sys/procfs.h>

Descrizione

Il file system /proc fornisce l'accesso allo stato di ogni processo attivo e thread nel sistema. Il nome di ogni voce nel file system /proc è un numero decimale corrispondente al processo ID. Queste voci sono sottodirectory e il proprietario di ciascuno è determinato dall'ID utente del processo. L'accesso allo stato di processo viene fornito da ulteriori file contenuti all'interno di ogni sottodirectory. Salvo quanto diversamente specificato, il termine File /proc si intende fare riferimento ad un file non di directory all'interno della gerarchia radicato a /proc. Il proprietario di ogni file è determinato dall'ID utente del processo.

Le varie /proc directory, file e nomi di campo contengono il termine lwp (processo di peso leggero). Questo termine si riferisce ad un thread del kernel. I file /proc non fanno riferimento ai pthread dello spazio utente. Sebbene il sistema operativo non utilizzi il termine lwp per descrivere i propri thread, viene utilizzato nel file system /proc per la compatibilità con altri sistemi operativi UNIX .

Le seguenti interfacce di subroutine standard sono utilizzate per accedere ai file /proc :

• aperto subroutine
• chiudi subroutine
• leggi subroutine
• scrivere subroutine

La maggior parte dei file descrive lo stato di processo e sono destinati a essere letti solo. I file ctl (controllo) e lwpctl (controllo thread) consentono la manipolazione dello stato di processo e possono essere aperti solo per la scrittura. Il file come (space space) contiene l'immagine del processo di esecuzione e può essere aperto sia per la lettura che per la scrittura. Una scrittura aperta consente il controllo dei processi mentre un open - only aperto consente l'ispezione ma non il controllo di processo. Così, un processo viene descritto come aperto per la lettura o la scrittura se uno qualsiasi dei suoi file /proc associati viene aperto per la lettura o la scrittura, rispettivamente.

In generale, più di un processo può aprire lo stesso file /proc contemporaneamente. L'apertura esclusiva ha lo scopo di consentire il controllo dei processi senza un altro processo che tenta di aprire il file contemporaneamente. Un processo può ottenere il controllo esclusivo di un processo di destinazione se apre con successo qualsiasi file /proc nel processo di destinazione per la scrittura (i file come o ctl o il file lwpctl di qualsiasi thread del kernel) mentre specifica il flag O_EXCL nella sottoroutine aperto . Una simile chiamata della sottoroutine aperto fallisce se il processo di destinazione è già aperto per la scrittura (cioè se un file ctl, comeo lwpctl è aperto per la scrittura). Le istanze di sola lettura simultane-only della sottoroutine aperto possono esistere; il flag O_EXCL viene ignorato sulla sottoroutine aperto per la lettura. La prima apertura per la scrittura da parte di un processo di controllo dovrebbe utilizzare la bandiera O_EXCL . Più processi che cercano di controllare lo stesso processo di destinazione di solito si tradugono in errori.

I dati possono essere trasferiti da o verso qualsiasi località nello spazio di indirizzo del processo tracciato chiamando la sottoroutine lseek per posire il file come all'indirizzo di interesse virtuale, seguito da una chiamata alla sottoroutine leggi o scrivere . Una richiesta I/O che si estende in un'area non mappata viene troncata al limite. Una richiesta leggi o scrivere che inizia ad un indirizzo virtuale non mappato fallisce con errno impostato su EFAULT.

   prfillset(&set);            /* turn on all flags in set */
   premptyset(&set);           /* turn off all flags in set */
   praddset(&set, flag);       /* turn on the specified flag */
   prdelset(&set, flag);       /* turn off the specified flag */
   r = prismember(&set, flag); /* != 0 if flag is turned on */

La macro prfillset o premptyset deve essere utilizzata per inizializzare il tipo pr_sigset_t o fltset_t prima di essere utilizzato in qualsiasi altra operazione. Il parametro bandiera deve essere un membro dell'enumerazione che corrisponde all'apposito set.

int      num;                 /* Specifies the systemcall's number from sysent */
uint64_t sysnum;              /* Specifies the number of elements in pr_set array */
uint64_t syssize;             /* Allocates the size */
sysset_t *set;                /* Specifies the pointer to sysset_t */
sysnum = (num - 1)/64 + 1;
syssize = (sysnum + 1) * sizeof(uint64_t);
set = (sysset_t *)malloc(syssize);
set->pr_size = sysnum;
prfillsysset(set)          /* set all syscalls in the sysset */
premptysysset(set)         /* clear all syscalls in the sysset */
praddsysset(set, num)      /* set specified syscall in the sysset */
prdelsysset(set, num)      /* clear specified syscall in the sysset */
prissyssetmember(set, num) /* !=0 if specified syscall is set */

Consultare la descrizione del file sysent per ulteriori informazioni sulle chiamate di sistema.

Ogni processo attivo contiene almeno un thread del kernel. Ogni thread del kernel rappresenta un flusso di esecuzione che viene pianificato in modo indipendente dal sistema operativo. Tutti i thread del kernel in un processo condividono lo spazio di indirizzo così come molti altri attributi. Utilizzando i file ctl e lwpctl , è possibile manipolare i singoli thread del kernel in un processo o manipolarli tutti in una volta, a seconda dell'operazione.

Quando un processo ha più di un thread del kernel, un thread rappresentativo viene scelto dal sistema per determinate operazioni di file di stato e controllo. Il thread rappresentativo viene arrestato solo se tutti i thread del processo vengono fermati. Il thread rappresentativo può essere arrestato su un evento di interesse solo se tutti i thread vengono fermati, oppure può essere arrestato da un arresto PR_RICHIESTO solo se non esistono altri eventi di interesse.

Il thread rappresentativo rimane fisso finché tutti i thread vengono fermati su eventi di interesse o sono in PR_SOSPESO stop e l'operando PCRUN non viene applicato a nessuno di essi.

Quando applicato al file di controllo processi (ctl), ogni operazione di controllo /proc che interessa un thread del kernel utilizza lo stesso algoritmo per scegliere quale thread del kernel agire. Con arresto sincrono (vedi PCSET), questo comportamento consente ad un'applicazione di controllare un processo a più thread utilizzando solo lo stato del livello di processo e i file di controllo. Per maggiore controllo, utilizzare i file lwpctl specifici del thread.

Il file system /proc può essere utilizzato sia da 32 - bit che da 64 - bit processi di controllo per ottenere informazioni su entrambi i processi di destinazione 32 - bit e 64 - bit. I file /proc forniscono 64 - bit file invarianti di modalità abilitate a tutti gli osservatori. La modalità del processo di controllo non influiscono sul formato dei dati /proc . I dati vengono restituiti nello stesso formato a entrambi i processi di controllo 32 - bit e 64 - bit. Gli indirizzi e i campi di lunghezza e offset applicabili nei file /proc sono lunghi 8 bytes.

Struttura della directory

Al livello superiore, la directory /proc contiene voci, ognuna delle quali nomi un processo esistente nel sistema. I nomi delle voci presenti in questa directory sono numeri di processo ID (pid). Queste voci sono directory. Salvo diversa indicazione, i file descritti di seguito sono di sola lettura. Inoltre, se un processo diventa un zombie (uno che è stato terminato dal suo genitore con una chiamata uscita ma non è stato sospeso da una chiamata attesa ), la maggior parte dei file /proc associati scompaiono dalla struttura di directory. Normalmente, i tentativi successivi di aprire o di leggere o scrivere a file aperti prima che il processo venga terminato, susciti il messaggio ENOENT . Si notano eccezioni.

I file /proc contengono dati che presentano lo stato dei processi e dei thread nel sistema. Questo stato cambia costantemente mentre il sistema funziona. Per lessare il carico sulle prestazioni di sistema causate dalla lettura dei file /proc , il file system /proc non arresta l'attività di sistema durante la raccolta dei dati per quei file. Una sola lettura di un file /proc restituisce generalmente una rappresentazione coerente e abbastanza accurata dello stato di processo o thread. Tuttavia, poiché lo stato cambia man mano che si esegue il processo o il thread, più letture di file /proc possono restituire rappresentazioni che mostrano dati diversi e quindi sembrano essere incongruenti tra loro.

La struttura file /proc/pid

La directory /proc/pid contiene (ma non si limita a) le seguenti voci:

come

Contiene l'immagine dello spazio di indirizzo del processo. Il file come può essere aperto sia per la lettura che per la scrittura. La sottoroutine lseek viene utilizzata per posire il file all'indirizzo virtuale di interesse. Dopodichè è possibile visualizzare e modificare lo spazio di indirizzo con le sottoroutine leggi e scrivere , rispettivamente.

ctl

Un file di sola scrittura a cui vengono scritti messaggi strutturati indirizzando il sistema a cambiare qualche aspetto dello stato del processo o a controllare in qualche modo il suo comportamento. Lo scostamento della ricerca non è rilevante quando si scrive a questo file, consultare tipi di messaggi di controllo per ulteriori informazioni. I singoli thread hanno anche file lwpctl associati. Un messaggio di controllo può essere scritto sia al file ctl del processo o ad uno specifico file lwpctl con effetti specifici di funzionamento come descritto. L'effetto di un messaggio di controllo si riflette immediatamente nello stato del processo visibile attraverso appositi file di stato e informazioni.

stato

Contiene informazioni di stato sul processo e uno del suo thread rappresentativo. Il file viene formattato come tipo pstatus struct contenente i seguenti membri:

uint32_t pr_flag;                   /* process flags from proc struct p_flag */
uint32_t pr_flag2;                  /* process flags from proc struct p_flag2 */
uint32_t pr_flags;                  /* /proc flags */
uint32_t pr_nlwp;                   /* number of threads in the process */
char     pr_stat;                   /* process state from proc p_stat */
char     pr_dmodel;                 /* data model for the process */
char     pr__pad1[6];               /* reserved for future use */
pr_sigset_t pr_sigpend;             /* set of process pending signals */
prptr64_t pr_brkbase;               /* address of the process heap */
uint64_t pr_brksize;                /* size of the process heap, in bytes */
prptr64_t pr_stkbase;               /* address of the process stack */
uint64_t pr_stksize;                /* size of the process stack, in bytes */
pid64_t  pr_pid;                    /* process id */
pid64_t  pr_ppid;                   /* parent process id */
pid64_t  pr_pgid;                   /* process group id */
pid64_t  pr_sid;                    /* session id */
struct pr_timestruc64_t pr_utime;   /* process user cpu time */
struct pr_timestruc64_t pr_stime;   /* process system cpu time */
struct pr_timestruc64_t pr_cutime;  /* sum of children's user times */
struct pr_timestruc64_t pr_cstime;  /* sum of children's system times */
pr_sigset_t pr_sigtrace;            /* mask of traced signals */
fltset_t pr_flttrace;               /* mask of traced hardware faults */
uint32_t pr_sysentry_offset;        /* offset into pstatus file of sysset_t
                                     * identifying system calls traced on
                                     * entry.  If 0, then no entry syscalls
                                     * are being traced. */
uint32_t pr_sysexit_offset;         /* offset into pstatus file of sysset_t
                                     * identifying system calls traced on
                                     * exit.  If 0, then no exit syscalls
                                     * are being traced. */
uint64_t pr__pad[8];                /* reserved for future use */
lwpstatus_t pr_lwp;                 /* "representative" thread status */

I membri del file stato sono descritti di seguito:

pr_bandiere

Specifica un bit - mask che tiene queste bandiere:

PR_ISSYS

Il processo è un processo del kernel (vedi PCSTOP)

PR_FORK

Il processo ha la sua serie di bandiera a forcella (vedi PCSET)

PR_RLC

Il processo ha la sua serie di flag run - on - close (vedi PCSET)

PR_KLC

Processo ha la sua serie di flag kill - on - close (vedi PCSET)

PR_ASYNC

Il processo ha la sua serie di indicatori di arresto asincrono (vedi PCSET)

PR_PTRACE

Il processo è controllato dalla subroutine ptrace

pr_nlwp

Specifica il numero totale di thread nel processo

pr_brkbase

Specifica l'indirizzo virtuale dell'heap di processo

pr_brksize

Specifica la dimensione, in byte, dell'heap di processo

Nota: L'indirizzo formato dalla somma dei pr_brkbase e pr_brksize è il processo break (vedere la sottoroutine brk ).

pr_stkbase

Specifica l'indirizzo virtuale dello stack di processo

pr_stksize

Specifica la dimensione, in byte, dello stack di processo

Nota: Ogni thread viene eseguito su una pila separata. Il sistema operativo cresce lo stack di processo come necessario.

pr_pid

Specifica il processo ID

pr_ppid

Specifica il ID processo principale

pr_pgid

Specifica il gruppo di processo ID

pr_sid

Specifica l'ID di sessione del processo

pr_utime

Specifica il tempo di CPU utente consumato dal processo

pr_empo

Specifica il tempo di processo della CPU di sistema consumato dal processo

pr_cutime

Specifica il tempo di CPU utente cumulativo consumato dai bambini del processo, espresso in secondi e nanosecondi

pr_cstime

Specifica il tempo di CPU del sistema cumulativo, in secondi e nanosecondi, consumato dai bambini del processo

pr_sigtraccia

Specifica la serie di segnali che vengono tracciati (vedere il segnale PCSTRACE )

pr_flttrace

Specifica la serie di difetti hardware che vengono tracciati (vedere il segnale PCSFAULT )

pr_sysentry_offset

Se non zero, contiene offimpostate nel file stato alle serie sysset_t serie di chiamate di sistema tracciate sulla voce di sistema (vedere il segnale PCSENTRY ). Questo flag è zero se il tracciamento della chiamata di sistema non è attivo per il processo.

pr_sysexit_offset

Se non zero, contiene offimpostate nel file stato alle serie sysset_t delle chiamate di sistema tracciate sull'uscita di chiamata del sistema (vedere il segnale PCSEXIT ). Questo campo è zero se il tracciamento della chiamata di sistema non è attivo per il processo.

pr_lwp

Se il processo non è uno zombie, contiene una struttura lwpstatus_t che descrive un thread rappresentativo. Il contenuto di questa struttura ha lo stesso significato di se fosse letto da un file lwpstatus .

psinfo

Contiene informazioni sul processo necessario al comando ps . Se il processo contiene più di un thread, viene utilizzato un thread rappresentativo per ricavare le informazioni lwpsinfo . Il file viene formattato come tipo struct psinfo e contiene i seguenti membri:

uint32_t pr_flag;                   /* process flags from proc struct p_flag */
uint32_t pr_flag2;                  /* process flags from proc struct p_flag2 */
uint32_t pr_nlwp;                   /* number of threads in process */
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 */
uint32_t pr_argc;                   /* initial argument count */
pid64_t  pr_pid;                    /* unique process id */
pid64_t  pr_ppid;                   /* process id of parent */
pid64_t  pr_pgid;                   /* pid of process group leader */
pid64_t  pr_sid;                    /* session id */
dev64_t  pr_ttydev;                 /* controlling tty device */
prptr64_t   pr_addr;                /* internal address of proc struct */
uint64_t pr_size;                   /* size of process image in KB (1024) units */
uint64_t pr_rssize;                 /* resident set size in KB (1024) units */
struct   pr_timestruc64_t pr_start; /* process start time, time since epoch */
struct   pr_timestruc64_t pr_time;  /* usr+sys cpu time for this process */
prptr64_t   pr_argv;                /* address of initial argument vector in
                                       user process */
prptr64_t   pr_envp;                /* address of initial environment vector
                                       in user process */
char     pr_fname[PRFNSZ];          /* last component of exec()ed pathname*/
char     pr_psargs[PRARGSZ];        /* initial characters of arg list */
uint64_t pr__pad[8];                /* reserved for future use */
struct   lwpsinfo pr_lwp;           /* "representative" thread info */

Nota: Alcune delle voci presenti nel file psinfo , come pr_flag, pr_flag2e pr_addr, fanno riferimento alle strutture dati del kernel interno e potrebbero non conservare i loro significati in diverse versioni del sistema operativo. Non significano nulla per un programma e sono utili solo per l'interpretazione manuale da parte di un utente consapevole dei dettagli di implementazione.

Il file psinfo è accessibile dopo che un processo diventa uno zombie.

Il flag pr_lwp descrive il thread rappresentativo scelto. Se il processo è uno zombie, gli indicatori pr_nlwp e pr_lwp.pr_lwpid sono zero e gli altri campi di pr_lwp non sono definiti.

map

Contiene informazioni sulla mappa degli indirizzi virtuali del processo. Il file contiene una schiera di strutture prmap , ognuna delle quali descrive una regione di indirizzo virtuale contiguo nello spazio di indirizzo del processo tracciato.

Nota: Il file mappa potrebbe contenere voci solo per le regioni di indirizzo virtuale del processo che contengono gli oggetti caricati nel processo.

La struttura prmap contiene i seguenti membri:

uint64_t pr_size;                /* size of mapping in bytes */
prptr64_t pr_vaddr;              /* virtual address base */
char     pr_mapname[PRMAPSZ];    /* name in the /proc/pid/object object */
uint64_t pr_off;                 /* offset to the mapped object, if any */
uint32_t pr_mflags;              /* protection and attribute flags */
uint32_t pr_pathoff;             /* if map indicates the entry for a loaded object,
                                  * offset points to a null-terminated path name followed
                                  * by a null-terminated member name.
                                  * If the offset is mapped to a file and it is not an 
                                  * archive file, the member name is null.
                                  * The offset is 0 if map entry is
                                  * not applicable for a loaded object. */
int32_t pr_shmid;                /* shared memory ID for the MA_SHM or
                                  * MA_RTSHM region.
                                  * <0 indicates that teh shared memory ID is not 
                                  * available. */
dev64_t pr_dev;                  /* the dev_t data structure for the MA_FILEMAP file.
                                  * -1 indicates that the dev_t is not available 
                                  * -2 indicates that the file is on remote filesystem,
                                  * -3 indicates that the file is in a WPAR. */                                                                     
ino64_t pr_ino;                  /* The inode datastructure for the MA_FILEMAP file.
                                  * -1 indicates that the ino_t data structure is not 
                                  * available */
vmid64_t pr_vsid;                /* virtual segment ID for the first segment
                                  * in the region. */

I membri sono descritti di seguito:

pr_vaddr

Specifica l'indirizzo virtuale della mappatura all'interno del processo tracciato

pr_size

Specifica la dimensione della mappatura all'interno del processo tracciato

pr_mapname

Se non una stringa vuota, contiene il nome di un file che risiede nella directory oggetto e contiene un descrittore di file per l'oggetto a cui è mappato l'indirizzo virtuale. Il file viene aperto con la sottoroutine aperto .

pr_off

Contiene lo scostamento all'interno dell'oggetto mappato (se presente) a cui è mappato l'indirizzo virtuale

pr_pathoff

Se non zero, contiene uno scostamento nel file mappa al nome del percorso e nome membro dell'archivio di un oggetto caricato

pr_mbandiere

Specifica un bit - maschera di protezione e le seguenti bandiere di attributi:

MA_MAINEXEC

Indica che la mappatura si applica all'eseguibile principale nel processo.

MA_BREAK

Indica che la mappatura si applica ai dati del programma e gli intervalli di memoria nell'elaborazione.

MA_STACK

Indica che la mappatura si applica alla gamma di stack nel processo.

MA_MMAP

Indica che la mappatura si applica a un oggetto mappato al processo utilizzando la sottoroutine mmap .

MA_RTSHM

• Indica che la mappatura si applica a POSIX oggetti in tempo reale creati dalla subroutine shm_open .
• Questi oggetti vengono associati al processo utilizzando la sottoroutine mmap .

MA_SHM

Indica che la mappatura si applica a un oggetto mappato al processo utilizzando la sottoroutine shmat .

MA_FILEMAP

Indica che la mappatura si applica a un oggetto file mappato al processo utilizzando la sottoroutine mmap o la sottoroutine shmat .

MA_LAVORO

Indica che la mappatura si applica alla memoria che viene mappata al processo dal caricatore o da un altro sottosistema del kernel.

MA_RMMAP

Indica che la mappatura si applica a una regione di memoria o I/O mappata nel processo utilizzando la sottoroutine rmmap_create .

MA_KERNTEXT

Indica che la mappatura si applica alla memoria del kernel mappata al processo.

MA_PS4K

Indica che la mappatura è supportata da 4 KB blocchi di memoria fisica.

MA_PS64K

Indica che la mappatura è supportata da 64 KB blocchi di memoria fisica.

MA_PS16M

Indica che la mappatura è supportata da 16 MB blocchi di memoria fisica.

MA_PS16G

Indica che la mappatura è supportata da 16 GB blocchi di memoria fisica.

MA_READ

Indica che la mappatura è leggibile dal processo tracciato.

MA_WRITE

Indica che la mappatura è scrivibile dal processo tracciato.

MA_EXEC

Indica che la mappatura è eseguibile dal processo tracciato.

MA_CONDIVISO

Indica che le modifiche di mappatura sono condivise dall'oggetto mappato.

pr_shmid

Per la mappatura MA_SHM, contiene l'ID di memoria condivisa System V della mappatura. Utilizzare il comando ipcs -m per visualizzare gli ID di memoria condivisa.

pr_dev

Per la mappatura MA_FILEMAP, contiene il numero ID del dispositivo mappato.

pr_ino

Per la mappatura MA_FILEMAP, contiene il numero inode del file mappato relativo all'ID periferica nel campo pr_dev .

pr_vsid

Contiene il primo ID del segmento Virtual Memory Manager nella mappatura.

Un'area contigua dello spazio di indirizzo avente lo stesso oggetto mappato sottostante può apparire come più mappature a causa di varia lettura, scrittura, esecuzione e attributi condivisi. L'oggetto mappato sottostante non cambia nell'intervallo di una singola mappatura. Un'operazione I/O su una mappatura contrassegnata MA_CONDIVISO fallisce se applicata ad un indirizzo virtuale non corrispondente ad una pagina valida nell'oggetto mappato sottostante. Le operazioni di lettura e scrittura a mappature private riescono sempre. Le operazioni di lettura e scrittura su indirizzi non mappati fallisce sempre.

cred

Contiene una descrizione delle credenziali associate al processo. Il file viene formattato come tipo struct prcred e contiene i seguenti membri:

uid_t    pr_euid;                /* effective user id */
uid_t    pr_ruid;                /* real user id */
uid_t    pr_suid;                /* saved user id (from exec) */
gid_t    pr_egid;                /* effective group id */
gid_t    pr_rgid;                /* real group id */
gid_t    pr_sgid;                /* saved group id (from exec) */
uint32_t pr_ngroups;             /* number of supplementary groups */
gid_t    pr_groups[1];           /* array of supplementary groups */

sysent

Contiene informazioni relative alle chiamate di sistema disponibili al processo. Il file può essere utilizzato per trovare il numero di una specifica chiamata di sistema da tracciare. Può essere utilizzato per trovare il nome di una chiamata di sistema associata ad un numero di chiamata di sistema restituito in un file lwpstatus .

Il file consiste in una sezione di intestazione seguita da una schiera di voci, ognuna delle quali corrisponde ad una chiamata di sistema fornita al processo. Ogni voce schiera contiene il numero di chiamata di sistema e uno scostamento nel file sysent a quel nome nullo della chiamata di sistema.

Il file sysent è caratterizzato dai seguenti attributi:

• I nomi delle chiamate di sistema sono il vero nome del kernel della chiamata di sistema esportata.
• Le voci nella schiera non hanno alcun ordinamento specifico.
• Ci possono essere lacune nei numeri di chiamata del sistema.
• Diversi processi possono avere diversi nomi e numeri di chiamate di sistema, soprattutto tra un processo 32 - bit e un processo del 64 - bit. Non supporre che gli stessi nomi o numeri attraversi diversi processi.
• La serie di chiamate di sistema possono cambiare durante mentre il sistema operativo è in esecuzione. È possibile aggiungere chiamate di sistema mentre il sistema operativo è in esecuzione.
• I nomi e i numeri delle chiamate di sistema possono cambiare all'interno di diverse release o quando il servizio viene applicato al sistema.

cwd

Un link che fornisce l'accesso all'attuale directory di lavoro del processo. Qualsiasi processo può accedere alla directory di lavoro corrente del processo attraverso questo link, purché disponga delle autorizzazioni necessarie.

FD

Contiene file per tutti i descrittori di file aperti del processo. Ogni voce è un numero decimale corrispondente a un descrittore di file aperto nel processo. Se un enty si riferisce ad un file regolare, può essere aperto con la normale semantica del file. Per garantire che il processo di contolling non possa ottenere maggiore accesso, non ci sono modalità di accesso al file diverse dalle proprie modalità di apertura / scrittura nel processo controllato. Le directory verranno visualizzate come link. Un tentativo di apertura di qualsiasi altro tipo di ingresso avrà esito negativo (da qui verrà visualizzato 0 permesso quando elencato).

oggetto

Una directory contenente file di sola lettura con nomi come appaiono nelle voci del file mappa , corrispondenti agli oggetti mappati nello spazio di indirizzo del processo di destinazione. L'apertura di un tale file restituisce un descrittore per il file mappato associato a una determinata regione di indirizzo - spazio. Il nome a.out viene visualizzato nella directory come sinonimo del file eseguibile associato al testo del processo in esecuzione.

La directory degli oggetti permette di avere un processo di controllo per ottenere l'accesso al file oggetto e ad eventuali librerie condivise (e di conseguenza le tabelle dei simboli), senza che il processo ottenga per la prima volta i nomi di percorso specifici di quei file.

root

Un link che fornisce l'accesso alla directory principale corrente del processo. Qualsiasi processo può accedere alla directory principale corrente del processo attraverso questo link, a condizione che il processo (che sta tentando di accedere alla directory root) disponga delle autorizzazioni necessarie.

mmap

Un file che contiene una schiera di strutture stat64x . Ogni struttura descrive le informazioni su un file associato ad un'area mappata alla memoria di proprietà del processo.

lwp

Una directory contenente le voci ciascuna delle quali nominano un thread del kernel all'interno del processo contenente. I nomi delle voci presenti in questa directory sono numeri di thread ID (tid). Queste voci sono directory contenenti file aggiuntivi descritti di seguito.

La struttura /proc/pid/lwp/tid

La directory /proc/pid/lwp/tid contiene le seguenti voci:

lwpctl

Questo è un file di controllo di sola scrittura. I messaggi scritti in questo file riguardano solo il thread associato piuttosto che il processo nel suo insieme (se del caso).

stato lwp

Contiene informazioni di stato specifiche del thread. Queste informazioni sono presenti anche nel file stato del processo per il suo thread rappresentativo. Il file viene formattato come struct lwpstatus e contiene i seguenti membri:

uint64_t  pr_lwpid;                 /* specific thread id */
uint32_t pr_flags;                  /* thread status flags */
char     pr_state;                  /* thread state - from thread.h t_state */
uint16_t pr_cursig;                 /* current signal */
uint16_t pr_why;                    /* reason for stop (if stopped) */
uint16_t pr_what;                   /* more detailed reason */
uint32_t pr_policy;                 /* scheduling policy */
char     pr_clname[PRCLSZ];         /* printable character representing pr_policy */
pr_sigset_t pr_lwppend;             /* set of signals pending to the thread */
pr_sigset_t pr_lwphold;             /* set of signals blocked by the thread */
pr_siginfo64_t pr_info;             /* info associated with signal or fault */
pr_stack64_t pr_altstack;           /* alternate signal stack info */
struct pr_sigaction64 pr_action;    /* signal action for current signal */
uint16_t pr_syscall;                /* system call number (if in syscall) */
uint16_t pr_nsysarg;                /* number of arguments to this syscall */
uint64_t pr_sysarg[PRSYSARGS];      /* arguments to this syscall */
prgregset_t pr_reg;                 /* general and special registers */
prfpregset_t pr_fpreg;              /* floating point registers */
pfamily_t pr_family;                /* hardware platform specific information */

I membri del file lwpstatus sono descritti di seguito:

pr_bandiere

Specifica un bit - mask che tiene queste bandiere:

PR_ARRESTATO

Indica che il thread viene arrestato

PR_ISTOP

Indica che il thread viene arrestato su un evento di interesse (vedere il segnale PCSTOP )

PR_DSTOP

Indica che il thread ha una direttiva di arresto in vigore (vedere il segnale PCSTOP )

PR_ADDORMENTATO

Il thread è in un sonno interrompibile all'interno di una chiamata di sistema

PR_NOREGS

Non è stato fornito alcun stato di registrazione per il thread

pr_perché e pr_cosa

Fornisce il motivo per cui un thread è stato arrestato. Di seguito sono riportati i valori possibili del membro pr_perché :

PR_RICHIESTO

Mostra che il thread è stato arrestato in risposta ad una direttiva di arresto, normalmente perché il segnale PCSTOP è stato applicato o perché un altro thread arrestato su un evento di interesse e il flag di arresto asincrono (vedere il segnale PCSET ) non è stato impostato per il processo. Il membro pr_cosa è inutilizzato in questo caso.

PR_SEGNALATO

Mostra che il thread si è fermato alla ricezione di un segnale (vedere il segnale PCSTRACE ). Il segnale pr_cosa detiene il numero di segnale che ha causato la fermata (per un thread appena arrestato, lo stesso valore viene dato con il membro pr_cursig ).

PR_FAULTED

Mostra che il thread si è fermato a incorrere in un guasto hardware (vedere il segnale PCSFAULT). Il membro pr_cosa contiene il numero di colpa che ha causato la fermata.

PR_SYSENTRY

Mostra una fermata all'ingresso in una chiamata di sistema (vedere il segnale PCSENTRY ). Il membro pr_cosa contiene il numero di chiamata del sistema.

PR_SYSEXIT

Mostra una fermata all'uscita da una chiamata di sistema (vedere il segnale PCSEXIT ). Il pr_cosa contiene il numero di chiamata del sistema.

PR_CONTROLLO_LAVORO

Mostra che il thread si è arrestato a causa dell'azione predefinita di un segnale di arresto del controllo del lavoro (vedere la sottoroutine sigazione ). Il membro pr_cosa contiene il numero di segnale di arresto.

pr_lwpid

Nomina il thread specifico I/O

pr_cursig

Nomi il segnale corrente, ovvero il segnale successivo da consegnare al thread. Quando il thread viene arrestato dal segnale PR_SEGNALATO o PR_FAULTED , il membro pr_info contiene ulteriori informazioni utili al particolare segnale o guasto. La quantità di dati contenuti nel membro pr_info dipende dal tipo di arresto e se su non l'applicazione ha specificato il flag SA_SIGINFO quando è stato stabilito il gestore del segnale. Per PR_FAULTED stop e PR_SEGNALATO si arresta quando non è stato specificato il flag SA_SIGINFO , solo i campi si_signo, si_code e si_addr pr_info contengono dati. Per PR_SEGNALATO stop quando viene specificato il flag SA_SIGINFO , gli altri campi pr_info contengono anche i dati.

pr_azione

Contiene le informazioni di azione del segnale relative al segnale corrente. Questo membro è indefinito se il membro pr_cursig è zero. Consultare la sottoroutine sigazione .

pr_lwppend

Identifica eventuali segnali generati in modo sincrono o thread in sospeso per il thread. Non include segnali in sospeso a livello di processo.

pr_altstack

Contiene le informazioni di stack del segnale alternativo per il thread. Consultare la sottoroutine sigaltstack .

pr_syscall

Specifica il numero della chiamata di sistema, se presente, che viene eseguita dal thread. Si tratta di non zero se e solo se il thread viene arrestato su PR_SYSENTRY o PR_SYSEXIT.

Se il membro pr_syscall è non zero, il membro pr_nsysarg è il numero di argomenti alla chiamata di sistema e l'array pr_sysarg contiene gli argomenti. Il membro pr_nsysarg è sempre impostato su 8, il numero massimo di parametri di chiamata di sistema. Il membro pr_sysarg contiene sempre otto argomenti.

pr_clname

Contiene il nome della classe di pianificazione del thread

pr_reg

Struttura contenente i fili generali e registri speciali. Le dimensioni e i nomi di campo di questa struttura dipendono dalla macchina. Consultare il file di intestazione <sys/m_procfs.h> per la descrizione di questa struttura per la macchina specifica. I contenuti di questa struttura sono indefiniti se il thread non viene arrestato.

pr_fpreg

Struttura contenente i registri dei punti galleggianti. Le dimensioni e i nomi di campo di questa struttura dipendono dalla macchina. I contenuti di questa struttura sono indefiniti se il thread non viene arrestato.

pr_famiglia

Contiene le informazioni specifiche della macchina sul filo. L'utilizzo di questo campo non è portatile su architetture diverse. La struttura pr_family contiene campi offset di contesto esteso e campi di dimensioni, che, se non zero, indicano la disponibilità di informazioni di contesto macchina estesa per il thread. Una successiva lettura del file stato o lwpstatus allo scostamento e dimensione specificato richiamerà le informazioni di contesto esteso corrispondenti ad una struttura prextset . In alternativa, l'intero file lwpstatus può essere letto e formattato come struct lwpstatusx, che include l'estensione prextset . L'offset del contesto esteso pr_family e i membri delle dimensioni, se non zero, indicano se il membro prextset della struttura lwpstatusx è valido.

lwpsinfo

Contiene informazioni sul thread necessario al comando ps . Queste informazioni sono presenti anche nel file psinfo del processo per il suo thread rappresentativo se ne ha uno. Il file viene formattato come tipo struct lwpsinfo contenente i seguenti membri:

uint64_t  pr_lwpid;              /* thread id */
prptr64_t pr_addr;               /* internal address of thread */
prptr64_t pr_wchan;              /* wait addr for sleeping thread */
uint32_t pr_flag;                /* thread flags */
uchar_t  pr_wtype;               /* type of thread wait */
uchar_t  pr_state;               /* numeric scheduling state */
char     pr_sname;               /* printable character representing pr_state */
uchar_t  pr_nice;                /* nice for cpu usage */
int      pr_pri;                 /* priority, high value = high priority*/
uint32_t pr_policy;              /* scheduling policy */
char     pr_clname[PRCLSZ];      /* printable character representing pr_policy */
cpu_t    pr_onpro;               /* processor on which thread last ran */
cpu_t    pr_bindpro;             /* processor to which thread is bound */

Alcune delle voci presenti nel file lwpsinfo , come pr_flag, pr_addr, pr_stato, pr_wtypee pr_wchan, fanno riferimento a strutture di dati del kernel interno e non dovrebbero conservare i loro significati in diverse versioni del sistema operativo. Non hanno alcun significato per un programma e sono utili solo per l'interpretazione manuale da parte di un utente consapevole dei dettagli di implementazione.

Messaggi di controllo

Le modifiche dello stato di processo vengono effettuate tramite messaggi scritti nel file ctl del processo o al file lwpctl di un singolo thread. Tutti i messaggi di controllo sono costituiti da un codice di operazione int che identifica l'operazione specifica seguita da ulteriori dati contenenti operandi (se presenti). Più messaggi di controllo possono essere combinati in una sola sottoroutine scrivere ad un file di controllo, ma non sono consentite scritture parziali. Ogni messaggio di controllo (codice di funzionamento plus operandi) deve essere presentato nella sua interezza alla sottoroutine scrivere , non a pezzi attraverso diverse chiamate di sistema.

PCSTOP, PCDSTOP, PCWSTOP

Quando applicato al file di controllo del processo,

• PCSTOP indirizza tutti i thread per fermarsi e attende che si fermi;
• PCDSTOP indirizza tutti i thread a fermarsi senza aspettare che si fermi;
• PCWSTOP attende semplicemente che tutti i thread si arrestino.

Quando applicato ad un file di controllo del thread,

• PCSTOP indirizza il thread specifico per fermarsi e attende fino a quando non si è arrestato;
• PCDSTOP indirizza il thread specifico a fermarsi senza aspettare che si fermi;
• PCWSTOP attende semplicemente che il thread si fermi.

Quando applicato ad un file di controllo del thread, PCSTOP e PCWSTOP completano quando il thread si arresta su un evento di interesse e immediatamente se il thread è già arrestato.

Quando applicato al file di controllo dei processi, PCSTOP e PCWSTOP completano quando ogni thread si è fermato su un evento di interesse.

Un evento di interesse è uno stop PR_RICHIESTO o uno stop che è stato specificato nelle bandiere di tracciamento del processo (impostate da PCSTRACE, PCSFAULT, PCSENTRYe PCSEXIT). PR_JOBCONTROL e PR_SOSPESO le fermate non sono eventi di interesse. (Un thread può fermarsi due volte a causa di un segnale di arresto; mostrare per la prima volta PR_SEGNALATO se il segnale viene tracciato e di nuovo mostrando PR_JOBCONTROL se il thread è impostato in esecuzione senza cancellare il segnale.) Se PCSTOP o PCDSTOP viene applicato a un thread arrestato, ma non a causa di un evento di interesse, la direttiva stop prende effetto quando il thread viene riavviato dal meccanismo concorrente; in quel momento il thread entra in una PR_RICHIESTO stop prima di eseguire qualsiasi codice di livello utente.

Un'operazione scrivere di un messaggio di controllo che blocca è interrompibile da un segnale in modo che, ad esempio, una sottoroutine allarme possa essere impostata per evitare di attendere un processo o un thread che potrebbe non fermarsi mai su un evento di interesse. Se PCSTOP viene interrotto, le direttive di arresto del thread rimangono in vigore anche se la sottoroutine scrivere restituisce un errore.

Un processo del kernel (indicato dal flag PR_ISSYS ) non viene mai eseguito a livello di utente e non può essere arrestato. Non ha spazio di indirizzo di livello utente visibile attraverso il file system /proc . Applicando PCSTOP, PCDSTOPo PCWSTOP a un processo di sistema o a uno qualsiasi dei suoi thread susciti l'errore EBUSY.

PCRUN

Esegue nuovamente un thread dopo che è stato arrestato. L'operando è una serie di bandiere, contenute in un operando int , descrivendo azioni aggiuntive facoltative.

Le bandiere consentite per PCRUN sono descritte di seguito:

PRCSIG

Elimina il segnale corrente, se presente. Vedere PCSSIG.

PRCGUASTO

Elimina la colpa corrente, se presente. Vedere PCCFAULT.

PRSTEP

Indirizza il thread per eseguire un'istruzione singola macchina. A completamento dell'istruzione si verifica una trappola della traccia. Se FLTTRACE viene tracciato, il thread si arresta, altrimenti viene inviato SIGTRAP. Se SIGTRAP viene rintracciato e non congelato, il thread si arresta. Quando il thread si arresta su un evento di interesse la direttiva a passo singolo viene annullata, anche se la fermata si verifica prima dell'esecuzione dell'istruzione.

PRSABORT

Istruisce il thread per interrompere l'esecuzione della chiamata di sistema. Vedere PCSENTRY, e PCSEXIT. È significativo solo se il thread è in una fermata PR_SYSENTRY oppure è contrassegnato PR_ADDORMENTATO.

PRSTOP

Indirizza il thread a fermarsi il più presto possibile dopo l'esecuzione ripresa. Vedere PCSTOP. In particolare, se il thread viene arrestato su PR_SEGNALATO o PR_FAULTED, la fermata successiva mostra PR_RICHIESTO, nessun' altra fermata è intervenuta e il thread non esegue alcun codice di livello utente.

Quando applicato ad un file di controllo del thread, PCRUN rende il thread specifico runnable. L'operazione non riesce e restituisce l'errore EBUSY se il thread specifico non viene arrestato su un evento di interesse.

Quando applicato al file di controllo del processo, viene scelto un thread rappresentativo per l'operazione come descritto per il file /proc/pid/stato . L'operazione non riesce e restituisce l'errore EBUSY se il thread rappresentativo non viene arrestato su un evento di interesse. Se PRSTEP o PRSTOP sono stati richiesti, PCRUN rende il thread rappresentativo runnable. In caso contrario, il thread scelto è contrassegnato PR_RICHIESTO. Se come risultato tutti i thread sono nello stato di arresto PR_RICHIESTO , tutti diventano runnable.

Una volta PCRUN fa un thread runnable, non si ferma più su un evento di interesse, anche se rimane fermato a causa di un meccanismo concorrente.

PCSTRACE

Definisce una serie di segnali da tracciare nel processo. Al ricevimento di uno di questi segnali, il thread si arresta. La serie di segnali viene definita utilizzando un operando pr_sigset_t contenuto nel messaggio di controllo. La ricezione di SIGKILL non può essere tracciata. Se si specifica SIGKILL, il thread lo ignora.

Se un segnale incluso in un set di segnale tenuto da un thread viene inviato a quel thread, il segnale non viene ricevuto e non provoca una sosta fino a quando non viene rimosso dal set di segnale tenuto. O il thread stesso lo rimuove o lo si rimuove impostando il segnale tenuto impostato con PCSHOLD o l'opzione PRSHOLD di PCRUN.

PCSSIG

Specifica il segnale corrente e le relative informazioni di segnale associate per il thread specifico o il thread rappresentativo. Queste informazioni sono impostate in base alla struttura dell'operando pr_siginfo64 . Se il numero di segnale specificato è zero, il segnale corrente viene sdoganato. L'errore EBUSY viene restituito se il thread non viene arrestato su un evento di interesse.

La sintassi di questa operazione è diversa da quelle della sottoroutine uccidi , della sottoroutine pthread__kill o PCKILL. Con PCSSIG, il segnale viene consegnato al thread immediatamente dopo la ripresa dell'esecuzione (anche se il segnale si sta tenendo) e un'ulteriore PR_SEGNALATO stop non interviene anche se il segnale viene tracciato. Impostando il segnale corrente su SIGKILL termina immediatamente il processo.

PCKILL

Se applicato al file di controllo del processo, viene inviato un segnale al processo con la sintassi identica a quella della sottoroutine uccidi . Se applicato ad un file di controllo del thread, viene inviato un segnale al thread con sintassi identica a quella della sottoroutine pthread__kill . Il segnale è denominato in un operando int contenuto nel messaggio. L'invio di SIGKILL termina immediatamente il processo o il thread.

PCUNKILL

Specifica un segnale da rimuovere dal set di segnali in sospeso. Se applicato al file di controllo del processo, il segnale viene cancellato dai segnali in sospeso del processo. Se applicato ad un file di controllo del thread, il segnale viene cancellato dai segnali in sospeso del thread. Il segnale corrente (se presente) è inalterato. Il segnale viene denominato in un operando int nel messaggio di controllo. Un tentativo di cancellazione SIGKILL dei risultati nell'errore EINVAL.

PCSHOLD

Imposta la serie di segnali mantenuti per il thread specifico o rappresentativo in base alla struttura dell'operando sigset_t . I segnali mantenuti sono quelli la cui consegna viene ritardata se inviata al thread. SIGKILL o SIGSTOP non possono essere tenuti. Se specificato, vengono silenziosamente ignorati.

PCSFAULT

Definisce una serie di difetti hardware da tracciare nel processo. Quando incorrere uno di questi difetti, un filo si arresta. Il set è definito tramite la struttura dell'operando fltset_t . I nomi di errore sono definiti nel file <sys/procfs.h> e includono quanto segue:

Nota: Alcune di queste possono non verificarsi su tutti i processori; altri difetti specifici del processore possono esistere oltre a quelli descritti qui.

FLSINO

Istruzione non valida

FLTPRIV

Istruzione privilegiata

FLTBPT

Trappola del punto di rottura

FLTTRACE

Trappola della traccia

FLTACCESS

Errore di accesso alla memoria (errore bus)

FLTBOUNDS

Violazione dei limiti di memoria

FLTIOVF

Overflow intero

FLTIZDIV

Divario zero intero

FLTFPE

Eccezione a virgola mobile

FLTSTACK

Faglia stack non recuperabile

Quando non viene rintracciato, un guasto comporta normalmente il distacco di un segnale al filo che ha sostenuto la colpa. Se un thread si arresta su un guasto, il segnale viene inviato al thread quando l'esecuzione viene ripresa a meno che non venga sdoganato da PCCFAULT o dall'opzione PRCGUASTO di PCRUN. The pr_info field in /proc/pid/stato or in /proc/pid/lwp/tid/lwpstatus identifies the signal to be sent and contains machine-specific information about the fault.

PCCFAULT

Specifica la colpa corrente, se presente, da sdoganare. Il segnale associato non viene inviato al thread specificato o al thread rappresentativo.

PCSENTRY

Istruisce i thread del processo per fermarsi all'ingresso alle chiamate di sistema specificate. La serie di chiamate di sistema da tracciare è definita tramite una struttura sysset_t operando. Quando si fa risalire la voce ad una chiamata di sistema, un thread si arresta dopo aver iniziato la chiamata al sistema ma prima che gli argomenti di chiamata del sistema siano stati caricati dal thread.

Se un thread viene arrestato all'entrata in una chiamata di sistema (PR_SYSENTRY) o quando si dorme in una chiamata di sistema interrompibile (PR_ADDORMENTATO è impostato), può essere istruito ad andare direttamente all'uscita della chiamata di sistema specificando il flag PRSABORT in un messaggio di controllo PCRUN . A meno che non venga tracciata l'uscita dalla chiamata di sistema, il thread ritorna al livello utente che mostra l'errore EINTR.

PCSEXIT

Istruisce i thread del processo per fermarsi all'uscita dalle chiamate di sistema specificate. La serie di chiamate di sistema da tracciare è definita tramite una struttura sysset_t operando. Quando si esegue l'uscita da una chiamata di sistema, un thread si arresta al completamento della chiamata di sistema poco prima del controllo dei segnali e tornando al livello dell'utente. A questo punto tutti i valori di ritorno sono stati memorizzati nei registri dei thread.

PCSET, PCRESET, PCUNSET

PCSET imposta una o più modalità di funzionamento per il processo tracciato. PCRESET o PCUNSET reimposta queste modalità. Le modalità da impostare o reimpostare vengono specificate dalle bandiere in un operando int nel messaggio di controllo:

PR_FORK (eredità - on - fork)

Quando impostato, le bandiere di tracciamento del processo vengono ereditate dal bambino di una sottoroutine forcella o vfork . Quando il reset, i processi child iniziano con tutte le indicatori di tracciamento sdoganate

PR_RLC (run - on - last - close)

Quando impostato e l'ultimo descrittore di file /proc scrivibile riferendosi al processo di tracciamento o a qualsiasi suo thread è chiuso, tutte le bandiere di tracciamento del processo vengono sdoganate, le eventuali direttive di arresto in sospeso vengono annullate e se eventuali thread vengono fermati su eventi di interesse, sono impostati come se PCRUN fosse stato applicato ad essi. Quando viene reimpostato, le bandiere di tracciamento del processo vengono conservate e i thread non sono impostati in esecuzione su ultimo chiusura.

PR_KLC (kill - on - last - close)

Quando impostato e l'ultimo descrittore di file /proc scrivibile che si riferisce al processo tracciato o a uno dei suoi thread è chiuso, il processo viene esitato con SIGKILL.

PR_ASYNC (arresto asincrono)

Quando impostato, una fermata su un evento di interesse da un solo thread non interessa direttamente altri thread del processo. Quando il reset e un thread si arresta su un evento di interesse diverso da PR_RICHIESTO, tutti gli altri thread del processo sono diretti a fermarsi.

L'errore EINVAL viene restituito se si specificano bandiere diverse da quelle sopra descritte o per applicare queste operazioni ad un processo di sistema. Le modalità correnti sono riportate nel campo pr_bandiere del file /proc/pid/stato .

PCSREG

Imposta i registri generali e speciali per il thread specifico o rappresentativo in base alla struttura dell'operando prgregset_t . Ci possono essere limitazioni specifiche della macchina sul set di modifiche consentito. PCSREG fallisce e restituisce l'errore EBUSY se il thread non viene arrestato su un evento di interesse o viene arrestato nel kernel.

PCSFPREG

Imposta i registri di virgola mobile per il thread specifico o rappresentativo in base alla struttura dell'operando fpregset_t . L'errore EINVAL viene restituito se il sistema non supporta le operazioni a virgola mobile (nessun hardware a virgola mobile e il sistema non emula le istruzioni della macchina a virgola mobile). PCSFPREG fallisce e restituisce l'errore EBUSY se il thread non viene arrestato su un evento di interesse o viene arrestato nel kernel.

PCSVREG

Imposta i registri vettoriali per il thread specifico o rappresentativo in base alla struttura dell'operando prvregset_t . L'errore EINVAL viene restituito se il sistema non supporta le operazioni vettrici (nessun hardware vettoriale e il sistema non emula le istruzioni macchina vettoriali) o se il thread rappresentativo non ha fatto riferimento all'unità vettoriale. PCSVREG fallisce e restituisce l'errore EBUSY se il thread non viene arrestato su un evento di interesse o viene arrestato nel kernel.

PCNICE

La priorità bello del processo di tracciamento viene incrementata dall'importo contenuto nell'operando int. Solo il superutente può meglio una priorità di un processo in questo modo, ma qualsiasi utente potrebbe peggiorare la priorità. Questa operazione è significativa solo quando applicata ad un processo nella classe di pianificazione del time-sharing.

File

Codici di errore

Altri errori possono verificarsi in aggiunta agli errori normalmente associati all'accesso al file system:

Sicurezza

L'effetto di un messaggio di controllo è garantito per essere atomico rispetto al processo tracciato.

Per motivi di sicurezza, tranne che per l'utente privilegiato, una sottoroutine aperto di un file /proc non riesce a meno che sia l'ID utente effettivo che l'ID del gruppo effettivo del chiamante corrispondono a quelli del processo tracciato e il file oggetto del processo è leggibile dal chiamante. I file corrispondenti ai processi setuid e setgid possono essere aperti solo dall'utente privilegiato. Anche se posseduta dall'utente privilegiato, un descrittore di file aperti o thread diventa non valido se il processo tracciato esegue una sottoroutine exec su un file oggetto setuid / setgid o su un file oggetto che non può leggere. Qualsiasi operazione eseguita su un descrittore di file non valido, tranne che per la sottoroutine chiudi , fallisce con EBADF. In questo caso, se sono impostati gli eventuali indicatori di tracciamento e il processo o qualsiasi file di thread è aperto per la scrittura, il processo è diretto a fermarsi e il suo indicatore di esecuzione - on - close è impostato (vedi PCSET).

Questa funzione consente una procedura di controllo (che ha il permesso necessario) di riaprire il file di processo per ottenere nuovi descrittori di file validi, chiudere i descrittori di file non validi e procedere. Basta chiudere i descrittori di file non validi causa il processo di tracciamento per riprendere l'esecuzione senza bandiere di traccia impostate. Qualsiasi processo che non sia attualmente aperto per la scrittura con gli indicatori di tracciamento lasciati da una precedente sottoroutine aperto e che esegue una sottoroutine exec su un file oggetto setuid / setgid o non leggibile non viene arrestato. Tuttavia, tale processo non ha tutte le sue bandiere di tracciamento sdoganate.