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 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)) );
}
}
}
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;
}
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 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 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;
}
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 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);
}
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 );
}
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;
}
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;
}
int32_t
acrn_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;
}
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;
}
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);
}
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);
}
CStdMultimediaTimerProc::CStdMultimediaTimerProc(uint32_t iDelay)
{
fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
if (fd == -1)
Log("timerfd_create failed");
SetDelay(iDelay);
}
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;
}
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;
}
