Czy wątek errno jest bezpieczny?

W errno.h, ta zmienna jest zadeklarowana jako, extern int errno;więc moje pytanie brzmi, czy bezpiecznie jest sprawdzić errnowartość po niektórych wywołaniach lub użyć perror () w kodzie wielowątkowym. Czy to zmienna bezpieczna dla wątków? Jeśli nie, to jaka jest alternatywa?

Używam Linuksa z GCC na architekturze x86.

Tak, jest bezpieczny dla wątków. W systemie Linux globalna zmienna errno jest specyficzna dla wątku. POSIX wymaga, aby errno było bezpieczne dla wątków.

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

W POSIX.1 errno jest zdefiniowane jako zewnętrzna zmienna globalna. Jednak definicja ta jest nie do przyjęcia w środowisku wielowątkowym, ponieważ jej użycie może skutkować niedeterministycznymi wynikami. Problem polega na tym, że dwa lub więcej wątków może napotkać błędy, które powodują ustawienie tego samego errno. W takich okolicznościach wątek może zakończyć sprawdzanie errno po tym, jak został już zaktualizowany przez inny wątek.

Aby obejść wynikowy niedeterminizm, POSIX.1c przedefiniowuje errno jako usługę, która może uzyskać dostęp do numeru błędu dla każdego wątku w następujący sposób (ISO / IEC 9945: 1-1996, §2.4):

Niektóre funkcje mogą podawać numer błędu w zmiennej, do której można uzyskać dostęp poprzez symbol errno. Symbol errno jest definiowany przez dołączenie nagłówka, zgodnie ze standardem C… Dla każdego wątku procesu, wywołania funkcji lub przypisania do errno przez inne wątki nie będą miały wpływu na wartość errno.

Zobacz także http://linux.die.net/man/3/errno

errno jest lokalnym wątkiem; ustawienie go w jednym wątku nie wpływa na jego wartość w żadnym innym wątku.

tak

Errno nie jest już prostą zmienną, jest czymś złożonym za kulisami, szczególnie w celu zapewnienia bezpieczeństwa wątków.

Zobacz $ 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.

Możemy dwukrotnie sprawdzić:

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

W errno.h ta zmienna jest zadeklarowana jako extern int errno;

Oto, co mówi standard C:

Makro errnonie musi być identyfikatorem obiektu. Może się rozwinąć do modyfikowalnej lwartości wynikającej z wywołania funkcji (na przykład *errno()).

Ogólnie errnojest to makro, które wywołuje funkcję zwracającą adres numeru błędu dla bieżącego wątku, a następnie wyłuskuje go.

Oto co mam w Linuksie, w /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

W końcu generuje taki kod:

> 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

W wielu systemach uniksowych kompilowanie z -D_REENTRANTzapewnia, że errnojest to bezpieczne wątkowo.

Na przykład:

#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) */

To jest z <sys/errno.h>mojego Maca:

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

Więc errnojest teraz funkcją __error(). Funkcja jest zaimplementowana tak, aby była bezpieczna dla wątków.

tak , jak jest to wyjaśnione na stronie podręcznika errno i w innych odpowiedziach, errno jest lokalną zmienną wątku.

jednak , nie jest głupi szczegół, który mógłby być łatwo zapomnieć. Programy powinny zapisywać i odtwarzać errno w każdym programie obsługi sygnału wykonującym wywołanie systemowe. Dzieje się tak, ponieważ sygnał będzie obsługiwany przez jeden z wątków procesu, który mógłby nadpisać jego wartość.

Dlatego programy obsługi sygnału powinny zapisywać i odtwarzać errno. Coś jak:

void sig_alarm(int signo)
{
 int errno_save;

 errno_save = errno;

 //whatever with a system call

 errno = errno_save;
}

Myślę, że odpowiedź brzmi „to zależy”. Biblioteki środowiska uruchomieniowego C z ochroną wątków zwykle implementują errno jako wywołanie funkcji (makro rozwijające się do funkcji), jeśli tworzysz kod z wątkami z odpowiednimi flagami.

Możemy to sprawdzić, uruchamiając prosty program na maszynie.

#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);                                                                                       
}

Uruchomienie tego programu i możesz zobaczyć różne adresy dla errno w każdym wątku. Wynik uruchomienia na moim komputerze wyglądał następująco: -

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 

Zauważ, że adres jest inny dla wszystkich wątków.