static PyObject * m_timerfd_gettime(PyObject *self, PyObject *args) { long fd = 0; int t_res; struct itimerspec g_time; PyObject* resp; if (!PyArg_ParseTuple(args, "l", &fd)) { PyErr_SetString( PyExc_TypeError, "fd is not a valid type or the argument is missing"); return NULL; } t_res = timerfd_gettime(fd, &g_time); if (t_res == -1) { return PyErr_SetFromErrno(PyExc_IOError); } resp = PyTuple_New(2); if (resp == NULL) { /* printf("bad tuple\n"); */ return NULL; } PyTuple_SetItem(resp, 0, PyDelta_FromDSU(0, g_time.it_value.tv_sec, NANO2MICRO(g_time.it_value.tv_nsec))); PyTuple_SetItem(resp, 1, PyDelta_FromDSU(0, g_time.it_interval.tv_sec, NANO2MICRO(g_time.it_interval.tv_nsec))); return resp; }//m_timerfd_gettime()
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; }
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); }
static int timerfd_timer_ack(int handle, unsigned int quantity) { uint64_t expirations; int read_result = 0; int res = 0; struct timerfd_timer *our_timer, find_helper = { .handle = handle, }; if (handle == -1) { ast_log(LOG_ERROR, "Attempting to ack timerfd handle -1"); return -1; } if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) { ast_log(LOG_ERROR, "Couldn't find a timer with handle %d\n", handle); return -1; } ao2_lock(our_timer); do { struct itimerspec timer_status; if (timerfd_gettime(handle, &timer_status)) { ast_log(LOG_ERROR, "Call to timerfd_gettime() using handle %d error: %s\n", handle, strerror(errno)); expirations = 0; res = -1; break; } if (timer_status.it_value.tv_sec == 0 && timer_status.it_value.tv_nsec == 0) { ast_debug(1, "Avoiding read on disarmed timerfd %d\n", handle); expirations = 0; break; } read_result = read(handle, &expirations, sizeof(expirations)); if (read_result == -1) { if (errno == EINTR || errno == EAGAIN) { continue; } else { ast_log(LOG_ERROR, "Read error: %s\n", strerror(errno)); res = -1; break; } } } while (read_result != sizeof(expirations)); ao2_unlock(our_timer); ao2_ref(our_timer, -1); if (expirations != quantity) { ast_debug(2, "Expected to acknowledge %u ticks but got %llu instead\n", quantity, (unsigned long long) expirations); } return res; }
int32_t acrn_timer_gettime(struct acrn_timer *timer, struct itimerspec *cur_value) { if (timer == NULL) { return -1; } return timerfd_gettime(timer->fd, cur_value); }
struct itimerspec timerfdObj::gettime() { struct itimerspec its; if (timerfd_gettime(filedesc, &its) < 0) throw SYSEXCEPTION("timerfd_gettime"); return its; }
static int timerfd_timer_ack(void *data, unsigned int quantity) { struct timerfd_timer *timer = data; uint64_t expirations; int read_result = 0; int res = 0; ao2_lock(timer); do { struct itimerspec timer_status; if (timerfd_gettime(timer->fd, &timer_status)) { ast_log(LOG_ERROR, "Call to timerfd_gettime() using handle %d error: %s\n", timer->fd, strerror(errno)); expirations = 0; res = -1; break; } if (timer_status.it_value.tv_sec == 0 && timer_status.it_value.tv_nsec == 0) { ast_debug(1, "Avoiding read on disarmed timerfd %d\n", timer->fd); expirations = 0; break; } read_result = read(timer->fd, &expirations, sizeof(expirations)); if (read_result == -1) { if (errno == EINTR || errno == EAGAIN) { continue; } else { ast_log(LOG_ERROR, "Read error: %s\n", strerror(errno)); res = -1; break; } } } while (read_result != sizeof(expirations)); ao2_unlock(timer); if (expirations != quantity) { ast_debug(2, "Expected to acknowledge %u ticks but got %llu instead\n", quantity, (unsigned long long) expirations); } return res; }
static void timerfd_gettime_verify(const struct test_case_t *test) { TEST(timerfd_gettime(*test->fd, test->curr_value)); if (TEST_RETURN != -1) { tst_resm(TFAIL, "timerfd_gettime() succeeded unexpectedly"); return; } if (TEST_ERRNO == test->exp_errno) { tst_resm(TPASS | TTERRNO, "timerfd_gettime() failed as expected"); } else { tst_resm(TFAIL | TTERRNO, "timerfd_gettime() failed unexpectedly; expected: " "%d - %s", test->exp_errno, strerror(test->exp_errno)); } }
int main(int ac, char **av) { int i, tfd; long ticks; unsigned long long tnow, ttmr; u_int64_t uticks; struct itimerspec tmr; struct tmr_type clks[] = { #if defined(HAVE_CLOCK_MONOTONIC) { CLOCK_MONOTONIC, "CLOCK MONOTONIC" }, #endif { CLOCK_REALTIME, "CLOCK REALTIME" }, }; for (i = 0; i < sizeof(clks) / sizeof(clks[0]); i++) { fprintf(stdout, "\n\n---------------------------------------\n"); fprintf(stdout, "| testing %s\n", clks[i].name); fprintf(stdout, "---------------------------------------\n\n"); fprintf(stdout, "relative timer test (at 500 ms) ...\n"); set_timespec(&tmr.it_value, 500 * 1000); set_timespec(&tmr.it_interval, 0); tnow = getustime(clks[i].id); if ((tfd = timerfd_create(clks[i].id, 0)) == -1) { perror("timerfd_create"); return 1; } if (timerfd_settime(tfd, 0, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "wating timer ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %.1f s\n", ticks, (ttmr - tnow) * 1e-6); fprintf(stdout, "absolute timer test (at 500 ms) ...\n"); tnow = getustime(clks[i].id); set_timespec(&tmr.it_value, tnow + 500 * 1000); set_timespec(&tmr.it_interval, 0); if (timerfd_settime(tfd, TFD_TIMER_ABSTIME, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "wating timer ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %.1f s\n", ticks, (ttmr - tnow) * 1e-6); fprintf(stdout, "sequential timer test (100 ms clock) ...\n"); tnow = getustime(clks[i].id); set_timespec(&tmr.it_value, tnow + 100 * 1000); set_timespec(&tmr.it_interval, 100 * 1000); if (timerfd_settime(tfd, TFD_TIMER_ABSTIME, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "sleeping one second ...\n"); sleep(1); if (timerfd_gettime(tfd, &tmr)) { perror("timerfd_gettime"); return 1; } fprintf(stdout, "timerfd_gettime returned:\n" "\tit_value = %.1f it_interval = %.1f\n", tmr.it_value.tv_sec + 1e-9 * tmr.it_value.tv_nsec, tmr.it_interval.tv_sec + 1e-9 * tmr.it_interval.tv_nsec); fprintf(stdout, "sleeping 1 second ...\n"); sleep(1); fprintf(stdout, "wating timer ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %.1f s\n", ticks, (ttmr - tnow) * 1e-6); fprintf(stdout, "O_NONBLOCK test ...\n"); tnow = getustime(clks[i].id); set_timespec(&tmr.it_value, 100 * 1000); set_timespec(&tmr.it_interval, 0); if (timerfd_settime(tfd, 0, &tmr, NULL)) { perror("timerfd_settime"); return 1; } #if 0 fprintf(stdout, "timerfd = %d\n", tfd); #endif fprintf(stdout, "wating timer (flush the single tick) ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %.1f s\n", ticks, (ttmr - tnow) * 1e-6); fcntl(tfd, F_SETFL, fcntl(tfd, F_GETFL, 0) | O_NONBLOCK); if (read(tfd, &uticks, sizeof(uticks)) > 0) fprintf(stdout, "whooops! timer ticks not zero when should have been\n"); else if (errno != EAGAIN) fprintf(stdout, "whooops! bad errno value (%d = '%s')!\n", errno, strerror(errno)); else fprintf(stdout, "success\n"); fcntl(tfd, F_SETFL, fcntl(tfd, F_GETFL, 0) & ~O_NONBLOCK); close(tfd); } return 0; }
int main() { #ifdef __NR_timerfd_create int fd; struct itimerspec val, oval; fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK); //staptest// timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK) = NNNN timerfd_gettime(fd, &val); //staptest// timerfd_gettime (NNNN, XXXX) = 0 val.it_value.tv_sec = 0; val.it_value.tv_nsec = 0; val.it_interval.tv_sec = 0; val.it_interval.tv_nsec = 0; timerfd_settime(fd, TFD_TIMER_ABSTIME, &val, &oval); //staptest// timerfd_settime (NNNN, TFD_TIMER_ABSTIME, \[0.000000,0.000000\], XXXX) = 0 close(fd); //staptest// close (NNNN) = NNNN /* Limit testing. */ fd = timerfd_create(-1, 0); //staptest// timerfd_create (0xffffffff, 0x0) = NNNN close(fd); //staptest// close (NNNN) = NNNN fd = timerfd_create(CLOCK_REALTIME, -1); //staptest// timerfd_create (CLOCK_REALTIME, TFD_[^ ]+|XXXX) = NNNN close(fd); //staptest// close (NNNN) = NNNN timerfd_gettime(-1, &val); //staptest// timerfd_gettime (-1, XXXX) = NNNN timerfd_gettime(-1, (struct itimerspec *)-1); #ifdef __s390__ //staptest// timerfd_gettime (-1, 0x[7]?[f]+) = NNNN #else //staptest// timerfd_gettime (-1, 0x[f]+) = NNNN #endif val.it_value.tv_sec = 0; val.it_value.tv_nsec = 0; val.it_interval.tv_sec = 0; val.it_interval.tv_nsec = 0; timerfd_settime(-1, TFD_TIMER_ABSTIME, &val, &oval); //staptest// timerfd_settime (-1, TFD_TIMER_ABSTIME, \[0.000000,0.000000\], XXXX) = NNNN timerfd_settime(-1, -1, &val, &oval); //staptest// timerfd_settime (-1, TFD_TIMER_[^ ]+|XXXX, \[0.000000,0.000000\], XXXX) = NNNN timerfd_settime(-1, TFD_TIMER_ABSTIME, (struct itimerspec *)-1, &oval); #ifdef __s390__ //staptest// timerfd_settime (-1, TFD_TIMER_ABSTIME, 0x[7]?[f]+, XXXX) = NNNN #else //staptest// timerfd_settime (-1, TFD_TIMER_ABSTIME, 0x[f]+, XXXX) = NNNN #endif timerfd_settime(-1, TFD_TIMER_ABSTIME, &val, (struct itimerspec *)-1); #ifdef __s390__ //staptest// timerfd_settime (-1, TFD_TIMER_ABSTIME, \[0.000000,0.000000\], 0x[7]?[f]+) = NNNN #else //staptest// timerfd_settime (-1, TFD_TIMER_ABSTIME, \[0.000000,0.000000\], 0x[f]+) = NNNN #endif #endif return 0; }
int main(int ac, char **av) { int i, tfd; long ticks; unsigned long long tnow, ttmr; u_int64_t uticks; struct itimerspec tmr; struct tmr_type clks[] = { {CLOCK_MONOTONIC, "CLOCK MONOTONIC"}, {CLOCK_REALTIME, "CLOCK REALTIME"}, }; if ((tst_kvercmp(2, 6, 25)) < 0) { tst_resm(TCONF, "This test can only run on kernels that are "); tst_resm(TCONF, "2.6.25 and higher"); exit(0); } for (i = 0; i < sizeof(clks) / sizeof(clks[0]); i++) { fprintf(stdout, "\n\n---------------------------------------\n"); fprintf(stdout, "| testing %s\n", clks[i].name); fprintf(stdout, "---------------------------------------\n\n"); fprintf(stdout, "relative timer test (at 500 ms) ...\n"); set_timespec(&tmr.it_value, 500 * 1000); set_timespec(&tmr.it_interval, 0); tnow = getustime(clks[i].id); if ((tfd = timerfd_create(clks[i].id, 0)) == -1) { perror("timerfd"); return 1; } fprintf(stdout, "timerfd = %d\n", tfd); if (timerfd_settime(tfd, 0, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "wating timer ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %llu ms\n", ticks, (ttmr - tnow) / 1000); fprintf(stdout, "absolute timer test (at 500 ms) ...\n"); tnow = getustime(clks[i].id); set_timespec(&tmr.it_value, tnow + 500 * 1000); set_timespec(&tmr.it_interval, 0); if (timerfd_settime(tfd, TFD_TIMER_ABSTIME, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "wating timer ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %llu ms\n", ticks, (ttmr - tnow) / 1000); fprintf(stdout, "sequential timer test (100 ms clock) ...\n"); tnow = getustime(clks[i].id); set_timespec(&tmr.it_value, tnow + 100 * 1000); set_timespec(&tmr.it_interval, 100 * 1000); if (timerfd_settime(tfd, TFD_TIMER_ABSTIME, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "sleeping 1 second ...\n"); sleep(1); if (timerfd_gettime(tfd, &tmr)) { perror("timerfd_gettime"); return 1; } fprintf(stdout, "timerfd_gettime returned:\n" "\tit_value = { %ld, %ld } it_interval = { %ld, %ld }\n", (long)tmr.it_value.tv_sec, (long)tmr.it_value.tv_nsec, (long)tmr.it_interval.tv_sec, (long)tmr.it_interval.tv_nsec); fprintf(stdout, "sleeping 1 second ...\n"); sleep(1); fprintf(stdout, "wating timer ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %llu ms\n", ticks, (ttmr - tnow) / 1000); fprintf(stdout, "O_NONBLOCK test ...\n"); tnow = getustime(clks[i].id); set_timespec(&tmr.it_value, 100 * 1000); set_timespec(&tmr.it_interval, 0); if (timerfd_settime(tfd, 0, &tmr, NULL)) { perror("timerfd_settime"); return 1; } fprintf(stdout, "timerfd = %d\n", tfd); fprintf(stdout, "wating timer (flush the single tick) ...\n"); ticks = waittmr(tfd, -1); ttmr = getustime(clks[i].id); if (ticks <= 0) fprintf(stdout, "whooops! no timer showed up!\n"); else fprintf(stdout, "got timer ticks (%ld) after %llu ms\n", ticks, (ttmr - tnow) / 1000); fcntl(tfd, F_SETFL, fcntl(tfd, F_GETFL, 0) | O_NONBLOCK); if (read(tfd, &uticks, sizeof(uticks)) > 0) fprintf(stdout, "whooops! timer ticks not zero when should have been\n"); else if (errno != EAGAIN) fprintf(stdout, "whooops! bad errno value (%d = '%s')!\n", errno, strerror(errno)); else fprintf(stdout, "success\n"); fcntl(tfd, F_SETFL, fcntl(tfd, F_GETFL, 0) & ~O_NONBLOCK); close(tfd); } tst_exit(); }
/* * stress_timerfd * stress timerfd */ int stress_timerfd( uint64_t *const counter, const uint32_t instance, const uint64_t max_ops, const char *name) { struct itimerspec timer; (void)instance; if (!set_timerfd_freq) { if (opt_flags & OPT_FLAGS_MAXIMIZE) opt_timerfd_freq = MAX_TIMERFD_FREQ; if (opt_flags & OPT_FLAGS_MINIMIZE) opt_timerfd_freq = MIN_TIMERFD_FREQ; } rate_ns = opt_timerfd_freq ? 1000000000 / opt_timerfd_freq : 1000000000; timerfd = timerfd_create(CLOCK_REALTIME, 0); if (timerfd < 0) { pr_failed_err(name, "timerfd_create"); (void)close(timerfd); return EXIT_FAILURE; } stress_timerfd_set(&timer); if (timerfd_settime(timerfd, 0, &timer, NULL) < 0) { pr_failed_err(name, "timer_settime"); (void)close(timerfd); return EXIT_FAILURE; } do { int ret; uint64_t exp; struct itimerspec value; struct timeval timeout; fd_set rdfs; FD_ZERO(&rdfs); FD_SET(timerfd, &rdfs); timeout.tv_sec = 0; timeout.tv_usec = 500000; if (!opt_do_run) break; ret = select(timerfd + 1, &rdfs, NULL, NULL, &timeout); if (ret < 0) { if (errno == EINTR) continue; pr_failed_err(name, "select"); break; } if (ret < 1) continue; /* Timeout */ ret = read(timerfd, &exp, sizeof exp); if (ret < 0) { pr_failed_err(name, "timerfd read"); break; } if (timerfd_gettime(timerfd, &value) < 0) { pr_failed_err(name, "timerfd_gettime"); break; } if (opt_flags & OPT_FLAGS_TIMERFD_RAND) { stress_timerfd_set(&timer); if (timerfd_settime(timerfd, 0, &timer, NULL) < 0) { pr_failed_err(name, "timer_settime"); break; } } (*counter)++; } while (opt_do_run && (!max_ops || timerfd_counter < max_ops)); (void)close(timerfd); return EXIT_SUCCESS; }