Là chủ đề errno an toàn?

Trong đó errno.h, biến này được khai báo vì extern int errno;vậy câu hỏi của tôi là, có an toàn không khi kiểm tra errnogiá trị sau một số cuộc gọi hoặc sử dụng perror () trong mã đa luồng. Đây có phải là một biến an toàn chủ đề? Nếu không, thì cái gì thay thế?

Tôi đang sử dụng linux với gcc trên kiến ​​trúc x86.

Vâng, nó là chủ đề an toàn. Trên Linux, biến errno toàn cầu là đặc trưng của luồng. POSIX yêu cầu errno là chủ đề an toàn.

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

Trong POSIX.1, errno được định nghĩa là biến toàn cục bên ngoài. Nhưng định nghĩa này là không thể chấp nhận được trong một môi trường đa luồng, bởi vì việc sử dụng nó có thể dẫn đến kết quả không xác định. Vấn đề là hai hoặc nhiều luồng có thể gặp lỗi, tất cả gây ra lỗi tương tự được đặt. Trong những trường hợp này, một luồng có thể sẽ kiểm tra errno sau khi nó đã được cập nhật bởi một luồng khác.

Để tránh sự không xác định kết quả, POSIX.1c xác định lại errno là một dịch vụ có thể truy cập vào số lỗi trên mỗi luồng như sau (ISO / IEC 9945: 1-1996, §2.4):

Một số hàm có thể cung cấp số lỗi trong một biến được truy cập thông qua biểu tượng errno. Ký hiệu errno được xác định bằng cách bao gồm tiêu đề, như được chỉ định bởi Tiêu chuẩn C ... Đối với mỗi luồng của một quy trình, giá trị của errno sẽ không bị ảnh hưởng bởi các lệnh gọi hàm hoặc gán cho errno bởi các luồng khác.

Xem thêm http://linux.die.net/man/3/errno

errno là chủ đề cục bộ; thiết lập nó trong một luồng không ảnh hưởng đến giá trị của nó trong bất kỳ luồng nào khác.

Đúng

Errno không phải là một biến đơn giản nữa, đó là một thứ phức tạp đằng sau hậu trường, đặc biệt là nó an toàn cho chủ đề.

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

Chúng tôi có thể kiểm tra lại:

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

Trong errno.h, biến này được khai báo là extern int errno;

Đây là những gì tiêu chuẩn C nói:

Macro errnokhông cần phải là định danh của một đối tượng. Nó có thể mở rộng thành một giá trị có thể sửa đổi do một lệnh gọi hàm (ví dụ *errno():).

Nói chung, errnolà một macro gọi một hàm trả về địa chỉ của số lỗi cho luồng hiện tại, sau đó hủy bỏ nó.

Đây là những gì tôi có trên Linux, trong /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

Cuối cùng, nó tạo ra loại mã này:

> 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

Trên nhiều hệ thống Unix, biên dịch với -D_REENTRANTđảm bảo errnoan toàn cho luồng.

Ví dụ:

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

Đây là từ <sys/errno.h>trên máy Mac của tôi:

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

Vì vậy, errnobây giờ là một chức năng __error(). Các chức năng được thực hiện để an toàn chủ đề.

vâng , như được giải thích trong trang man errno và các phản hồi khác, errno là một biến cục bộ của luồng.

Tuy nhiên , có một chi tiết ngớ ngẩn có thể dễ dàng bị lãng quên. Các chương trình nên lưu và khôi phục lỗi trên bất kỳ trình xử lý tín hiệu nào thực hiện cuộc gọi hệ thống. Điều này là do tín hiệu sẽ được xử lý bởi một trong các luồng xử lý có thể ghi đè lên giá trị của nó.

Do đó, các trình xử lý tín hiệu nên lưu và khôi phục errno. Cái gì đó như:

void sig_alarm(int signo)
{
 int errno_save;

 errno_save = errno;

 //whatever with a system call

 errno = errno_save;
}

Tôi nghĩ câu trả lời là "nó phụ thuộc". Các thư viện thời gian chạy C an toàn cho luồng thường triển khai errno dưới dạng gọi hàm (macro mở rộng thành hàm) nếu bạn đang xây dựng mã luồng với các cờ chính xác.

Chúng ta có thể kiểm tra bằng cách chạy một chương trình đơn giản trên máy.

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

Chạy chương trình này và bạn có thể thấy các địa chỉ khác nhau cho errno trong mỗi luồng. Đầu ra của một lần chạy trên máy của tôi trông giống như: -

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 

Lưu ý rằng địa chỉ là khác nhau cho tất cả các chủ đề.