O errno thread-safe?

Em errno.h, essa variável é declarada como extern int errno;minha pergunta é: é seguro verificar o errnovalor após algumas chamadas ou usar perror () no código multiencadeado. Essa é uma variável segura de thread? Se não, então qual é a alternativa?

Estou usando o linux com gcc na arquitetura x86.

Sim, é seguro para threads. No Linux, a variável global errno é específica do segmento. O POSIX exige que o erro não seja seguro.

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

No POSIX.1, errno é definido como uma variável global externa. Mas essa definição é inaceitável em um ambiente multithread, porque seu uso pode resultar em resultados não determinísticos. O problema é que dois ou mais encadeamentos podem encontrar erros, todos causando o mesmo erro. Nessas circunstâncias, um encadeamento pode acabar verificando errno depois de já ter sido atualizado por outro encadeamento.

Para contornar o não determinismo resultante, o POSIX.1c redefine errno como um serviço que pode acessar o número de erro por thread da seguinte maneira (ISO / IEC 9945: 1-1996, §2.4):

Algumas funções podem fornecer o número do erro em uma variável acessada através do símbolo errno. O símbolo errno é definido pela inclusão do cabeçalho, conforme especificado pelo Padrão C ... Para cada encadeamento de um processo, o valor de errno não deve ser afetado por chamadas ou atribuições de função a errno por outros encadeamentos.

Veja também http://linux.die.net/man/3/errno

errno é thread-local; defini-lo em um thread não afeta seu valor em nenhum outro thread.

sim

Errno não é mais uma variável simples, é algo complexo nos bastidores, especificamente para ser seguro para threads.

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

Podemos verificar:

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

Em errno.h, essa variável é declarada como extern int errno;

Aqui está o que o padrão C diz:

A macro errnonão precisa ser o identificador de um objeto. Pode expandir para um valor l modificável resultante de uma chamada de função (por exemplo, *errno()).

Geralmente, errnoé uma macro que chama uma função retornando o endereço do número do erro para o encadeamento atual e o desreferencia.

Aqui está o que eu tenho no Linux, em /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

No final, ele gera esse tipo de código:

> 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

Em muitos sistemas Unix, a compilação com -D_REENTRANTgarante errnosegurança de thread.

Por exemplo:

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

Isto é do <sys/errno.h>meu Mac:

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

Então errnoagora é uma função __error(). A função é implementada de modo a ser segura para threads.

sim , como é explicado na página do manual errno e nas outras respostas, errno é uma variável local do encadeamento.

No entanto , há um detalhe bobo que pode ser facilmente esquecido. Os programas devem salvar e restaurar o erro em qualquer manipulador de sinal que esteja executando uma chamada do sistema. Isso ocorre porque o sinal será tratado por um dos threads do processo que pode sobrescrever seu valor.

Portanto, os manipuladores de sinal devem salvar e restaurar o erro. Algo como:

void sig_alarm(int signo)
{
 int errno_save;

 errno_save = errno;

 //whatever with a system call

 errno = errno_save;
}

Eu acho que a resposta é "depende". As bibliotecas de tempo de execução C seguras para threads geralmente implementam errno como uma chamada de função (macro expandida para uma função) se você estiver criando código encadeado com os sinalizadores corretos.

Podemos verificar executando um programa simples em uma máquina.

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

Executando este programa e você pode ver endereços diferentes para errno em cada thread. A saída de uma execução na minha máquina parecia: -

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 

Observe que o endereço é diferente para todos os segmentos.