Come posso determinare il valore massimo di un pid_t?

Question

Come posso determinare in modo visibile il valore massimo del tipo pid_t? Non c'è una costante PID_MAX sul mio sistema.

(Nota, mi riferisco al valore massimo consentito dal tipo di dati, non il de facto valore massimo il sistema assegnerà ai processi.)

Caso d'uso: Sto conversione di un dall'utente fornito la specifica di stringa di un pid a pid_t e si desidera assicurarsi che l'input dell'utente non superi la capacità del tipo.

Answer 1

POSIX (2008) says:

tipi interi

blksize_t, pid_t e ssize_t devono essere firmate.

E:

L'attuazione sostiene uno o più ambienti di programmazione in cui le larghezze di blksize_t, pid_t, size_t, ssize_t e suseconds_t sono non maggiore della larghezza di tipo lungo.

Così si potrebbe convertire le stringhe degli utenti per long e quindi verificare la presenza di troppo pieno per il tipo pid_t utilizzando long pid; .. pid == (pid_t)pid.

Answer 2

In una delle intestazioni:

#ifndef PID_MAX 
#define PID_MAX INT_MAX // or whatever value you see fit 
#endif 

si può anche fare in base a Server/OS definizione dipendente sulla base di variabili di ambiente.

sguardo: Similar post : Maximum PID in Linux

Answer 3

Quello che ho fatto a volte in passato viene utilizzato un tipo di dati più grande, e poi quando si converte al mio tipo più piccolo, immediatamente riconvertire il tipo più grande e verificare che il valore non è cambiato

Ad esempio, dire che utilizzato un int64_t invece, allora si potrebbe avere qualcosa di simile:

int64_t my_pid64; 

/* ... parse string value into my_pid64 ... */ 

pid_t my_pid = (pid_t) my_pid64; 
if ((int64_t) my_pid != my_pid64) /* check that value was not out of range of pid_t */ 
{ 
    /* ... handle error ... */ 
} 

Non c'è grande opzione per il tipo di dati più grande per usare. "long" era il più grande tipo di dati intero primitivo, ma non è più vero su alcuni comuni compilatori/architetture - anche per Linux (vedere i commenti sotto). Nel frattempo, il tipo intmax_t ha un supporto di libreria scadente. Il risultato è che int64_t a volte è più utile nella pratica.

Ma, fondamentalmente le opzioni per un tipo di dati più grande sono probabilmente lunghe, int64_t e intmax_t.

Answer 4

La risposta di Steven è un buon approccio.

Ma se si vuole veramente per determinare il valore massimo pid_t senza fare affidamento su un comportamento indefinito, penso che la cosa migliore è:

#include <sys/types.h> 
#include <limits.h> 
#include <stdlib.h> 

static inline pid_t get_max_pid_t() 
{ 
    if (sizeof(pid_t) == sizeof(short)) return SHRT_MAX; 
    if (sizeof(pid_t) == sizeof(int)) return INT_MAX; 
    if (sizeof(pid_t) == sizeof(long)) return LONG_MAX; 
#if defined(LLONG_MAX) // C99 
    if (sizeof(pid_t) == sizeof(long long)) return LLONG_MAX; 
#endif 
    abort(); 
} 

garanzie POSIX che pid_t è un tipo integrale firmato. Questo codice presuppone che la dimensione di un tipo integrale firmato determini univocamente quel tipo.Penso che questo sia un presupposto eccellente, ma non sono sicuro che lo standard lo garantisca.

Qualsiasi compilatore decente sarà in linea e in costante propagazione di tutto questo in non esistenza, quindi le prestazioni non sono un problema.

(a parte: In C++ si scrive std::numeric_limits<pid_t>::max() e da fare con esso.)