Errno è thread-safe?

In errno.h, questa variabile è dichiarata extern int errno;così com'è la mia domanda, è sicuro controllare il errnovalore dopo alcune chiamate o usare perror () nel codice multi-thread. È una variabile thread-safe? In caso contrario, qual è l'alternativa?

Sto usando Linux con gcc su architettura x86.

Sì, è thread-safe. Su Linux, la variabile errno globale è specifica del thread. POSIX richiede che errno sia thread-safe.

Vedi http://www.unix.org/whitepapers/reentrant.html

In POSIX.1, errno è definito come una variabile globale esterna. Ma questa definizione è inaccettabile in un ambiente multithread, poiché il suo utilizzo può portare a risultati non deterministici. Il problema è che due o più thread possono riscontrare errori, provocando tutti lo stesso errno da impostare. In queste circostanze, un thread potrebbe finire per controllare errno dopo che è già stato aggiornato da un altro thread.

Per aggirare il non determinismo risultante, POSIX.1c ridefinisce errno come servizio che può accedere al numero di errore per thread come segue (ISO / IEC 9945: 1-1996, §2.4):

Alcune funzioni possono fornire il numero di errore in una variabile accessibile tramite il simbolo errno. Il simbolo errno è definito includendo l'intestazione, come specificato dalla norma C ... Per ogni thread di un processo, il valore di errno non deve essere influenzato dalle chiamate di funzione o dalle assegnazioni a errno da parte di altri thread.

Vedi anche http://linux.die.net/man/3/errno

errno è thread-local; l'impostazione in un thread non influisce sul suo valore in nessun altro thread.

sì

Errno non è più una semplice variabile, è qualcosa di complesso dietro le quinte, in particolare per essere thread-safe.

Vedi $ man 3 errno:

ERRNO(3)                   Linux Programmer’s Manual                  ERRNO(3)

NAME
       errno - number of last error

SYNOPSIS
       #include <errno.h>

DESCRIPTION

      ...
       errno is defined by the ISO C standard to be  a  modifiable  lvalue  of
       type  int,  and  must not be explicitly declared; errno may be a macro.
       errno is thread-local; setting it in one thread  does  not  affect  its
       value in any other thread.

Possiamo ricontrollare:

$ cat > test.c
#include <errno.h>
f() { g(errno); }
$ cc -E test.c | grep ^f
f() { g((*__errno_location ())); }
$ 

In errno.h, questa variabile è dichiarata come extern int errno;

Ecco cosa dice lo standard C:

La macro errnonon deve necessariamente essere l'identificatore di un oggetto. Potrebbe espandersi in un valore modificabile derivante da una chiamata di funzione (ad esempio, *errno()).

In genere, errnoè una macro che chiama una funzione che restituisce l'indirizzo del numero di errore per il thread corrente, quindi lo dereferenzia.

Ecco cosa ho su Linux, in /usr/include/bits/errno.h:

/* Function to get address of global `errno' variable.  */
extern int *__errno_location (void) __THROW __attribute__ ((__const__));

#  if !defined _LIBC || defined _LIBC_REENTRANT
/* When using threads, errno is a per-thread value.  */
#   define errno (*__errno_location ())
#  endif

Alla fine, genera questo tipo di codice:

> cat essai.c
#include <errno.h>

int
main(void)
{
    errno = 0;

    return 0;
}
> gcc -c -Wall -Wextra -pedantic essai.c
> objdump -d -M intel essai.o

essai.o:     file format elf32-i386


Disassembly of section .text:

00000000 <main>:
   0: 55                    push   ebp
   1: 89 e5                 mov    ebp,esp
   3: 83 e4 f0              and    esp,0xfffffff0
   6: e8 fc ff ff ff        call   7 <main+0x7>  ; get address of errno in EAX
   b: c7 00 00 00 00 00     mov    DWORD PTR [eax],0x0  ; store 0 in errno
  11: b8 00 00 00 00        mov    eax,0x0
  16: 89 ec                 mov    esp,ebp
  18: 5d                    pop    ebp
  19: c3                    ret

Su molti sistemi Unix, la compilazione con -D_REENTRANTassicura che errnosia thread-safe.

Per esempio:

#if defined(_REENTRANT) || _POSIX_C_SOURCE - 0 >= 199506L
extern int *___errno();
#define errno (*(___errno()))
#else
extern int errno;
/* ANSI C++ requires that errno be a macro */
#if __cplusplus >= 199711L
#define errno errno
#endif
#endif  /* defined(_REENTRANT) */

Questo è dal <sys/errno.h>mio Mac:

#include <sys/cdefs.h>
__BEGIN_DECLS
extern int * __error(void);
#define errno (*__error())
__END_DECLS

Quindi errnoora è una funzione __error(). La funzione è implementata in modo da essere thread-safe.

sì , come spiegato nella pagina man di errno e nelle altre risposte, errno è una variabile locale di thread.

Tuttavia , c'è un dettaglio stupido che potrebbe essere facilmente dimenticato. I programmi dovrebbero salvare e ripristinare l'errno su qualsiasi gestore di segnale che esegue una chiamata di sistema. Questo perché il segnale verrà gestito da uno dei thread di processo che potrebbe sovrascriverne il valore.

Pertanto, i gestori di segnale dovrebbero salvare e ripristinare errno. Qualcosa di simile a:

void sig_alarm(int signo)
{
 int errno_save;

 errno_save = errno;

 //whatever with a system call

 errno = errno_save;
}

Penso che la risposta sia "dipende". Le librerie di runtime C thread-safe di solito implementano errno come una chiamata di funzione (macro che si espande in una funzione) se stai costruendo un codice thread con i flag corretti.

Possiamo verificare eseguendo un semplice programma su una macchina.

#include <stdio.h>                                                                                                                                             
#include <pthread.h>                                                                                                                                           
#include <errno.h>                                                                                                                                             
#define NTHREADS 5                                                                                                                                             
void *thread_function(void *);                                                                                                                                 

int                                                                                                                                                            
main()                                                                                                                                                         
{                                                                                                                                                              
   pthread_t thread_id[NTHREADS];                                                                                                                              
   int i, j;                                                                                                                                                   

   for(i=0; i < NTHREADS; i++)                                                                                                                                 
   {
      pthread_create( &thread_id[i], NULL, thread_function, NULL );                                                                                            
   }                                                                                                                                                           

   for(j=0; j < NTHREADS; j++)                                                                                                                                 
   {                                                                                                                                                           
      pthread_join( thread_id[j], NULL);                                                                                                                       
   }                                                                                                                                                           
   return 0;                                                                                                                                                   
}                                                                                                                                                              

void *thread_function(void *dummyPtr)                                                                                                                          
{                                                                                                                                                              
   printf("Thread number %ld addr(errno):%p\n", pthread_self(), &errno);                                                                                       
}

Eseguendo questo programma e puoi vedere diversi indirizzi per errno in ogni thread. L'output di una corsa sulla mia macchina sembrava: -

Thread number 140672336922368 addr(errno):0x7ff0d4ac0698                                                                                                       
Thread number 140672345315072 addr(errno):0x7ff0d52c1698                                                                                                       
Thread number 140672328529664 addr(errno):0x7ff0d42bf698                                                                                                       
Thread number 140672320136960 addr(errno):0x7ff0d3abe698                                                                                                       
Thread number 140672311744256 addr(errno):0x7ff0d32bd698 

Si noti che l'indirizzo è diverso per tutti i thread.