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; }
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; }
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; }
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; }
// Enable The Timer And Set Interval, Timer Will First Run After It's Specified Interval int Timer::SetInterval(int sec, int msec) { struct itimerspec new_time; struct timespec current; clock_gettime(CLOCK_REALTIME, ¤t); new_time.it_value.tv_sec = current.tv_sec + sec; new_time.it_value.tv_nsec = current.tv_nsec + 1000000 * msec; // If Nanosecond Field Exceeds 1000000000, Second Field Increase if (new_time.it_value.tv_nsec >= 1000000000) { new_time.it_value.tv_sec++; new_time.it_value.tv_nsec -= 1000000000; } if (once_run_) { new_time.it_interval.tv_sec = 0; new_time.it_interval.tv_nsec = 0; } else { new_time.it_interval.tv_sec = sec; new_time.it_interval.tv_nsec = 1000000 * msec; } interval_ = new_time.it_interval; return timerfd_settime(timerfd_, TFD_TIMER_ABSTIME, &new_time, NULL); }
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(); }
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); }
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)) ); } } }
static int timerfd_timer_set_rate(int handle, unsigned int rate) { struct timerfd_timer *our_timer, find_helper = { .handle = handle, }; int res = 0; if (handle == -1) { ast_log(LOG_ERROR, "Attempting to set rate on timerfd handle -1"); return -1; } if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) { ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle); return -1; } ao2_lock(our_timer); our_timer->saved_timer.it_value.tv_sec = 0; our_timer->saved_timer.it_value.tv_nsec = rate ? (long) (1000000000 / rate) : 0L; our_timer->saved_timer.it_interval.tv_sec = our_timer->saved_timer.it_value.tv_sec; our_timer->saved_timer.it_interval.tv_nsec = our_timer->saved_timer.it_value.tv_nsec; if (!our_timer->is_continuous) { res = timerfd_settime(handle, 0, &our_timer->saved_timer, NULL); } ao2_unlock(our_timer); ao2_ref(our_timer, -1); return res; }
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 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); }
void Timer::runTimer() { struct pollfd event[1]; event[0].fd= timerfd_; event[0].events = POLLIN; char buf[1024]; int nready; if(timerfd_settime(timerfd_, 0, &howlong_, NULL) == -1) ERR_EXIT("timerfd_settime"); is_Started_ = true; while(is_Started_) { nready = poll(event, 1, 10000); if(nready == -1) { ERR_EXIT("poll"); } else if(nready == 0) printf("timeout\n"); else { if(read(timerfd_, buf, sizeof buf) == -1) ERR_EXIT("read"); timeCallback_(); } } }
void Timer::cancelTimer() { memset(&howlong_, 0, sizeof howlong_); if(timerfd_settime(timerfd_, 0, &howlong_, NULL) == -1) ERR_EXIT("timerfd_settime"); is_Started_ = false; }
int evfilt_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 int rb_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; }
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; }
/* 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 vc_stop_timer (vc_data *data) { if(data->fds[FD_INDEX_TIMER].fd < 0){ debug_printf("%s: attempted to operate on an invalid timerfd\n", __func__); return -1; } struct itimerspec its; its.it_interval.tv_sec = 0; its.it_interval.tv_nsec = 0; its.it_value.tv_sec = 0; its.it_value.tv_nsec = 0; int ret = 0; if((ret = timerfd_settime(data->fds[FD_INDEX_TIMER].fd, 0, (const struct itimerspec *) &its, NULL)) < 0) return -1; data->fds[FD_INDEX_TIMER].events = 0; return 0; }
ANW_RSP_STATUS AnwTimer::arm_timer() { struct itimerspec curr_value; ANW_RSP_STATUS anw_status = ANW_STATUS_SUCCESS; AnwApp *anw_app = NULL; epoll_event ev; curr_value.it_value.tv_sec = _it_value / 1000; curr_value.it_value.tv_nsec = (_it_value % 1000) * 1000 * 1000; curr_value.it_interval.tv_sec = _interval / 1000; curr_value.it_interval.tv_nsec = (_interval % 1000 ) * 1000 * 1000; if( -1 == timerfd_settime(_timerid, 0, &curr_value, 0)) { _valid = false; return ANW_STATUS_FAILURE; } _valid = true; ev.events = EPOLLIN | EPOLLPRI ; //ev.events = EPOLLIN | EPOLLET ; //_epoll_event_impl = new epoll_event_impl(ANW_EPOLL_IMPL_TYPE_TIMER, _timer_impl); //ev.data.ptr = _epoll_event_impl; //pass the pointer to AnwTimerImpl ev.data.ptr = this; anw_app = AnwApp::CreateInstance(); if (unlikely(NULL == anw_app)) { ANW_DEBUG_ASSERT(0); return ANW_STATUS_FAILURE; } anw_status = anw_app->add_timer(_timerid, ev); return anw_status; }
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_t netresolve_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; }
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); }
bool PeriodicThreadImplTimerfd::setPeriod(const icl_core::TimeSpan& period) { m_period = period; int ret = -1; if (timer_created) { /* Make the timer periodic */ unsigned int ns; unsigned int sec; struct itimerspec itval; sec = period.tsSec(); ns = period.tsNSec(); 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(m_info->timer_fd, 0, &itval, NULL); } if (ret == -1) { return false; } else { return true; } }
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; }
// Send Modbus packet int send_modbus_packet(uint8_t device_address, uint8_t sequence_number, Packet* packet_to_send) { int bytes_written = 0; uint16_t packet_crc16 = 0; uint8_t crc16_first_byte_index = 0; int packet_size = packet_to_send->header.length + MODBUS_PACKET_OVERHEAD; uint8_t modbus_packet[packet_size]; //printf(">>>>>>>>>>>>>>>>>>>>> SEN %llu\n", microseconds()); // Assemble Modbus packet header modbus_packet[0] = device_address; modbus_packet[1] = RS485_EXTENSION_MODBUS_FUNCTION_CODE; modbus_packet[2] = sequence_number; // Assemble Tinkerforge packet header memcpy(&modbus_packet[3], &packet_to_send->header, sizeof(PacketHeader)); // Assemble Tinkerforge packet payload (if any) memcpy(&modbus_packet[3+sizeof(PacketHeader)], &packet_to_send->payload, packet_to_send->header.length - TINKERFORGE_HEADER_LENGTH); // Calculating CRC16 packet_crc16 = crc16(modbus_packet, packet_to_send->header.length + MODBUS_PACKET_HEADER_LENGTH); // Assemble the calculated CRC16 to the Modbus packet crc16_first_byte_index = packet_to_send->header.length + MODBUS_PACKET_HEADER_LENGTH; modbus_packet[crc16_first_byte_index] = packet_crc16 >> 8; modbus_packet[++crc16_first_byte_index] = packet_crc16 & 0x00FF; // Enabling TX start = microseconds(); gpio_output_set(_tx_pin); // Sending packet bytes_written = write(_rs485_serial_fd, modbus_packet, sizeof(modbus_packet)); if (bytes_written <= 0) { // Disabling TX gpio_output_clear(_tx_pin); end = microseconds(); send_verify_flag = 0; log_error("RS485: Error sending packet through serial interface"); return -1; } // Save the packet as byte array memcpy(current_request_as_byte_array, modbus_packet, packet_size); // Start the send verify timer setup_timer(&send_verify_timer, TIME_UNIT_NSEC, SEND_VERIFY_TIMEOUT); timerfd_settime(_send_verify_event, 0, &send_verify_timer, NULL); // Set send verify flag send_verify_flag = 1; log_debug("RS485: Packet sent through serial interface"); return bytes_written; }
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; }
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); }
void CStdMultimediaTimerProc::SetDelay(uint32_t inDelay) { struct itimerspec nv, ov; nv.it_interval.tv_sec = inDelay / 1000; nv.it_interval.tv_nsec = (inDelay % 1000) * 1000000; nv.it_value = nv.it_interval; timerfd_settime(fd, 0, &nv, &ov); }
void CStdMultimediaTimerProc::Set() { struct itimerspec nv, ov; timerfd_gettime(fd, &nv); nv.it_value.tv_sec = 0; nv.it_value.tv_nsec = 1; timerfd_settime(fd, 0, &nv, &ov); }