Use of new Linux APIs signalfd, timerfd, and eventfd

Use of new Linux APIs signalfd, timerfd, and eventfd
Use of new Linux APIs signalfd, timerfd, and eventfd

Three new versions of fd added to Linux kernel:

Signalfd: 2.6.22

Timerfd: 2.6.25

Eventfd: 2.6.22

Three fd meanings:

Lsignalfd

The traditional method of signal processing is to register a signal processing function. Because the signal occurs asynchronously, it is necessary to solve the problem of Concurrent Data Access and re-import. Signalfd can abstract the signal into a file descriptor and read it when a signal occurs. In this way, the signal monitoring can be placed in the select, poll, epoll, and other listening queues.

Ltimerfd

The timer function can be implemented. The timer is abstracted as a file descriptor. When the timer expires, it can be read, which can also be placed in the main loop of the listener queue.

Leventfd

Event Notification between threads can also be used for user-mode and kernel communication. The buffer size of eventfd is sizeof (uint64_t). You can increment the value of this counter by writing to it. The read operation can be read and cleared. The eventfd can also be placed in the listening queue. When the counter is not 0, A readable event can be read.

All three new fd types can be monitored. When an event is triggered, a readable event occurs.

Signalfd involves APIs:

 
 

  
  
#include  
 
  
  
int signalfd(int fd, const sigset_t *mask, int flags);
 
 

Parameter fd: if it is-1, it indicates creating a new one. If it is an existing one, it indicates modifying the signal associated with signalfd;

Parameter mask: Signal Set;

Parameter flag: the kernel version 2.6.27 and later support SFD_NONBLOCK and SFD_CLOEXEC;

The file descriptor is returned successfully. The returned fd supports the following operations: read, select (poll, epoll), close

L example

 
 

  
  
 #include  
 
  
  
 #include  
 
  
  
#include  
 
  
  
 #include  
 
  
  
 #include  
 
  
  


  
  
 #define handle_error(msg) \ 

  
  
do { perror(msg); exit(EXIT_FAILURE); } while (0) 

  
  


  
  
int main(int argc, char *argv[]) 

  
  
{ 

  
  
 sigset_t mask; 

  
  
 int sfd; 

  
  
 struct signalfd_siginfo fdsi; 

  
  
 ssize_t s; 

  
  


  
  
 sigemptyset(&mask); 

  
  
 sigaddset(&mask, SIGINT); 

  
  
 sigaddset(&mask, SIGQUIT); 

  
  


  
  
 if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) 

  
  
 handle_error("sigprocmask"); 

  
  


  
  
 sfd = signalfd(-1, &mask, 0); 

  
  
 if (sfd == -1) 

  
  
 handle_error("signalfd"); 

  
  


  
  
 for (;;) { 

  
  
 s = read(sfd, &fdsi, sizeof(struct signalfd_siginfo)); 

  
  
 if (s != sizeof(struct signalfd_siginfo)) 

  
  
 handle_error("read"); 

  
  


  
  
 if (fdsi.ssi_signo == SIGINT) { 

  
  
 printf("Got SIGINT\n"); 

  
  
 } else if (fdsi.ssi_signo == SIGQUIT) { 

  
  
 printf("Got SIGQUIT\n"); 

  
  
 exit(EXIT_SUCCESS); 

  
  
 } else { 

  
  
 printf("Read unexpected signal\n"); 

  
  
 } 

  
  
 } 

  
  
 }
 
 

L17-L21: Add signals of interest to sigset_t;

L24: Call signalfd to associate the signal set with fd. The first parameter-1 indicates creating a signalfd, not-1, and a valid signalfd indicates adding a new signal to it.

L29: blocks and reads the waiting signal. Based on the read result, you can know what signal has occurred.

Timerfd APIs

 
 

  
  
#include  
 
  
  
int timerfd_create(int clockid, int flags); 

  
  
int timerfd_settime(int fd, int flags, const struct itimerspec *new_value,struct itimerspec *old_value); 

  
  
int timerfd_gettime(int fd, struct itimerspec *curr_value);
 
 

Timerfd_create: Create a timerfd. The returned fd can be read, select (poll, epoll), close

Timerfd_settime: set the timer cycle and start Interval

Timerfd_gettime: Get the expiration time.

 
 

  
  
// The data structure in function parameters is as follows:
 
  
  
Struct timespec

  
  
{

  
  
Time_t TV _sec;/* Seconds */

  
  
Long TV _nsec;/* Nanoseconds */

  
  
};

  
  
Struct itimerspec

  
  
{

  
  
Struct timespec it_interval;/* Interval for periodic timer */

  
  
Struct timespec it_value;/* Initial expiration */

  
  
};
 
 

L example

1. # Include
   
2. # Include
   
3. # Include
   
4. # Include
   
5. # Include
   
6. # Include
   
7. # Include /* Definition of uint64_t */
   
8. 
   
9. # Define handle_error (msg )\
   
10. Do {perror (msg); exit (EXIT_FAILURE);} while (0)
    
11. 
    
12. Void printTime ()
    
13. {
    
14. Struct timeval TV;
    
15. Gettimeofday (& TV, NULL );
    
16. Printf ("printTime: current time: % ld. % ld", TV. TV _sec, TV. TV _usec );
    
17. }
    
18. 
    
19. Int main (int argc, char * argv [])
    
20. {
    
21. Struct timespec now;
    
22. If (clock_gettime (CLOCK_REALTIME, & now) =-1)
    
23. Handle_error ("clock_gettime ");
    
24. 
    
25. Struct itimerspec new_value;
    
26. New_value.it_value. TV _sec = now. TV _sec + atoi (argv [1]);
    
27. New_value.it_value. TV _nsec = now. TV _nsec;
    
28. New_value.it_interval. TV _sec = atoi (argv [2]);
    
29. New_value.it_interval. TV _nsec = 0;
    
30. 
    
31. Int fd = timerfd_create (CLOCK_REALTIME, 0 );
    
32. If (fd =-1)
    
33. Handle_error ("timerfd_create ");
    
34. 
    
35. If (timerfd_settime (fd, TFD_TIMER_ABSTIME, & new_value, NULL) =-1)
    
36. Handle_error ("timerfd_settime ");
    
37. 
    
38. PrintTime ();
    
39. Printf ("timer started \ n ");
    
40. 
    
41. For (uint64_t tot_exp = 0; tot_exp <atoi (argv [3]);)
    
42. {
    
43. Uint64_t exp;
    
44. Ssize_t s = read (fd, & exp, sizeof (uint64_t ));
    
45. If (s! = Sizeof (uint64_t ))
    
46. Handle_error ("read ");
    
47. 
    
48. Tot_exp + = exp;
    
49. PrintTime ();
    
50. Printf ("read: % llu; total = % llu \ n", exp, tot_exp );
    
51. }
    
52. 
    
53. Exit (EXIT_SUCCESS );
    
54. }

Code L25-L29: Initialize the timer parameter, the initial interval and timing interval.

L32: Create a timer fd, CLOCK_REALTIME: Real Time type. Modifying the clock will affect the timer; CLOCK_MONOTONIC: relative time type. Modifying the clock will not affect the timer.

L35: set the timer value.

L44: blocking and waiting for the timer to expire. The returned value is the number of unprocessed expiration times. For example, if the scheduled interval is 2 seconds but the read takes 10 seconds, the read value is 5.

Compile and run: The rt Library (g ++-lrt timerfd. cc-o timerfd) must be added during compilation)

[Root @ localhost appTest] #./timerfd 5 2 10
PrintTime: current time: 1357391736.146196 timer started
PrintTime: current time: 1357391741.153430 read: 1; total = 1
PrintTime: current time: 1357391743.146550 read: 1; total = 2
PrintTime: current time: 1357391745.151483 read: 1; total = 3
PrintTime: current time: 1357391747.161155 read: 1; total = 4
PrintTime: current time: 1357391749.153934 read: 1; total = 5
PrintTime: current time: 1357391751.157309 read: 1; total = 6
PrintTime: current time: 1357391753.158384 read: 1; total = 7
PrintTime: current time: 1357391755.150470 read: 1; total = 8
PrintTime: current time: 1357391757.150253 read: 1; total = 9
PrintTime: current time: 1357391759.149954 read: 1; total = 10
[Root @ localhost appTest] #

The first parameter 5 is the first timer expiration interval, the second parameter 2 is the timer interval, and the third parameter is the timer expiration 10 times, then exit. The program runs (5 + 2*10) S and exits.

For details, refer to man timerfd_create.

Eventfd involves APIs:

 
 

  
  
#include  
 
  
  
int eventfd(unsigned int initval, int flags);
 
 

Create an eventfd, which is a counter-related fd. If the counter is not zero, a readable event occurs. After reading, the counter is cleared and the write counter is incremented. The returned fd can be operated as follows: read, write, select (poll, epoll), close.

This function creates an event object to implement the wait/notify mechanism between processes (threads. the kernel will maintain a 64-bit counter (uint64_t) for this object ). And use the first parameter (initval) to initialize the counter. When this function is called, a new file descriptor (event object) is returned ). Starting from 2.6.27, you can set the second parameter (flags) by bit ). You can use the following macros:

LEFD_NONBLOCK

The function is the same as O_NONBLOCK of open (2). The object is set to non-blocking. If this status is not set, read (2) read eventfd, when the counter value is 0, it is always blocked in the read call. If this flag is set, an EAGAIN error (errno = EAGAIN) is returned ). The effect is similar to the effect achieved by calling select (2.

LEFD_CLOEXEC

If this identifier is set, the file descriptor is automatically closed after exec is called to prevent leakage. For kernel 2.6.26 or earlier versions, flags must be set to 0.
After creating this object, you can perform the following operations on it:

1) write: add the 8-byte integer value written by the buffer to the kernel counter.

2) read: read the 8-byte value and reset the counter to 0. if the counter is 0 when read is called, if eventfd is blocked, read will always be blocked here; otherwise, an EAGAIN error will be returned. If the buffer length is less than 8, the read operation fails and the error code is set to EINVAL.

3) poll select epoll

4) close: You can call close when eventfd is not required. When all the handles of this object are closed, the kernel releases resources. Why is it released directly if it is not close? If you call fork to create
The process will copy the handle to the new process and inherit all States.

L example

 
 

  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#define handle_error(msg) \

  
  
do { perror(msg); exit(1); } while (0)

  
  
int main( int argc, char **argv ){

  
  
uint64_t u;

  
  
ssize_t s;5 int j;

  
  
if ( argc < 2 ) {

  
  
fprintf(stderr, "input in command argument");

  
  
exit(1);

  
  
}

  
  


  
  
int efd;

  
  
if ( (efd = eventfd(0, EFD_NONBLOCK)) == -1 )

  
  
handle_error("eventfd failed");

  
  


  
  


  
  
switch (fork()) {

  
  
case 0:

  
  
for( j = 1; j < argc; j ++ ) {

  
  
printf("Child writing %s to efd\n", argv[j] );

  
  


  
  
u = strtoull(argv[j], NULL, 0); /* analogesly atoi */

  
  
s = write(efd, &u, sizeof(uint64_t));/*append u to counter */

  
  
if ( s != sizeof(uint64_t) )

  
  
handle_error("write efd failed");

  
  


  
  
}

  
  
printf("child completed write loop\n");

  
  


  
  
exit(0);

  
  
default:

  
  
sleep (2);

  
  


  
  
printf("parent about to read\n");

  
  
s = read(efd, &u, sizeof(uint64_t));

  
  
if ( s != sizeof(uint64_t) ) {

  
  
if (errno = EAGAIN) {

  
  
printf("Parent read value %d\n", s);

  
  
return 1;

  
  
}

  
  
handle_error("parent read failed");

  
  
}

  
  
printf("parent read %d , %llu (0x%llx) from efd\n",

  
  
s, (unsigned long long)u, (unsigned long long) u);

  
  
exit(0);

  
  


  
  
case -1:

  
  
handle_error("fork ");

  
  
}

  
  
return 0;

  
  
}