int main(int argc, char *argv[])
{
struct sigevent ev;
timer_t tid;
struct itimerspec its;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGCONT;
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_delete(tid) != 0) {
perror("timer_delete() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_gettime(tid, &its) == -1) {
if (EINVAL == errno) {
printf("fcn returned -1 and errno==EINVAL\n");
return PTS_PASS;
} else {
printf("fcn returned -1 but errno!=EINVAL\n");
printf("Test FAILED\n");
return PTS_FAIL;
}
}
printf("fcn did not return -1\n");
return PTS_PASS;
}
int main(int argc, char *argv[])
{
struct sigevent ev;
timer_t tid;
struct itimerspec itsset, itsget;
struct timespec ts;
int flags = 0;
int delta;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGCONT;
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
if (clock_gettime(CLOCK_REALTIME, &ts) != 0) {
perror("clock_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
itsset.it_interval.tv_sec = 0;
itsset.it_interval.tv_nsec = 0;
itsset.it_value.tv_sec = ts.tv_sec + TIMERSEC;
itsset.it_value.tv_nsec = ts.tv_nsec;
flags |= TIMER_ABSTIME;
if (timer_settime(tid, flags, &itsset, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_gettime(tid, &itsget) != 0) {
perror("timer_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
delta = TIMERSEC - itsget.it_value.tv_sec;
if (delta < 0) {
printf("FAIL: timer_gettime() value > timer_settime()\n");
printf("%d > %d\n", (int)itsget.it_value.tv_sec,
(int)itsset.it_value.tv_sec);
return PTS_FAIL;
}
if (delta <= ACCEPTABLEDELTA) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("FAIL: timer_gettime() value !~= timer_settime()\n");
printf("%d !~= %d\n", (int)itsget.it_value.tv_sec,
(int)itsset.it_value.tv_sec);
return PTS_FAIL;
}
printf("This code should not be executed\n");
return PTS_UNRESOLVED;
}
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
{
timer_t host_timer = (timer_t)(long)t->priv;
struct itimerspec timeout;
int64_t nearest_delta_us = INT64_MAX;
int64_t current_us;
assert(alarm_has_dynticks(t));
if (!active_timers[QEMU_CLOCK_REALTIME] &&
!active_timers[QEMU_CLOCK_VIRTUAL] &&
!active_timers[QEMU_CLOCK_HOST])
return;
nearest_delta_us = qemu_next_deadline_dyntick();
/* check whether a timer is already running */
if (timer_gettime(host_timer, &timeout)) {
perror("gettime");
fprintf(stderr, "Internal timer error: aborting\n");
exit(1);
}
current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
if (current_us && current_us <= nearest_delta_us)
return;
timeout.it_interval.tv_sec = 0;
timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
timeout.it_value.tv_sec = nearest_delta_us / 1000000;
timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
perror("settime");
fprintf(stderr, "Internal timer error: aborting\n");
exit(1);
}
}
static void dynticks_rearm_timer(struct qemu_alarm_timer *t,
int64_t nearest_delta_ns)
{
timer_t host_timer = t->timer;
struct itimerspec timeout;
int64_t current_ns;
if (nearest_delta_ns < MIN_TIMER_REARM_NS)
nearest_delta_ns = MIN_TIMER_REARM_NS;
/* check whether a timer is already running */
if (timer_gettime(host_timer, &timeout)) {
perror("gettime");
fprintf(stderr, "Internal timer error: aborting\n");
exit(1);
}
current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
if (current_ns && current_ns <= nearest_delta_ns)
return;
timeout.it_interval.tv_sec = 0;
timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
timeout.it_value.tv_sec = nearest_delta_ns / 1000000000;
timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
perror("settime");
fprintf(stderr, "Internal timer error: aborting\n");
exit(1);
}
}
void armIdleTimer(timer_t timerid, struct itimerspec &its) {
its.it_value.tv_sec = 900;
its.it_value.tv_nsec = 0;
its.it_interval.tv_sec = 0;
its.it_interval.tv_nsec = 0;
if(timer_settime(timerid, 0, &its, NULL) == -1) {
logWarning(NetMauMau::Common::Logger::time(TIMEFORMAT) << "Could not arm idle timer");
} else {
struct itimerspec itc;
char *sdStr = 0L;
if(!timer_gettime(timerid, &itc) &&
!(itc.it_value.tv_sec == 0 &&
itc.it_value.tv_nsec == 0)) {
time_t now;
time(&now);
now += itc.it_value.tv_sec;
sdStr = std::asctime(std::localtime(&now));
}
if(sdStr) logInfo(NetMauMau::Common::Logger::time(TIMEFORMAT) << "Idle timer armed to "
<< sdStr);
}
}
int main(int argc, char *argv[])
{
struct sigevent ev;
timer_t tid;
struct itimerspec its;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGCONT;
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_gettime(tid, &its) != 0) {
perror("timer_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
if ( (0 == its.it_value.tv_sec) &&
(0 == its.it_value.tv_nsec) ) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED: tv_sec %d tv_nsec %d\n",
(int) its.it_value.tv_sec,
(int) its.it_value.tv_nsec);
return PTS_FAIL;
}
return PTS_UNRESOLVED;
}
int main(void)
{
timer_t timerid = 0;
struct itimerspec value;
return timer_gettime(timerid, &value);
}
unsigned int alarm
(
unsigned int secs
)
{
static timer_t timer_id = NULL;
struct itimerspec tspec, tremain;
/* if first time, create a timer */
if (!timer_id)
{
if (timer_create(CLOCK_REALTIME, NULL, &timer_id) == ERROR)
return(ERROR);
}
/* set new time*/
tspec.it_interval.tv_sec = 0;
tspec.it_interval.tv_nsec = 0;
tspec.it_value.tv_sec = secs;
tspec.it_value.tv_nsec = 0;
/* save off timer remaining from previous for return */
timer_gettime(timer_id, &tremain);
timer_settime(timer_id, CLOCK_REALTIME, &tspec, NULL);
return((unsigned int)tremain.it_value.tv_sec);
}
void test( void )
{
timer_t timerid = 0;
struct itimerspec value;
int result;
result = timer_gettime( timerid, &value );
}
int main(int argc, char *argv[])
{
struct sigevent ev;
timer_t tid;
struct itimerspec itsset, itsget;
int delta;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGCONT;
itsset.it_interval.tv_sec = 0;
itsset.it_interval.tv_nsec = 0;
itsset.it_value.tv_sec = TIMERSEC;
itsset.it_value.tv_nsec = 0;
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_settime(tid, 0, &itsset, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
if (sleep(SLEEPSEC) != 0) {
perror("sleep() did not return 0\n");
return PTS_UNRESOLVED;
}
if (timer_gettime(tid, &itsget) != 0) {
perror("timer_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
delta = (itsset.it_value.tv_sec - SLEEPSEC) - itsget.it_value.tv_sec;
if (delta < 0) {
printf("FAIL: timer_gettime() value > time expected left\n");
printf("%d > %d\n", (int)itsget.it_value.tv_sec,
(int)itsset.it_value.tv_sec - SLEEPSEC);
return PTS_FAIL;
}
if (delta <= ACCEPTABLEDELTA) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("FAIL: timer_gettime() value !~= time expected left\n");
printf("%d !~= %d\n", (int)itsget.it_value.tv_sec,
(int)itsset.it_value.tv_sec - SLEEPSEC);
return PTS_FAIL;
}
printf("This code should not be executed\n");
return PTS_UNRESOLVED;
}
// NOTE: must be called with monitor lock.
static void reschedule_root_alarm(void) {
bool timer_was_set = timer_set;
assert(alarms != NULL);
// If used in a zeroed state, disarms the timer
struct itimerspec wakeup_time;
memset(&wakeup_time, 0, sizeof(wakeup_time));
if (list_is_empty(alarms))
goto done;
alarm_t *next = list_front(alarms);
int64_t next_expiration = next->deadline - now();
if (next_expiration < TIMER_INTERVAL_FOR_WAKELOCK_IN_MS) {
if (!timer_set) {
int status = bt_os_callouts->acquire_wake_lock(WAKE_LOCK_ID);
if (status != BT_STATUS_SUCCESS) {
LOG_ERROR("%s unable to acquire wake lock: %d", __func__, status);
goto done;
}
}
wakeup_time.it_value.tv_sec = (next->deadline / 1000);
wakeup_time.it_value.tv_nsec = (next->deadline % 1000) * 1000000LL;
} else {
if (!bt_os_callouts->set_wake_alarm(next_expiration, true, timer_callback, NULL))
LOG_ERROR("%s unable to set wake alarm for %" PRId64 "ms.", __func__, next_expiration);
}
done:
timer_set = wakeup_time.it_value.tv_sec != 0 || wakeup_time.it_value.tv_nsec != 0;
if (timer_was_set && !timer_set) {
bt_os_callouts->release_wake_lock(WAKE_LOCK_ID);
}
if (timer_settime(timer, TIMER_ABSTIME, &wakeup_time, NULL) == -1)
LOG_ERROR("%s unable to set timer: %s", __func__, strerror(errno));
// If next expiration was in the past (e.g. short timer that got context switched)
// then the timer might have diarmed itself. Detect this case and work around it
// by manually signalling the |alarm_expired| semaphore.
//
// It is possible that the timer was actually super short (a few milliseconds)
// and the timer expired normally before we called |timer_gettime|. Worst case,
// |alarm_expired| is signaled twice for that alarm. Nothing bad should happen in
// that case though since the callback dispatch function checks to make sure the
// timer at the head of the list actually expired.
if (timer_set) {
struct itimerspec time_to_expire;
timer_gettime(timer, &time_to_expire);
if (time_to_expire.it_value.tv_sec == 0 && time_to_expire.it_value.tv_nsec == 0) {
LOG_ERROR("%s alarm expiration too close for posix timers, switching to guns", __func__);
semaphore_post(alarm_expired);
}
}
}
int RequestInjectionData::getRemainingTime() const {
if (m_hasTimer) {
itimerspec ts;
if (!timer_gettime(m_timer_id, &ts)) {
int remaining = ts.it_value.tv_sec;
return remaining > 1 ? remaining : 1;
}
}
return m_timeoutSeconds;
}
struct itimerspec getTimer(const timer_t timerid) {
struct itimerspec timeout;
errno = 0;
if (timer_gettime(timerid, &timeout) != 0)
ERREXIT("Cannot set timer: %s", strerror(errno));
return timeout;
}
static void
start_stop_timer(timer_t timerid, long interval, bool start)
{
struct itimerspec its;
if (start) {
its.it_value.tv_sec = interval;
its.it_value.tv_nsec = 0;
} else {
#ifdef CKPTTIMER_PLUGIN_DEBUG
if (timer_gettime(timerid, &its) == 0) {
JTRACE("Time left: it_value, it_interval") (its.it_value.tv_sec)
(its.it_value.tv_nsec)
(its.it_interval.tv_sec)
(its.it_interval.tv_nsec);
} else {
handleError("timer_gettime");
}
#endif // ifdef CKPTTIMER_PLUGIN_DEBUG
its.it_value.tv_sec = 0;
its.it_value.tv_nsec = 0;
}
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) {
handleError("timer_settime");
}
#ifdef CKPTTIMER_PLUGIN_DEBUG
if (!start) {
if (timer_gettime(timerid, &its) == 0) {
JTRACE("After disabling: it_value, it_interval") (its.it_value.tv_sec)
(its.it_value.tv_nsec)
(its.it_interval.tv_sec)
(its.it_interval.tv_nsec);
} else {
handleError("timer_gettime");
}
}
#endif // ifdef CKPTTIMER_PLUGIN_DEBUG
}
int RequestTimer::getRemainingTime() const {
#ifndef __APPLE__
if (m_hasTimer) {
itimerspec ts;
if (!timer_gettime(m_timer_id, &ts)) {
int remaining = ts.it_value.tv_sec;
return remaining > 1 ? remaining : 1;
}
}
#endif
return m_timeoutSeconds;
}
int main(int argc, char *argv[])
{
struct sigevent ev;
timer_t tid;
struct itimerspec itsset, itsget;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGCONT;
itsset.it_interval.tv_sec = 0;
itsset.it_interval.tv_nsec = 0;
itsset.it_value.tv_sec = TIMERSEC;
itsset.it_value.tv_nsec = 0;
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
/*
* set up timer that will expire
*/
if (timer_settime(tid, 0, &itsset, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
/*
* let timer expire (just call sleep())
*/
sleep(TIMERSEC + SLEEPDELTA);
if (timer_gettime(tid, &itsget) != 0) {
perror("timer_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
if (0 == itsget.it_value.tv_sec && 0 == itsget.it_value.tv_nsec) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED: tv_sec %d tv_nsec %d\n",
(int)itsget.it_value.tv_sec,
(int)itsget.it_value.tv_nsec);
return PTS_FAIL;
}
printf("This code should not be executed\n");
return PTS_UNRESOLVED;
}
int main(void)
{
struct sigevent ev;
timer_t tid;
struct itimerspec itsset, itsget;
int delta;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGCONT;
itsset.it_interval.tv_sec = 0;
itsset.it_interval.tv_nsec = 0;
itsset.it_value.tv_sec = TIMERSEC;
itsset.it_value.tv_nsec = 0;
if (timer_create(CLOCK_REALTIME, &ev, &tid) != 0) {
perror("timer_create() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_settime(tid, 0, &itsset, NULL) != 0) {
perror("timer_settime() did not return success\n");
return PTS_UNRESOLVED;
}
if (timer_gettime(tid, &itsget) != 0) {
perror("timer_gettime() did not return success\n");
return PTS_UNRESOLVED;
}
delta = itsset.it_value.tv_sec - itsget.it_value.tv_sec;
if (delta < 0) {
printf("FAIL: timer_gettime() value > timer_settime()\n");
printf("%d > %d\n", (int)itsget.it_value.tv_sec,
(int)itsset.it_value.tv_sec);
return PTS_FAIL;
}
if (delta <= ACCEPTABLEDELTA) {
printf("Test PASSED\n");
return PTS_PASS;
}
printf("FAIL: timer_gettime() value !~= timer_settime()\n");
printf("%d !~= %d\n", (int)itsget.it_value.tv_sec,
(int)itsset.it_value.tv_sec);
return PTS_FAIL;
}
bool timer_complete(timer_t * timer)
{
struct itimerspec curr_val;
if(timer_gettime(*timer, &curr_val) == -1) {
perror("\nCould not get time\n");
exit(EXIT_FAILURE);
}
if(curr_val.it_value.tv_nsec == 0 && curr_val.it_value.tv_sec == 0) {
printf("\nTimer %lx Complete!\n", (long)*timer);
return true;
}
else
return false;
}
int32 timer_status (timer_info_t *timer_info)
{
int current_count = -1;
struct itimerspec timer_spec;
if ((timer_gettime ((timer_t)(timer_info->handle), &timer_spec)) == 0)
{
current_count = timer_info->millisec
- ((timer_spec.it_value.tv_sec * 1000)
+ (timer_spec.it_value.tv_nsec / 1000000));
}
return current_count;
}
// Return: 0 if the timer has expired
static int
read_and_restart_timer(int seconds)
{
int result;
struct itimerspec current;
result = timer_gettime(timer, ¤t);
if (result != 0) die("timer_gettime() failed");
if (current.it_value.tv_sec == 0 && current.it_value.tv_nsec == 0)
{
set_timer(seconds);
return 0;
}
return 1;
}
/*
* waitms: -1 for block until event occurs
* 0 perform non blocking check
* >0 Timeout in milliseconds.
*/
void
PhysicalMedium::interval(int waitms)
{
int rv;
struct itimerspec ts;
struct itimerspec ts_left;
/* One shot timer, armed with the time after the interval specified */
timespec_add_ms(&pimpl->curTime, waitms);
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 0;
ts.it_value = pimpl->curTime;
/* As we are using a timer any adjustments while this asbsolute timer
* is armed will also be adjusted. */
rv = timer_settime(pimpl->timer, TIMER_ABSTIME, &ts, NULL);
if (rv == -1)
throw "PhysicalMedium::interval: failed to arm timer";
do {
rv = epoll_wait(pimpl->poller.epfd, pimpl->poller.events,
EPOLL_MAX_EVENTS, waitms);
if (rv == -1) {
if (errno != EINTR)
/* Not EINTR so we do have a problem */
throw "PhysicalMedium::interval: epoll failure";
} else {
//rv is 0 or number of file descriptors to process.
if (rv) {
processPollerEvents(rv);
break;
}
}
if (timer_gettime(pimpl->timer, &ts_left) == -1)
throw "PhysicalMedium::interval: failed to get timer";
// Readjust wait ms based on time left.
waitms = (ts_left.it_value.tv_sec * 1000)
+ (ts_left.it_value.tv_nsec / 1000000);
} while(rv > 0 && waitms > 0);
}
static void luasandbox_timer_stop_one(luasandbox_timer * lt, struct timespec * remaining)
{
static struct timespec zero = {0, 0};
struct itimerspec its;
timer_gettime(lt->timer, &its);
if (remaining) {
*remaining = its.it_value;
}
its.it_value = zero;
its.it_interval = zero;
if (timer_settime(lt->timer, 0, &its, NULL) != SUCCESS) {
TSRMLS_FETCH();
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"timer_settime(): %s", strerror(errno));
}
// Invalidate the callback structure, delete the timer
lt->sandbox = NULL;
// If the timer event handler is running, wait for it to finish
// before returning to the caller, otherwise the timer event handler
// may find itself with a dangling pointer in its local scope.
while (1) {
if (sem_wait(<->semaphore) == SUCCESS) {
sem_destroy(<->semaphore);
break;
}
if (errno != EINTR) {
TSRMLS_FETCH();
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"sem_wait(): %s", strerror(errno));
break;
}
}
if (timer_delete(lt->timer) != SUCCESS) {
TSRMLS_FETCH();
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"timer_delete(): %s", strerror(errno));
}
luasandbox_timer_free(lt);
}
int
main(int argc, char *argv[])
{
struct sigevent sev;
struct itimerspec ts;
long arg1, arg2, arg3, arg4;
timer_t tid;
int j;
if (argc < 2) {
fprintf(stderr,
"Usage: %s secs [nsecs [int-secs [int-nsecs]]]\n",
argv[0]);
exit(EXIT_FAILURE);
} /* if */
sev.sigev_notify = SIGEV_NONE;
if (timer_create(CLOCK_REALTIME, &sev, &tid) == -1)
errExit("timer_create");
arg1 = ts.it_value.tv_sec = atoi(argv[1]);
arg2 = ts.it_value.tv_nsec = (argc > 2) ? atoi(argv[2]) : 0;
arg3 = ts.it_interval.tv_sec = (argc > 3) ? atoi(argv[3]) : 0;
arg4 = ts.it_interval.tv_nsec = (argc > 4) ? atoi(argv[4]) : 0;
if (timer_settime(tid, 0, &ts, NULL) == -1) errExit("timer_settime");
for (j = 0; ; j++) {
usleep(500000);
if (timer_gettime(tid, &ts) == -1) errExit("timer_gettime");
printf("%d: value=%ld.%09ld(%ld.%09ld); interval=%ld.%09ld(%ld.%09ld)\n", j,
(long) ts.it_value.tv_sec, (long) ts.it_value.tv_nsec,
arg1, arg2,
(long) ts.it_interval.tv_sec,
(long) ts.it_interval.tv_nsec,
arg3, arg4);
} /* if */
exit(EXIT_SUCCESS);
} /* main */
static void luasandbox_timer_stop_one(luasandbox_timer * lt, struct timespec * remaining)
{
static struct timespec zero = {0, 0};
struct itimerspec its;
timer_gettime(lt->timer, &its);
if (remaining) {
*remaining = its.it_value;
}
its.it_value = zero;
its.it_interval = zero;
timer_settime(lt->timer, 0, &its, NULL);
if (lt->cbdata.type == LUASANDBOX_TIMER_PROFILER) {
// Invalidate the cbdata, delete the timer
lt->cbdata.sandbox = NULL;
timer_delete(lt->timer);
// If the timer event handler is running, wait for it to finish
// before returning to the caller, otherwise the timer event handler
// may find itself with a dangling pointer in its local scope.
while (sem_wait(<->cbdata.semaphore) && errno == EINTR);
sem_destroy(<->cbdata.semaphore);
} else {
// Block the signal, delete the timer, flush pending signals, restore
sigset_t sigset, oldset, pendset;
siginfo_t info;
sigemptyset(&sigset);
sigaddset(&sigset, LUASANDBOX_SIGNAL);
sigprocmask(SIG_BLOCK, &sigset, &oldset);
timer_delete(lt->timer);
while (1) {
sigpending(&pendset);
if (!sigismember(&pendset, LUASANDBOX_SIGNAL)) {
break;
}
sigwaitinfo(&sigset, &info);
luasandbox_timer_handle_signal(LUASANDBOX_SIGNAL, &info, NULL);
}
sigprocmask(SIG_SETMASK, &oldset, NULL);
}
}
/*
* reinit_timer - reinitialize interval timer after a clock step.
*/
void
reinit_timer(void)
{
#if !defined(SYS_WINNT) && !defined(VMS)
ZERO(itimer);
# ifdef HAVE_TIMER_CREATE
timer_gettime(timer_id, &itimer);
# else
getitimer(ITIMER_REAL, &itimer);
# endif
if (itimer.it_value.tv_sec < 0 ||
itimer.it_value.tv_sec > (1 << EVENT_TIMEOUT))
itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
if (itimer.it_value.itv_frac < 0)
itimer.it_value.itv_frac = 0;
if (0 == itimer.it_value.tv_sec &&
0 == itimer.it_value.itv_frac)
itimer.it_value.tv_sec = (1 << EVENT_TIMEOUT);
itimer.it_interval.tv_sec = (1 << EVENT_TIMEOUT);
itimer.it_interval.itv_frac = 0;
set_timer_or_die(&itimer);
# endif /* VMS */
}
/**
* @fn :tc_timer_timer_set_get_time
* @brief :arm/disarm and fetch state of POSIX per-process timer
* @scenario :arm/disarm and fetch state of POSIX per-process timer
* API's covered :timer_create, timer_settime, timer_gettime
* Preconditions :Creation of timer_id(timer_create)
* Postconditions :none
* @return :void
*/
static void tc_timer_timer_set_get_time(void)
{
int ret_chk = ERROR;
clockid_t clockid = CLOCK_REALTIME;
struct sigevent st_sigevent;
struct itimerspec st_timer_spec_set;
struct itimerspec st_timer_spec_get;
timer_t timer_id;
/* Set and enable alarm */
st_sigevent.sigev_notify = SIGEV_SIGNAL;
st_sigevent.sigev_signo = sig_no;
st_sigevent.sigev_value.sival_ptr = &timer_id;
ret_chk = timer_create(clockid, &st_sigevent, &timer_id);
TC_ASSERT_NEQ("timer_create", ret_chk, ERROR);
TC_ASSERT_NOT_NULL("timer_create", timer_id);
st_timer_spec_set.it_interval.tv_sec = 1;
st_timer_spec_set.it_interval.tv_nsec = 0; /* interval; */
st_timer_spec_set.it_value.tv_sec = 1;
st_timer_spec_set.it_value.tv_nsec = 0; /* expire; */
ret_chk = timer_settime(timer_id, 0, &st_timer_spec_set, NULL); /* Flag =1 :TIMER_ABSTIME */
TC_ASSERT_EQ_ERROR_CLEANUP("timer_settime", ret_chk, OK, errno, timer_delete(timer_id));
usleep(USECINT);
ret_chk = timer_gettime(timer_id, &st_timer_spec_get);
TC_ASSERT_EQ_ERROR_CLEANUP("timer_gettime", ret_chk, OK, errno, timer_delete(timer_id));
TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_interval.tv_nsec, st_timer_spec_set.it_interval.tv_nsec, timer_delete(timer_id));
TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_interval.tv_sec, st_timer_spec_set.it_interval.tv_sec, timer_delete(timer_id));
TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_value.tv_sec, st_timer_spec_set.it_value.tv_sec, timer_delete(timer_id));
TC_ASSERT_GEQ_CLEANUP("timer_gettime", st_timer_spec_get.it_value.tv_nsec, st_timer_spec_set.it_value.tv_nsec, timer_delete(timer_id));
timer_delete(timer_id);
TC_SUCCESS_RESULT();
}
/*
* reinit_timer - reinitialize interval timer.
*/
void
reinit_timer(void)
{
#if !defined(SYS_WINNT) && !defined(VMS)
# if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
timer_gettime(ntpd_timerid, &itimer);
if (itimer.it_value.tv_sec < 0 || itimer.it_value.tv_sec > (1<<EVENT_TIMEOUT)) {
itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
}
if (itimer.it_value.tv_nsec < 0 ) {
itimer.it_value.tv_nsec = 0;
}
if (itimer.it_value.tv_sec == 0 && itimer.it_value.tv_nsec == 0) {
itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
itimer.it_value.tv_nsec = 0;
}
itimer.it_interval.tv_sec = (1<<EVENT_TIMEOUT);
itimer.it_interval.tv_nsec = 0;
timer_settime(ntpd_timerid, 0 /*!TIMER_ABSTIME*/, &itimer, NULL);
# else
getitimer(ITIMER_REAL, &itimer);
if (itimer.it_value.tv_sec < 0 || itimer.it_value.tv_sec > (1<<EVENT_TIMEOUT)) {
itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
}
if (itimer.it_value.tv_usec < 0 ) {
itimer.it_value.tv_usec = 0;
}
if (itimer.it_value.tv_sec == 0 && itimer.it_value.tv_usec == 0) {
itimer.it_value.tv_sec = (1<<EVENT_TIMEOUT);
itimer.it_value.tv_usec = 0;
}
itimer.it_interval.tv_sec = (1<<EVENT_TIMEOUT);
itimer.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0);
# endif
# endif /* VMS */
}
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
{
timer_t host_timer = t->timer;
struct itimerspec timeout;
int64_t nearest_delta_ns = INT64_MAX;
int64_t current_ns;
assert(alarm_has_dynticks(t));
if (!qemu_clock_has_timers(QEMU_CLOCK_REALTIME) &&
!qemu_clock_has_timers(QEMU_CLOCK_VIRTUAL) &&
!qemu_clock_has_timers(QEMU_CLOCK_HOST))
return;
nearest_delta_ns = qemu_next_alarm_deadline();
if (nearest_delta_ns < MIN_TIMER_REARM_NS)
nearest_delta_ns = MIN_TIMER_REARM_NS;
/* check whether a timer is already running */
if (timer_gettime(host_timer, &timeout)) {
perror("gettime");
fprintf(stderr, "Internal timer error: aborting\n");
exit(1);
}
current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
if (current_ns && current_ns <= nearest_delta_ns)
return;
timeout.it_interval.tv_sec = 0;
timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
timeout.it_value.tv_sec = nearest_delta_ns / 1000000000;
timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
perror("settime");
fprintf(stderr, "Internal timer error: aborting\n");
exit(1);
}
}
//------------------------------------------------------------------------------
BOOL timeru_isActive(tTimerHdl timerHdl_p)
{
tTimeruData* pData;
struct itimerspec remaining;
// check handle itself, i.e. was the handle initialized before
if (timerHdl_p == 0)
{ // timer was not created yet, so it is not active
return FALSE;
}
pData = (tTimeruData*)timerHdl_p;
// check if timer is running
timer_gettime(pData->timer, &remaining);
if ((remaining.it_value.tv_sec == 0) && (remaining.it_value.tv_nsec == 0))
{
return FALSE;
}
else
{
return TRUE;
}
}
int fat_open(struct inode* inode) {
fat_t* fat = (fat_t*) inode->userdata;
if(unlikely(!fat)) {
errno = EINVAL;
return E_ERR;
}
if(fat->entry_sector == 0)
return E_OK;
fat->dev->position = fat->entry_sector * fat->bytes_per_sector;
inode_t* child = NULL;
static char buf[512];
fat_entry_t* e = (fat_entry_t*) &buf;
fat_entry_lfn_t* lfn = (fat_entry_lfn_t*) &buf;
int entry = 0;
do {
if(unlikely(fat_check_entry(fat, &entry) == E_ERR))
break;
if(vfs_read(fat->dev, &buf, 32) != 32) {
errno = EIO;
return E_ERR;
}
if(e->name[0] == '\0')
break;
child = (inode_t*) kmalloc(sizeof(inode_t), GFP_ATOMIC);
if(unlikely(!child)) {
errno = ENOMEM;
return E_ERR;
}
memset(child, 0, sizeof(inode_t));
child->name = (const char*) kmalloc(FAT_MAXFN, GFP_ATOMIC);
if(unlikely(!child->name)) {
kfree((void*) child);
errno = ENOMEM;
return E_ERR;
}
memset((void*) child->name, 0, FAT_MAXFN);
if(e->flags == ATTR_LFN) {
do {
#if CONFIG_LFN
lfncat(child->name, lfn->name_2, 2);
lfncat(child->name, lfn->name_1, 6);
lfncat(child->name, lfn->name_0, 5);
#endif
if(unlikely(fat_check_entry(fat, &entry) == E_ERR)) {
kfree((void*) child->name);
kfree((void*) child);
errno = ENOENT;
return E_ERR;
}
if(vfs_read(fat->dev, &buf, 32) != 32) {
kfree((void*) child->name);
kfree((void*) child);
errno = EIO;
return E_ERR;
}
} while(lfn->flags == ATTR_LFN);
}
if(e->name[0] == '\xE5') {
kfree((void*) child->name);
kfree((void*) child);
continue;
}
if(child->name[0] == '\0')
fatcat(child->name, e->name, e->extension);
struct inode_childs* cx;
for(cx = inode->childs; cx; cx = cx->next) {
if(strcmp(cx->inode->name, child->name) == 0) {
kfree((void*) child->name);
kfree((void*) child);
continue;
}
}
fat_t* fc = (fat_t*) kmalloc(sizeof(fat_t), GFP_USER);
if(unlikely(!fc)) {
kfree((void*) child->name);
kfree((void*) child);
errno = ENOMEM;
return E_ERR;
}
memcpy(fc, fat, sizeof(fat_t));
int cluster = (e->cluster_high << 16) | (e->cluster_low & 0xFFFF);
fc->entry_sector = cluster
? CLUSTER_TO_SECTOR(fc, cluster)
: 0
;
child->userdata = (void*) fc;
child->ino = vfs_inode();
child->mode = (e->flags & ATTR_DIRECTORY ? S_IFDIR : S_IFREG) |
(e->flags & ATTR_RDONLY ? 0444 : 0666) & ~current_task->umask;
child->dev =
child->rdev =
child->nlink = 0;
child->uid = current_task->uid;
child->gid = current_task->gid;
child->size = (off64_t) e->size;
child->atime =
child->ctime =
child->mtime = timer_gettime();
child->parent = inode;
child->link = NULL;
child->childs = NULL;
if(e->flags & ATTR_DIRECTORY) {
child->finddir = fat_finddir;
child->mknod = fat_mknod;
child->rename = NULL;
child->unlink = fat_unlink;
child->open = fat_open;
child->close = fat_close;
} else {
child->read = NULL;
child->write = NULL;
}
child->chown = NULL;
child->chmod = NULL;
child->ioctl = NULL;
cx = (struct inode_childs*) kmalloc(sizeof(struct inode_childs), GFP_KERNEL);
cx->inode = child;
cx->next = inode->childs;
inode->childs = cx;
} while(1);
}
