Unix网络编程补充：eventfd和timerfd

#include <sys/eventfd.h>

// 成功返回eventfd描述符， 出错返回-1
int eventfd(unsigned int initval, int flags);

#include <sys/eventfd.h>

typedef uint64_t eventfd_t;

/* 成功返回调用传递的数据量，出错返回-1 */

int eventfd_read(int fd, eventfd_t *value);

int eventfd_write(int fd, eventfd_t value);

#include <sys/eventfd.h>
#include <unistd.h>
#include <inttypes.h>  // definition of PRIu64 & PRIx64
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>  // definition of uint64_t

#define handle_error(msg) \
  do { \
    perror(msg); \
    exit(EXIT_FAILURE); \
  } while (0)

int main(int argc, char **argv) {
  int efd;
  uint64_t u;

  if (argc < 2) {
    fprintf(stderr, "Usage: %s <num>...\n", argv[0]);
    exit(EXIT_FAILURE);
  }

  if ((efd = eventfd(0, 0)) == -1)
    handle_error("eventfd");

  switch (fork()) {
  case 0:
    for (int j = 1; j < argc; j++) {
      printf("Child writing %s to efd\n", argv[j]);
      u = strtoull(argv[j], NULL, 0);
      if(write(efd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
        handle_error("write");
    }
    printf("Child completed write loop\n");
    exit(EXIT_SUCCESS);

  default:
    sleep(2);

    printf("Parent about to read\n");
    if (read(efd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
      handle_error("read");
    printf("Parent read %" PRIu64 " (%#" PRIx64 ") from efd\n", u, u);
    exit(EXIT_SUCCESS);

  case -1:
    handle_error("fork");
  }
}

#include <sys/timerfd.h>

// 成功返回timer描述符，出错返回-1
int timerfd_create(int clockid, int flags);

#include <sys/timerfd.h>

/* 成功返回0，出错返回-1 */

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

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

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

#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
#include <inttypes.h>  // definition of PRIu64
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>  // definition of uint64_t

#define handle_error(msg) \
  do { \
    perror(msg); \
    exit(EXIT_FAILURE); \
  } while(0)

static void print_elapsed_time() {
  static struct timespec start;
  struct timespec curr;
  static int first_call = 1;
  int secs, nsecs;

  if (first_call) {
    first_call = 0;
    if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
      handle_error("clock_gettime");
  }

  if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1)
    handle_error("clock_gettime");

  secs = curr.tv_set - start.tv_sec;
  nsecs = curr.tv_nsec - start.tv_nsec;
  if (nsecs < 0) {
    secs--;
    nsecs += 1000000000;
  }
  printf("%d.%03d: ", secs, (nsecs + 500000) / 1000000);
}

int main(int argc, char **argv) {
  struct itimerspec new_value;
  int max_exp, fd;
  struct timespec now;
  uint64_t exp, tot_exp;

  if ((argc != 2) && (argc != 4)) {
    fprintf(stderr, "%s init-secs [interval-secs max-exp]\n", argv[0]);
    exit(EXIT_FAILURE);
  }

  if (clock_gettime(CLOCK_REALTIME, &now) == -1)
    handle_error("clock_gettime");

  /* Create a CLOCK_REALTIME absolute timer with initial
     expiration and interval as specified in command line. */
  new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
  new_value.it_value.tv_nsec = now.tv_nsec;
  if (argc == 2) {
    new_value.it_interval.tv_sec = 0;
    max_exp = 1;
  } else {
    new_value.it_interval.tv_sec = atoi(argv[2]);
    max_exp = atoi(argv[3]);
  }
  new_value.it_interval.tv_nsec = 0;

  if ((fd = timerfd_create(CLOCK_REALTIME, 0)) == -1)
    handle_error("timerfd_create");

  if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
    handle_error("timerfd_settime");

  print_elapsed_time();
  printf("timer started\n");

  for (tot_exp = 0; tot_exp < max_exp; ) {
    if (read(fd, &exp, sizeof(uint64_t)) != sizeof(uint64_t))
      handle_error("read");

    tot_exp += exp;
    print_elapsed_time();
    printf("read: %" PRIu64 "; total=%" PRIu64 "\n", exp, tot_exp);
  }

  exit(EXIT_SUCCESS);
}