Errno потокобезопасный?

В errno.h, эта переменная объявлена ​​так, extern int errno;поэтому мой вопрос: безопасно ли проверять errnoзначение после некоторых вызовов или использовать perror () в многопоточном коде. Это потокобезопасная переменная? Если нет, то какая альтернатива?

Я использую Linux с GCC на архитектуре x86.

Да, это потокобезопасно. В Linux глобальная переменная errno зависит от потока. POSIX требует, чтобы errno был безопасен для потоков.

См. Http://www.unix.org/whitepapers/reentrant.html.

В POSIX.1 errno определяется как внешняя глобальная переменная. Но это определение неприемлемо в многопоточной среде, потому что его использование может привести к недетерминированным результатам. Проблема состоит в том, что два или более потоков могут столкнуться с ошибками, и все они вызывают одинаковые ошибки. При таких обстоятельствах поток может закончить проверку errno после того, как он уже был обновлен другим потоком.

Чтобы обойти результирующий недетерминизм, POSIX.1c переопределяет errno как сервис, который может получить доступ к номеру ошибки для каждого потока следующим образом (ISO / IEC 9945: 1-1996, §2.4):

Некоторые функции могут предоставлять номер ошибки в переменной, доступ к которой осуществляется через символ errno. Символ errno определяется путем включения заголовка, как указано в стандарте C ... Для каждого потока процесса на значение errno не должны влиять вызовы функций или назначения errno другими потоками.

Также см. Http://linux.die.net/man/3/errno

errno является локальным для потока; установка его в одном потоке не влияет на его значение в любом другом потоке.

да

Errno больше не простая переменная, это нечто сложное за кулисами, специально для того, чтобы оно было поточно-ориентированным.

Смотрите $ 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.

Мы можем перепроверить:

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

В errno.h эта переменная объявлена ​​как extern int errno;

Вот что говорит стандарт C:

Макрос errnoне обязательно должен быть идентификатором объекта. Он может расширяться до модифицируемого lvalue, получаемого в результате вызова функции (например, *errno()).

Обычно errnoэто макрос, который вызывает функцию, возвращающую адрес номера ошибки для текущего потока, а затем разыменовывает его.

Вот что у меня есть в Linux, в /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

В конце концов, он генерирует такой код:

> 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

Во многих системах Unix компиляция с -D_REENTRANTгарантирует, что errnoэто потокобезопасно.

Например:

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

Это из <sys/errno.h>моего Mac:

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

Так errnoчто теперь функция __error(). Функция реализована так, чтобы быть поточно-ориентированной.

да , как объясняется на странице руководства errno и в других ответах, errno является локальной переменной потока.

Однако есть глупая деталь, о которой можно легко забыть. Программы должны сохранять и восстанавливать ошибки в любом обработчике сигналов, выполняющем системный вызов. Это связано с тем, что сигнал будет обрабатываться одним из потоков процесса, который может перезаписать его значение.

Поэтому обработчики сигналов должны сохранять и восстанавливать ошибки. Что-то вроде:

void sig_alarm(int signo)
{
 int errno_save;

 errno_save = errno;

 //whatever with a system call

 errno = errno_save;
}

Я думаю, что ответ "это зависит". Поточно-ориентированные библиотеки времени выполнения C обычно реализуют errno как вызов функции (расширение макроса до функции), если вы создаете многопоточный код с правильными флагами.

Мы можем проверить, запустив простую программу на машине.

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

Запуск этой программы, и вы можете увидеть разные адреса для errno в каждом потоке. Вывод пробега на моей машине выглядел так:

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 

Обратите внимание, что адрес отличается для всех потоков.