linux下定时器函数

/*
  2021.7.31 
man timer_create得到的，并不是原创
  CLOCK_MONOTONIC是monotonic time，而CLOCK_REALTIME是wall time。
  monotonic time字面意思是单调时间，实际上它指的是系统启动以后流逝的时间，这是由变量jiffies来记录的。
系统每次启动时jiffies初始化为0，每来一个timer interrupt，jiffies加1，也就是说它代表系统启动后流逝的tick数。
jiffies一定是单调递增的，因为时间不可逆！
  wall time字面意思是挂钟时间，实际上就是指的是现实的时间，这是由变量xtime来记录的。系统每次启动时将
CMOS上的RTC时间读入xtime，这个值是"自1970-01-01起经历的秒数、本秒中经历的纳秒数"，每来一个timer interrupt，
也需要去更新xtime。
  以前我一直想不明白，既然每个timer interrupt，jiffies和xtime都要更新，那么不都是单调递增的吗？
那它们之间使用时有什么区别呢？昨天看到一篇文章，终于明白了，wall time不一定是单调递增的。
因为wall time是指现实中的实际时间，如果系统要与网络中某个节点时间同步、或者由系统管理员觉得
这个wall time与现实时间不一致，有可能任意的改变这个wall time。最简单的例子是，我们用户
可以去任意修改系统时间，这个被修改的时间应该就是wall time，即xtime，它甚至可以被写入RTC而永久保存。
一些应用软件可能就是用到了这个wall time，比如以前用vmware workstation，一启动提示试用期已过，但是只要把
系统时间调整一下提前一年，再启动就不会有提示了，这很可能就是因为它启动时用gettimeofday去读wall time，然后
判断是否过期，只要将wall time改一下，就可以欺骗过去了。

  取得一个定时器的超限运行次数：
  有可能一个定时器到期了，而同一定时器上一次到期时产生的信号还处于挂起状态。
在这种情况下，其中的一个信号可能会丢失。这就是定时器超限。
程序可以通过调用timer_getoverrun来确定一个特定的定时器出现这种超限的次数。定时器超限
只能发生在同一个定时器产生的信号上。由多个定时器，甚至是那些使用相同的时钟和信号的定时器，所产生的
信号都会排队而不会丢失。

int timer_getoverrun(timer_t timerid);
执行成功时，timer_getoverrun()会返回定时器初次到期与通知进程(例如通过信号)定时器
已到期之间额外发生的定时器到期次数。举例来说，在我们之前的例子中，一个1ms的定时器运行了10ms，则此
调用会返回9。如果超限运行的次数等于或大于DELAYTIMER_MAX，则此调用会返回DELAYTIMER_MAX。

执行失败时，此函数会返回-1并将errno设定会EINVAL，这个唯一的错误情况代表timerid指定了无效的定时器。

 */
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <time.h>

#define CLOCKID CLOCK_REALTIME
#define SIG SIGRTMIN       ///kill -l 查看该值为34
///#define EXIT_FAILURE 1 
///
#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
} while (0)
static int end_flag; 

static void
print_siginfo(siginfo_t *si)
{
  timer_t *tidp;
  int or;

  tidp = si->si_value.sival_ptr;

  printf("sival_ptr = %p; ", si->si_value.sival_ptr);
  printf("*sival_ptr = 0x%lx\n", (long) *tidp);

  or = timer_getoverrun(*tidp);
  if (or == -1)
    errExit("timer_getoverrun");
  else
    printf("overrun count = %d\n", or);
}

static void
handler(int sig, siginfo_t *si, void *uc)
{
  /* Note: calling printf() from a signal handler is not
  strictly correct, since printf() is not async-signal-safe;
  see signal(7) */

  printf("Caught signal %d\n", sig);
  end_flag++; ///信号函数中，静态变量应该用互斥锁保护，但若添加了互斥锁后，该信号函数
  ///就是线程安全函数，也是不可重入函数。
  print_siginfo(si); ///参照上面的note，应该着重了解，可重入函数，线程安全函数，异步信号安全函数，不可重入函数。
  //signal(sig, SIG_IGN);///信号函数只执行一次
}



int
main(int argc, char *argv[])
{
  timer_t timerid;
  struct sigevent sev;
  struct itimerspec its;
  long long freq_nanosecs;
  sigset_t mask;
  struct sigaction sa;
  end_flag = 0;

  if (argc != 3) {
    fprintf(stderr, "Usage: %s <sleep-secs> <freq-nanosecs>\n",argv[0]);
    exit(EXIT_FAILURE);
  }

  /* Establish handler for timer signal */
  printf("Establishing handler for signal %d\n", SIG);
  sa.sa_flags = SA_SIGINFO;
  sa.sa_sigaction = handler;
  sigemptyset(&sa.sa_mask);
  
  if (sigaction(SIG, &sa, NULL) == -1)
    errExit("sigaction");

  /* Block timer signal temporarily */

  printf("Blocking signal %d\n", SIG);
  sigemptyset(&mask);
  sigaddset(&mask, SIG);/// 在信号处理函数执行期间屏蔽SIG信号，完毕后会抵达
     /* 注意sigprocmask中屏蔽的信号是一直不能抵达的，除非解除了阻塞*/
  if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1)
    errExit("sigprocmask");

  /* Create the timer */
  sev.sigev_notify = SIGEV_SIGNAL;
  sev.sigev_signo = SIG;
  sev.sigev_value.sival_ptr = &timerid;
  if (timer_create(CLOCKID, &sev, &timerid) == -1)
  errExit("timer_create");

  printf("timer ID is 0x%lx\n", (long) timerid);

  /* Start the timer */

  freq_nanosecs = atoll(argv[2]);
  its.it_value.tv_sec = freq_nanosecs / 1000000000;
  its.it_value.tv_nsec = freq_nanosecs % 1000000000;
  its.it_interval.tv_sec = its.it_value.tv_sec;
  its.it_interval.tv_nsec = its.it_value.tv_nsec;

  if (timer_settime(timerid, 0, &its, NULL) == -1)
    errExit("timer_settime");
  /* Sleep for a while; meanwhile, the timer may expire  multiple times */

  printf("Sleeping for %d seconds\n", atoi(argv[1]));
  sleep(atoi(argv[1]));

  /* Unlock the timer signal, so that timer notification  can be delivered */

  printf("Unblocking signal %d\n", SIG);
  if(sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1)
    errExit("sigprocmask");
  do
  {
    if(end_flag == 3) 
    {
      timer_delete(timerid);
      exit(EXIT_SUCCESS);
    }
  }
  while(1);
  exit(EXIT_SUCCESS);
}
/*
编译 ： gcc timer.c -lrt
./a.out 1 1000000000
Establishing handler for signal 34
Blocking signal 34
timer ID is 0x1fa4010
Sleeping for 1 seconds
Unblocking signal 34
Caught signal 34
sival_ptr = 0x7ffcf06f7b80; *sival_ptr = 0x1fa4010
overrun count = 0

 */