自学教程：C++ timerfd_create函数代码示例

static jlong init_timerfd(){    int epollfd;    int fds[N_ANDROID_TIMERFDS];    epollfd = epoll_create(N_ANDROID_TIMERFDS);    if (epollfd < 0) {        ALOGV("epoll_create(%zu) failed: %s", N_ANDROID_TIMERFDS,                strerror(errno));        return 0;    }    for (size_t i = 0; i < N_ANDROID_TIMERFDS; i++) {        fds[i] = timerfd_create(android_alarm_to_clockid[i], 0);        if ((fds[i] < 0) && (android_alarm_to_clockid[i] == CLOCK_POWEROFF_ALARM)) {            ALOGV("timerfd does not support CLOCK_POWEROFF_ALARM, using CLOCK_REALTIME_ALARM instead");            fds[i] = timerfd_create(CLOCK_REALTIME_ALARM, 0);        }        if (fds[i] < 0) {            ALOGV("timerfd_create(%u) failed: %s",  android_alarm_to_clockid[i],                    strerror(errno));            close(epollfd);            for (size_t j = 0; j < i; j++) {                close(fds[j]);            }            return 0;        }    }    AlarmImpl *ret = new AlarmImplTimerFd(fds, epollfd, wall_clock_rtc());    for (size_t i = 0; i < N_ANDROID_TIMERFDS; i++) {        epoll_event event;        event.events = EPOLLIN | EPOLLWAKEUP;        event.data.u32 = i;        int err = epoll_ctl(epollfd, EPOLL_CTL_ADD, fds[i], &event);        if (err < 0) {            ALOGV("epoll_ctl(EPOLL_CTL_ADD) failed: %s", strerror(errno));            delete ret;            return 0;        }    }    struct itimerspec spec;    memset(&spec, 0, sizeof(spec));    /* 0 = disarmed; the timerfd doesn't need to be armed to get       RTC change notifications, just set up as cancelable */    int err = timerfd_settime(fds[ANDROID_ALARM_TYPE_COUNT],            TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &spec, NULL);    if (err < 0) {        ALOGV("timerfd_settime() failed: %s", strerror(errno));        delete ret;        return 0;    }    return reinterpret_cast<jlong>(ret);}

network_t * network_create(){    network_t * network;    if (!(network = malloc(sizeof(network_t))))          goto ERR_NETWORK;    if (!(network->socketpool   = socketpool_create()))  goto ERR_SOCKETPOOL;    if (!(network->sendq        = queue_create()))       goto ERR_SENDQ;    if (!(network->recvq        = queue_create()))       goto ERR_RECVQ;    if ((network->timerfd = timerfd_create(CLOCK_REALTIME, 0)) == -1) {        goto ERR_TIMERFD;    }#ifdef USE_SCHEDULING    if ((network->scheduled_timerfd = timerfd_create(CLOCK_REALTIME, 0)) == -1) {        goto ERR_GROUP_TIMERFD;    }    if (!(network->scheduled_probes = probe_group_create(network->scheduled_timerfd))) {        goto ERR_GROUP;    }#endif    if (!(network->sniffer = sniffer_create(network->recvq, network_sniffer_callback))) {        goto ERR_SNIFFER;    }    if (!(network->probes = dynarray_create())) goto ERR_PROBES;    network->last_tag = 0;    network->timeout = NETWORK_DEFAULT_TIMEOUT;    network->is_verbose = false;    return network;ERR_PROBES:    sniffer_free(network->sniffer);ERR_SNIFFER:#ifdef USE_SCHEDULING    probe_group_free(network->scheduled_probes);ERR_GROUP :    close(network->scheduled_timerfd);ERR_GROUP_TIMERFD :#endif    close(network->timerfd);ERR_TIMERFD:    queue_free(network->recvq, (ELEMENT_FREE) packet_free);ERR_RECVQ:    queue_free(network->sendq, (ELEMENT_FREE) probe_free);ERR_SENDQ:    socketpool_free(network->socketpool);ERR_SOCKETPOOL:    free(network);ERR_NETWORK:    return NULL;}

void suspend(void){	int power_state_fd;	struct sigevent event = {};	int timerfd;	int err;	struct itimerspec spec = {};	if (getuid() != 0)		ksft_exit_skip("Please run the test as root - Exiting./n");	power_state_fd = open("/sys/power/state", O_RDWR);	if (power_state_fd < 0)		ksft_exit_fail_msg(			"open(/"/sys/power/state/") failed %s)/n",			strerror(errno));	timerfd = timerfd_create(CLOCK_BOOTTIME_ALARM, 0);	if (timerfd < 0)		ksft_exit_fail_msg("timerfd_create() failed/n");	spec.it_value.tv_sec = 5;	err = timerfd_settime(timerfd, 0, &spec, NULL);	if (err < 0)		ksft_exit_fail_msg("timerfd_settime() failed/n");	if (write(power_state_fd, "mem", strlen("mem")) != strlen("mem"))		ksft_exit_fail_msg("Failed to enter Suspend state/n");	close(timerfd);	close(power_state_fd);}

int main(){	struct itimerspec time;	struct timeval now;		gettimeofday(&now, NULL);	time.it_interval.tv_sec = 1;	time.it_interval.tv_nsec = 0;	time.it_value.tv_sec = now.tv_sec + 1; 	time.it_value.tv_nsec = now.tv_usec * 1000;		int fd = timerfd_create(CLOCK_REALTIME, 0);	assert(fd > 0);		timerfd_settime(fd, TFD_TIMER_ABSTIME, &time, NULL);		int count = 0;	while(1)	{		uint64_t exp;		int n = read(fd, &exp, sizeof(exp));		assert(n == sizeof(exp));		printf("time out %d./n", ++count);	}	return 0;}

static int timerfd_init(const struct itimerspec *ti){	int fd = -1;	int ret = -1;	if (ti == NULL)		return -1;	/* create new timer */	fd = timerfd_create(CLOCK_MONOTONIC, 0);	if (fd < 0) {		printf("Failed to create timer/n");		return -1;	}	/* set to non-blocking */	ret = fcntl(fd, F_SETFL, O_NONBLOCK);	if (ret) {		printf("Failed to set to non blocking mode/n");		close(fd);		return -1;	}	/* set timeout */	ret = timerfd_settime(fd, 0, ti, NULL);	if (ret) {		printf("Failed to set timer duration/n");		close(fd);		return -1;	}	printf("%s fd %d/n", __func__, fd);	return fd;}

static dbus_bool_t addTimeout(DBusTimeout *timeout, void *data){   (void)data;   dbus_bool_t ret = FALSE;   if(ARRAY_SIZE(gPollInfo.fds) > (unsigned int)(gPollInfo.nfds))   {      const int interval = dbus_timeout_get_interval(timeout);      if ((0<interval)&&(TRUE==dbus_timeout_get_enabled(timeout)))      {         const int tfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);         if (-1!=tfd)         {            const struct itimerspec its = { .it_value= {interval/1000, interval%1000} };            if (-1!=timerfd_settime(tfd, 0, &its, NULL))            {               tObjectEntry * const pEntry = &gPollInfo.objects[gPollInfo.nfds];               pEntry->objtype = OT_TIMEOUT;               pEntry->timeout = timeout;               gPollInfo.fds[gPollInfo.nfds].fd = tfd;               gPollInfo.fds[gPollInfo.nfds].events |= POLLIN;               ++gPollInfo.nfds;               ret = TRUE;            }            else            {               DLT_LOG(gPclDLTContext, DLT_LOG_ERROR, DLT_STRING("addTimeout - _settime() failed"), DLT_STRING(strerror(errno)) );            }         }         else         {            DLT_LOG(gPclDLTContext, DLT_LOG_ERROR, DLT_STRING("addTimeout - _create() failed"), DLT_STRING(strerror(errno)) );         }      }   }

CStdMultimediaTimerProc::CStdMultimediaTimerProc(uint32_t iDelay){	fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);	if (fd == -1)		Log("timerfd_create failed");	SetDelay(iDelay);}

struct pool_controller *controller_create(struct thread_pool *pool) {	PRINT_DEBUG("Entered: pool=%p", pool);	struct pool_controller *controller = (struct pool_controller *) secure_malloc(sizeof(struct pool_controller));	controller->pool = pool;	controller->period = 1000.000; //observe queue add rates & change time	controller->id = 0;	controller->running = 1;#ifndef BUILD_FOR_ANDROID	controller->fd = timerfd_create(CLOCK_REALTIME, 0);	if (controller->fd == -1) {		PRINT_ERROR("ERROR: unable to create to_fd.");		exit(-1);	}#endif	//sem_init(&worker->activate_sem, 0, 0);	//change back to normal? if fails don't crash	secure_pthread_create(&controller->thread, NULL, controller_thread, (void *) controller);	//pthread_detach(&controller->thread);	//start_timer(controller->fd, 0.5);	return controller;}

int main(int argc, const char *argv[]){    //创建fd    int timerfd = timerfd_create(CLOCK_REALTIME, 0);    if(timerfd == -1)        ERR_EXIT("timerfd_create");    //设置时间    struct itimerspec tv;    memset(&tv, 0, sizeof tv);    tv.it_value.tv_sec = 3;    tv.it_interval.tv_sec = 1;    if(timerfd_settime(timerfd, 0, &tv, NULL) == -1)        ERR_EXIT("timerfd_settime");    //判断fd可读    uint64_t val;    int ret;    while(1)    {        ret = read(timerfd, &val, sizeof val);        if(ret == -1 && errno == EINTR)            continue;        printf("ret = %d/n", ret);        foo();    }    close(timerfd);    return 0;}

int create_timer(int interval_value , int epoll_fd){    int timer_fd = timerfd_create(CLOCK_REALTIME , 0);    if(timer_fd < 0)     {        LOG_ERROR("In create_timer : timerfd_create error : %s" , STR_ERROR);        return -1;    }    struct timespec interval;    interval.tv_sec = interval_value;    interval.tv_nsec = 0;    struct itimerspec spec;    spec.it_value = interval;    spec.it_interval = interval;    if(timerfd_settime(timer_fd , TFD_TIMER_ABSTIME , &spec , NULL) < 0)    {        LOG_ERROR("In create_timer : timerfd_settime error : %s" , STR_ERROR);        close(timer_fd);        return -1;    }    if(add_to_epoll(epoll_fd , timer_fd , EPOLLIN , NULL) < 0)    {        LOG_ERROR("In create_timer : all timer %d to epoll error !" , timer_fd);        close(timer_fd);        return -1;    }    return timer_fd;}

 int CTimerHandler::open(uint32_t start_second, int interval_second) {     this->m_start_second = start_second;     this->m_interval_second = interval_second;          if((m_sock_handle = timerfd_create(CLOCK_MONOTONIC,TFD_NONBLOCK|TFD_CLOEXEC)) < 0)     {         LOG_ERROR("Timer fd create failed. %d, %s", errno, strerror(errno));         return -1;     }          struct itimerspec new_value;     // struct itimerspec old_value;     // bzero(&new_value, sizeof(new_value));     // bzero(&old_value,sizeof(old_value));          struct timespec start, interval;     start.tv_sec = start_second;     start.tv_nsec = 0;          interval.tv_sec = interval_second;     interval.tv_nsec = 0;          new_value.it_value = start;     new_value.it_interval = interval;          if( timerfd_settime(m_sock_handle, 0, &new_value, NULL) < 0) // 0 relative time     {         LOG_ERROR("Settime error, %d, %s/n", errno, strerror(errno));         return -1;     }          return CEventHandler::open(); }

void service_init(struct service *sv, uint16_t port, const char *key, const char *capture, const char *playback, uint32_t bitrate,        void (*handler)(enum service_event event, const uint8_t uid[20], void *args), void *args){    sv->state = STATE_IDLE;    sv->state_handler = handler;    sv->state_args = args;    sv->epfd = epoll_create1(0); assert(sv->epfd > 0);    sv->timerfd = timerfd_create(CLOCK_MONOTONIC, 0); assert(sv->timerfd > 0);    service_pollfd(sv, sv->timerfd, (void(*)(void*))timer_handler, sv);    const int optval = 1;    const struct sockaddr_in addr = { AF_INET, htons(port) };    sv->sockfd = socket(AF_INET, SOCK_DGRAM, 0); assert(sv->sockfd > 0);    int res = setsockopt(sv->sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); assert(res == 0);    if(bind(sv->sockfd, (struct sockaddr*)&addr, sizeof(addr)) != 0) { ERROR("Cannot bind socket"); abort(); }    service_pollfd(sv, sv->sockfd, (void(*)(void*))socket_handler, sv);    route_init(sv->table);    sv->crypto = (struct crypto*)((void*)sv + sizeof(struct service));    crypto_init(sv->crypto, key, sv->srcid);    sv->media = (struct media*)((void*)sv + sizeof(struct service) + crypto_sizeof());    media_init(sv->media, capture, playback);    sv->packet_size = bitrate / 8 / 50;    INFO("Media: bitrate = %u, capture = %s, playback = %s", bitrate, capture, playback);    char tmp[128]; INFO("User ID is %.40s", hexify(sv->srcid, tmp, 20));}

int main(void) {  int fd = timerfd_create(CLOCK_MONOTONIC, 0);  struct itimerspec spec, old;  uint64_t num_expirations;  atomic_printf("created timerfd %d/n", fd);  test_assert(fd >= 0);  memset(&spec, 0, sizeof(spec));  spec.it_value.tv_nsec = 100000000;  atomic_printf("setting timer to expire in {sec:%ld,nsec:%ld}/n",                spec.it_value.tv_sec, spec.it_value.tv_nsec);  timerfd_settime(fd, 0, &spec, &old);  atomic_printf("  (old expiration was {sec:%ld,nsec:%ld})/n",                old.it_value.tv_sec, old.it_value.tv_nsec);  test_assert(0 == old.it_value.tv_sec && 0 == old.it_value.tv_nsec);  atomic_puts("sleeping 50ms ...");  usleep(50000);  timerfd_gettime(fd, &old);  atomic_printf("  expiration now in {sec:%ld,nsec:%ld})/n",                old.it_value.tv_sec, old.it_value.tv_nsec);  test_assert(0 == old.it_value.tv_sec && old.it_value.tv_nsec <= 50000000);  atomic_puts("waiting for timer to expire ...");  read(fd, &num_expirations, sizeof(num_expirations));  atomic_printf("  timer expired %" PRIu64 " times/n", num_expirations);  test_assert(1 == num_expirations);  atomic_puts("EXIT-SUCCESS");  return 0;}

int			create_timer(t_cc* data, t_evqueue *evq, int p_id){  struct itimerspec	new_value;  t_evq			*tdata;  t_evq			d = {-1, NULL, p_id, data->fd, NULL};  int			timer_fd;  tdata = malloc(sizeof(t_evq));  check_mem(tdata);  new_value.it_value.tv_sec = 0;  new_value.it_value.tv_nsec = 0;  new_value.it_interval.tv_sec = 0;  new_value.it_interval.tv_nsec = 0;  timer_fd = timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);  *evq = create_evqueue(timer_fd);  d.eventq = *evq;  memcpy(tdata, &d , sizeof(t_evq));  timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &new_value, NULL);  tdata->timer_fd = timer_fd;  tdata->read_func = execute_event;  data->e->event.events = EPOLLIN | EPOLLRDHUP;  data->e->event.data.ptr = tdata;  epoll_ctl(data->e->efd, EPOLL_CTL_ADD, timer_fd, &data->e->event);  return (timer_fd); error:  return (-1);}

CAMLprim value netsys_not_event_timerfd(int clockid){    struct not_event *p;    value r;    int x;    int e;    r = alloc_not_event();    p = *(Not_event_val(r));    p->state = 0;    p->fd1 = -1;    p->fd2 = -1;    p->allow_user_add = 0;    p->type = NE_TIMERFD;    x = timerfd_create(clockid, 0);    if (x == -1) uerror("timerfd_create", Nothing);    p->fd1 = x;    x = fcntl(p->fd1, F_SETFD, FD_CLOEXEC);    if (x == -1) {	e = errno;	close(p->fd1);	unix_error(e, "fcntl", Nothing);    }    return r;}

int main(int argc, char ** argv ) {    struct timespec cur;    struct timeval  tv1,tv2;    if( argc < 4 ) {	fprintf( stderr, "Usage: %s <num> <num> <num>.../n", argv[0] );	exit( EXIT_FAILURE );    }    int fd = timerfd_create( CLOCK_MONOTONIC, 0 );    clock_gettime( CLOCK_MONOTONIC, &cur );    struct itimerspec val;    val.it_value.tv_sec     = cur.tv_sec + atoi( argv[1] );    val.it_value.tv_nsec    = 0;    val.it_interval.tv_sec  = atoi( argv[2] );    val.it_interval.tv_nsec = 0;    timerfd_settime( fd, TFD_TIMER_ABSTIME, &val, 0 );    gettimeofday( &tv1, 0 );    uint64_t read_cnt;    int      cnt;    for( cnt = 0; cnt < atoi( argv[3] ); cnt ++ ) {	read( fd, &read_cnt, sizeof( uint64_t ));	gettimeofday( &tv2, 0 );	double rtn = TV2SEC( tv2 ) - TV2SEC( tv1 );	printf( "timerfd %d Path... [%f]/n", cnt + 1, rtn );	tv1 = tv2;    }    close( fd );    exit( EXIT_SUCCESS );}

netresolve_timeout_tnetresolve_timeout_add(netresolve_query_t query, time_t sec, long nsec,		netresolve_timeout_callback_t callback, void *data){	netresolve_watch_t watch;	int fd;	struct itimerspec timerspec = {{0, 0}, {sec, (sec != 0 || nsec != 0) ? nsec : 1}};	if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK)) == -1)		return NULL;	if (timerfd_settime(fd, 0, &timerspec, NULL) == -1) {		close(fd);		return NULL;	}	debug_query(query, "adding timeout: fd=%d sec=%d nsec=%ld", fd, (int) sec, nsec);	watch = netresolve_watch_add(query, fd, POLLIN, NULL, data);	if (watch && callback) {		watch->callback = timeout_watch_callback;		watch->timeout_callback = callback;	}	assert(watch);	return watch;}

static int async_usleep(struct sip_msg* msg, async_ctx *ctx, int *useconds){	struct itimerspec its;	int fd;	LM_DBG("sleep %d useconds/n", *(unsigned int *)useconds);	/* create the timer fd */	if ( (fd=timerfd_create( CLOCK_REALTIME, 0))<0 ) {		LM_ERR("failed to create new timer FD (%d) <%s>/n",			errno, strerror(errno));		return -1;	}	/* set the time */	its.it_value.tv_sec = (*(unsigned int *)useconds / 1000000);	its.it_value.tv_nsec = (*(unsigned int *)useconds % 1000000) * 1000;	its.it_interval.tv_sec = 0;	its.it_interval.tv_nsec = 0;	if (timerfd_settime( fd, 0, &its, NULL)<0) {		LM_ERR("failed to set timer FD (%d) <%s>/n",			errno, strerror(errno));		return -1;	}	/* start the async wait */	ctx->resume_param = (void*)(unsigned long)		(((unsigned long)-1) & (get_uticks()+*(unsigned int *)useconds));	ctx->resume_f = resume_async_sleep;	async_status = fd;	return 1;}

static int make_periodic (unsigned int period, struct periodic_info *info){	int ret;	unsigned int ns;	unsigned int sec;	int fd;	struct itimerspec itval;	/* Create the timer */	fd = timerfd_create (CLOCK_MONOTONIC, 0);	info->wakeups_missed = 0;	info->timer_fd = fd;	if (fd == -1)		return fd;	/* Make the timer periodic */	sec = period/1000000;	ns = (period - (sec * 1000000)) * 1000;	itval.it_interval.tv_sec = sec;	itval.it_interval.tv_nsec = ns;	itval.it_value.tv_sec = sec;	itval.it_value.tv_nsec = ns;	ret = timerfd_settime (fd, 0, &itval, NULL);	return ret;}

int32_tacrn_timer_init(struct acrn_timer *timer, void (*cb)(void *, uint64_t),		void *param){	if ((timer == NULL) || (cb == NULL)) {		return -1;	}	timer->fd = -1;	if ((timer->clockid == CLOCK_REALTIME) ||			(timer->clockid == CLOCK_MONOTONIC)) {		timer->fd = timerfd_create(timer->clockid,					TFD_NONBLOCK | TFD_CLOEXEC);	} else {		perror("acrn_timer clockid is not supported./n");	}	if (timer->fd <= 0) {		perror("acrn_timer create failed./n");		return -1;	}	timer->mevp = mevent_add(timer->fd, EVF_READ, timer_handler, timer, NULL, NULL);	if (timer->mevp == NULL) {		close(timer->fd);		perror("acrn_timer mevent add failed./n");		return -1;	}	timer->callback = cb;	timer->callback_param = param;	return 0;}

static int TimerStart(unsigned int period, struct TimerInfo *info){    int rc;    unsigned int ns;    unsigned int sec;    int fd;    struct itimerspec itval;    // Create the timer    fd = timerfd_create (CLOCK_MONOTONIC, 0);    info->wakeups_missed = 0;    info->timer_fd = fd;    if (fd == -1)    {        return fd;    }    // Make the timer periodic    sec = period/1000000;    ns = (period - (sec * 1000000)) * 1000;    itval.it_interval.tv_sec = sec;    itval.it_interval.tv_nsec = ns;    itval.it_value.tv_sec = sec;    itval.it_value.tv_nsec = ns;    rc = timerfd_settime (fd, 0, &itval, NULL);    return rc;}

timerfd*timerfd_new(uint32_t timeout,void *ud){	timerfd *t = calloc(1,sizeof(*t));	((handle*)t)->fd = timerfd_create(CLOCK_MONOTONIC,TFD_CLOEXEC|TFD_NONBLOCK);	if(((handle*)t)->fd < 0){		free(t);		return NULL;	}	struct itimerspec spec;    struct timespec now;	clock_gettime(CLOCK_MONOTONIC, &now);	int32_t sec = timeout/1000;	int32_t ms = timeout%1000;    	int64_t nosec = (now.tv_sec + sec)*1000*1000*1000 + now.tv_nsec + ms*1000*1000;	spec.it_value.tv_sec = nosec/(1000*1000*1000);    	spec.it_value.tv_nsec = nosec%(1000*1000*1000);    	spec.it_interval.tv_sec = sec;    	spec.it_interval.tv_nsec = ms*1000*1000;			if(0 != timerfd_settime(((handle*)t)->fd,TFD_TIMER_ABSTIME,&spec,0))	{		close(((handle*)t)->fd);		free(t);		return NULL;	}	((handle*)t)->on_events = on_timeout;	((handle*)t)->imp_engine_add = imp_engine_add;	t->ud = ud;	return t;}

int timer_setup (rtdal_timer_t *info){    long int ns;    __time_t sec;    int fd;    if (info->period<=0) {        aerror_msg("Invalid period %d/n", (int) info->period);        return -1;    }    /* Create the timer */    fd = timerfd_create (CLOCK_REALTIME, 0);    if (fd == -1) {        perror("timerfd_create");        return -1;    }    info->wakeups_missed = 0;    info->timer_fd = fd;    /* Make the timer periodic */    sec = info->period/1000000000;    ns = (info->period - (sec * 1000000));    info->itval.it_interval.tv_sec = sec;    info->itval.it_interval.tv_nsec = ns;    info->itval.it_value.tv_sec = sec;    info->itval.it_value.tv_nsec = ns;    return 0;}

/* Register a timeout file descriptor */static inline int _mk_event_timeout_create(mk_event_ctx_t *ctx, int expire){    int ret;    int timer_fd;    struct itimerspec its;    /* expiration interval */    its.it_interval.tv_sec  = expire;    its.it_interval.tv_nsec = 0;    /* initial expiration */    its.it_value.tv_sec  = time(NULL) + expire;    its.it_value.tv_nsec = 0;    timer_fd = timerfd_create(CLOCK_REALTIME, 0);    if (timer_fd == -1) {        mk_libc_error("timerfd");        return -1;    }    ret = timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &its, NULL);    if (ret < 0) {        mk_libc_error("timerfd_settime");        return -1;    }    /* register the timer into the epoll queue */    ret = _mk_event_add(ctx, timer_fd, MK_EVENT_READ);    if (ret != 0) {        close(timer_fd);        return ret;    }    return timer_fd;}

int event_queue_add_timer(int eq, int *id, int sec) {	struct itimerspec it;	int tfd = timerfd_create(CLOCK_REALTIME, TFD_CLOEXEC);	if (tfd < 0) {		uwsgi_error("timerfd_create()");		return -1;	}	it.it_value.tv_sec = sec;	it.it_value.tv_nsec = 0;	it.it_interval.tv_sec = sec;	it.it_interval.tv_nsec = 0;	if (timerfd_settime(tfd, 0, &it, NULL)) {		uwsgi_error("timerfd_settime()");		close(tfd);		return -1;	}		*id = tfd;	return event_queue_add_fd_read(eq, tfd);}

static intrb_epoll_sched_event_timerfd(struct ev_entry *event, int when){	struct itimerspec ts;	static char buf[FD_DESC_SZ + 8];	int fd;	rb_fde_t *F;	if((fd = timerfd_create(CLOCK_REALTIME, 0)) < 0)	{		rb_lib_log("timerfd_create: %s/n", strerror(errno));		return 0;	}	memset(&ts, 0, sizeof(ts));	ts.it_value.tv_sec = when;	ts.it_value.tv_nsec = 0;	if(event->frequency != 0)		ts.it_interval = ts.it_value;	if(timerfd_settime(fd, 0, &ts, NULL) < 0)	{		rb_lib_log("timerfd_settime: %s/n", strerror(errno));		close(fd);		return 0;	}	rb_snprintf(buf, sizeof(buf), "timerfd: %s", event->name);	F = rb_open(fd, RB_FD_UNKNOWN, buf);	rb_set_nb(F);	event->comm_ptr = F;	rb_setselect(F, RB_SELECT_READ, rb_read_timerfd, event);	return 1;}

intevfilt_timer_knote_create(struct filter *filt, struct knote *kn){    struct epoll_event ev;    struct itimerspec ts;    int tfd;    kn->kev.flags |= EV_CLEAR;    tfd = timerfd_create(CLOCK_MONOTONIC, 0);    if (tfd < 0) {        dbg_printf("timerfd_create(2): %s", strerror(errno));        return (-1);    }    dbg_printf("created timerfd %d", tfd);    convert_msec_to_itimerspec(&ts, kn->kev.data, kn->kev.flags & EV_ONESHOT);    if (timerfd_settime(tfd, 0, &ts, NULL) < 0) {        dbg_printf("timerfd_settime(2): %s", strerror(errno));        close(tfd);        return (-1);    }    memset(&ev, 0, sizeof(ev));    ev.events = EPOLLIN;    ev.data.ptr = kn;    if (epoll_ctl(filter_epfd(filt), EPOLL_CTL_ADD, tfd, &ev) < 0) {        dbg_printf("epoll_ctl(2): %d", errno);        close(tfd);        return (-1);    }    kn->data.pfd = tfd;    return (0);}

static jint netty_epoll_native_timerFd(JNIEnv* env, jclass clazz) {    jint timerFD = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);    if (timerFD < 0) {        netty_unix_errors_throwChannelExceptionErrorNo(env, "timerfd_create() failed: ", errno);    }    return timerFD;}

       int       main(int argc, char *argv[])       {           struct itimerspec new_value;           int max_exp, fd;           struct timespec now;           uint64_t exp, tot_exp;           ssize_t s;           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 */	   double a = 1000.100;	   double re = a % 100;	   printf("1000.100 % 100 =  %lld", re);           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;           fd = timerfd_create(CLOCK_REALTIME, 0);           if (fd == -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;) {               s = read(fd, &exp, sizeof(uint64_t));               if (s != sizeof(uint64_t))                   handle_error("read");               tot_exp += exp;               print_elapsed_time();               printf("read: %llu; total=%llu/n",                       (unsigned long long) exp,                       (unsigned long long) tot_exp);           //}           exit(EXIT_SUCCESS);       }

static void *itimer_thread_func(void *_handle_tick){    TickProc handle_tick = _handle_tick;    uint64_t nticks;    int timerfd = -1;#if defined(USE_TIMERFD_FOR_ITIMER) && USE_TIMERFD_FOR_ITIMER    struct itimerspec it;    it.it_value.tv_sec  = TimeToSeconds(itimer_interval);    it.it_value.tv_nsec = TimeToNS(itimer_interval) % 1000000000;    it.it_interval = it.it_value;    timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);    if (timerfd == -1) {        sysErrorBelch("timerfd_create");        stg_exit(EXIT_FAILURE);    }    if (!TFD_CLOEXEC) {      fcntl(timerfd, F_SETFD, FD_CLOEXEC);    }    if (timerfd_settime(timerfd, 0, &it, NULL)) {        sysErrorBelch("timerfd_settime");        stg_exit(EXIT_FAILURE);    }#endif    while (!exited) {        if (USE_TIMERFD_FOR_ITIMER) {            if (read(timerfd, &nticks, sizeof(nticks)) != sizeof(nticks)) {                if (errno != EINTR) {                    sysErrorBelch("Itimer: read(timerfd) failed");                }            }        } else {            if (usleep(TimeToUS(itimer_interval)) != 0 && errno != EINTR) {                sysErrorBelch("usleep(TimeToUS(itimer_interval) failed");            }        }        // first try a cheap test        if (stopped) {            ACQUIRE_LOCK(&mutex);            // should we really stop?            if (stopped) {                waitCondition(&start_cond, &mutex);            }            RELEASE_LOCK(&mutex);        } else {            handle_tick(0);        }    }    if (USE_TIMERFD_FOR_ITIMER)        close(timerfd);    closeMutex(&mutex);    closeCondition(&start_cond);    return NULL;}