Apakah errno aman?

Dalam errno.h, variabel ini dinyatakan sebagai extern int errno;pertanyaan saya, apakah aman untuk memeriksa errnonilai setelah beberapa panggilan atau menggunakan perror () dalam kode multi-utas. Apakah ini variabel thread aman? Jika tidak, lalu apa alternatifnya?

Saya menggunakan linux dengan gcc pada arsitektur x86.

Ya, aman untuk thread. Di Linux, variabel errno global bersifat spesifik-utas. POSIX mengharuskan errno menjadi threadsafe.

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

Dalam POSIX.1, errno didefinisikan sebagai variabel global eksternal. Tetapi definisi ini tidak dapat diterima dalam lingkungan multithreaded, karena penggunaannya dapat menghasilkan hasil yang tidak ditentukan. Masalahnya adalah bahwa dua atau lebih utas dapat mengalami kesalahan, semua menyebabkan kesalahan yang sama diatur. Dalam keadaan ini, utas mungkin berakhir dengan memeriksa errno setelah utas tersebut diperbarui.

Untuk menghindari nondeterminisme yang dihasilkan, POSIX.1c mendefinisikan kembali errno sebagai layanan yang dapat mengakses nomor kesalahan per-utas sebagai berikut (ISO / IEC 9945: 1-1996, §2.4):

Beberapa fungsi dapat memberikan nomor kesalahan dalam variabel yang diakses melalui simbol errno. Simbol errno didefinisikan dengan memasukkan header, sebagaimana ditentukan oleh Standar C ... Untuk setiap utas proses, nilai errno tidak akan terpengaruh oleh pemanggilan fungsi atau penugasan untuk errno oleh utas lain.

Lihat juga http://linux.die.net/man/3/errno

errno adalah thread-local; mengaturnya di satu utas tidak memengaruhi nilainya di utas lainnya.

Iya

Errno bukan variabel sederhana lagi, itu sesuatu yang rumit di belakang layar, khusus untuk itu agar aman.

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

Kami dapat memeriksa ulang:

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

Di errno.h, variabel ini dideklarasikan sebagai extern int errno;

Inilah yang dikatakan standar C:

Makro errnotidak perlu menjadi pengidentifikasi objek. Mungkin diperluas ke nilai yang dapat dimodifikasi yang dihasilkan dari panggilan fungsi (misalnya, *errno()).

Secara umum, errnoadalah makro yang memanggil fungsi mengembalikan alamat nomor kesalahan untuk utas saat ini, lalu menyimpikannya.

Inilah yang saya miliki di Linux, di /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

Pada akhirnya, ini menghasilkan kode semacam ini:

> 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

Pada banyak sistem Unix, kompilasi dengan -D_REENTRANTmemastikan bahwa errnothread-safe.

Sebagai contoh:

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

Ini dari <sys/errno.h>pada Mac saya:

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

Jadi errnosekarang fungsi __error(). Fungsi ini diimplementasikan agar aman.

ya , seperti yang dijelaskan di halaman manual errno dan balasan lainnya, errno adalah variabel lokal thread.

Namun , ada detail konyol yang bisa dengan mudah dilupakan. Program harus menyimpan dan mengembalikan kesalahan pada penangan sinyal yang menjalankan panggilan sistem. Ini karena sinyal akan ditangani oleh salah satu utas proses yang dapat menimpa nilainya.

Oleh karena itu, penangan sinyal harus menyimpan dan mengembalikan errno. Sesuatu seperti:

void sig_alarm(int signo)
{
 int errno_save;

 errno_save = errno;

 //whatever with a system call

 errno = errno_save;
}

Saya pikir jawabannya adalah "itu tergantung". Pustaka runtime C aman-thread biasanya menerapkan errno sebagai panggilan fungsi (makro meluas ke suatu fungsi) jika Anda membuat kode berulir dengan flag yang benar.

Kita dapat memeriksa dengan menjalankan program sederhana pada mesin.

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

Menjalankan program ini dan Anda dapat melihat alamat yang berbeda untuk errno di setiap utas. Output dari pelarian pada mesin saya tampak seperti: -

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 

Perhatikan bahwa alamat berbeda untuk semua utas.