/*
|
* Copyright (C) 2010 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*
|
* Timer object abstraction.
|
*/
|
|
#include <signal.h>
|
#include <errno.h>
|
#include <stdlib.h>
|
#include <unistd.h>
|
#include <memory.h>
|
#include <limits.h>
|
#include <pthread.h>
|
#include <semaphore.h>
|
#include "boilerplate/list.h"
|
#include "boilerplate/signal.h"
|
#include "boilerplate/lock.h"
|
#include "copperplate/threadobj.h"
|
#include "copperplate/timerobj.h"
|
#include "copperplate/clockobj.h"
|
#include "copperplate/debug.h"
|
#include "internal.h"
|
|
static pthread_mutex_t svlock;
|
|
static pthread_t svthread;
|
|
static pid_t svpid;
|
|
static DEFINE_PRIVATE_LIST(svtimers);
|
|
#ifdef CONFIG_XENO_COBALT
|
|
static inline void timersv_init_corespec(void) { }
|
|
#else /* CONFIG_XENO_MERCURY */
|
|
static inline void timersv_init_corespec(void)
|
{
|
sigset_t set;
|
|
sigemptyset(&set);
|
sigaddset(&set, SIGALRM);
|
pthread_sigmask(SIG_BLOCK, &set, NULL);
|
}
|
|
#endif /* CONFIG_XENO_MERCURY */
|
|
/*
|
* XXX: at some point, we may consider using a timer wheel instead of
|
* a simple linked list to index timers. The latter method is
|
* efficient for up to ten outstanding timers or so, which should be
|
* enough for most applications. However, there exist poorly designed
|
* apps involving dozens of active timers, particularly in the legacy
|
* embedded world.
|
*/
|
static void timerobj_enqueue(struct timerobj *tmobj)
|
{
|
struct timerobj *__tmobj;
|
|
if (pvlist_empty(&svtimers)) {
|
pvlist_append(&tmobj->next, &svtimers);
|
return;
|
}
|
|
pvlist_for_each_entry_reverse(__tmobj, &svtimers, next) {
|
if (timespec_before_or_same(&__tmobj->itspec.it_value,
|
&tmobj->itspec.it_value))
|
break;
|
}
|
|
atpvh(&__tmobj->next, &tmobj->next);
|
}
|
|
static int server_prologue(void *arg)
|
{
|
svpid = get_thread_pid();
|
copperplate_set_current_name("timer-internal");
|
timersv_init_corespec();
|
threadobj_set_current(THREADOBJ_IRQCONTEXT);
|
|
return 0;
|
}
|
|
static void *timerobj_server(void *arg)
|
{
|
void (*handler)(struct timerobj *tmobj);
|
struct timespec now, value, interval;
|
struct timerobj *tmobj;
|
sigset_t set;
|
int sig, ret;
|
|
sigemptyset(&set);
|
sigaddset(&set, SIGALRM);
|
|
for (;;) {
|
ret = __RT(sigwait(&set, &sig));
|
if (ret && ret != -EINTR)
|
break;
|
/*
|
* We have a single server thread for now, so handlers
|
* are fully serialized.
|
*/
|
write_lock_nocancel(&svlock);
|
|
__RT(clock_gettime(CLOCK_COPPERPLATE, &now));
|
|
while (!pvlist_empty(&svtimers)) {
|
tmobj = pvlist_first_entry(&svtimers, typeof(*tmobj),
|
next);
|
|
value = tmobj->itspec.it_value;
|
interval = tmobj->itspec.it_interval;
|
handler = tmobj->handler;
|
if (timespec_after(&value, &now))
|
break;
|
pvlist_remove_init(&tmobj->next);
|
if (interval.tv_sec > 0 || interval.tv_nsec > 0) {
|
timespec_add(&tmobj->itspec.it_value,
|
&value, &interval);
|
timerobj_enqueue(tmobj);
|
}
|
write_unlock(&svlock);
|
handler(tmobj);
|
write_lock_nocancel(&svlock);
|
}
|
|
write_unlock(&svlock);
|
}
|
|
return NULL;
|
}
|
|
static void timerobj_spawn_server(void)
|
{
|
struct corethread_attributes cta;
|
|
cta.policy = SCHED_CORE;
|
cta.param_ex.sched_priority = threadobj_irq_prio;
|
cta.prologue = server_prologue;
|
cta.run = timerobj_server;
|
cta.arg = NULL;
|
cta.stacksize = PTHREAD_STACK_DEFAULT;
|
cta.detachstate = PTHREAD_CREATE_DETACHED;
|
|
__bt(copperplate_create_thread(&cta, &svthread));
|
}
|
|
int timerobj_init(struct timerobj *tmobj)
|
{
|
static pthread_once_t spawn_once;
|
pthread_mutexattr_t mattr;
|
struct sigevent sev;
|
int ret;
|
|
/*
|
* XXX: We need a threaded handler so that we may invoke core
|
* async-unsafe services from there (e.g. syncobj post
|
* routines are not async-safe, but the higher layers may
|
* invoke them from a timer handler).
|
*
|
* We don't rely on glibc's SIGEV_THREAD feature, because it
|
* is unreliable with some glibc releases (2.4 -> 2.9 at the
|
* very least), and spawning a short-lived thread at each
|
* timeout expiration to run the handler is just overkill.
|
*/
|
pthread_once(&spawn_once, timerobj_spawn_server);
|
if (!svthread)
|
return __bt(-EAGAIN);
|
|
tmobj->handler = NULL;
|
pvholder_init(&tmobj->next); /* so we may use pvholder_linked() */
|
|
memset(&sev, 0, sizeof(sev));
|
sev.sigev_notify = SIGEV_THREAD_ID;
|
sev.sigev_signo = SIGALRM;
|
sev.sigev_notify_thread_id = svpid;
|
|
ret = __RT(timer_create(CLOCK_COPPERPLATE, &sev, &tmobj->timer));
|
if (ret)
|
return __bt(-errno);
|
|
pthread_mutexattr_init(&mattr);
|
pthread_mutexattr_settype(&mattr, mutex_type_attribute);
|
pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
|
ret = pthread_mutexattr_setpshared(&mattr, mutex_scope_attribute);
|
assert(ret == 0);
|
ret = __bt(-__RT(pthread_mutex_init(&tmobj->lock, &mattr)));
|
pthread_mutexattr_destroy(&mattr);
|
|
return ret;
|
}
|
|
void timerobj_destroy(struct timerobj *tmobj) /* lock held, dropped */
|
{
|
write_lock_nocancel(&svlock);
|
|
if (pvholder_linked(&tmobj->next))
|
pvlist_remove_init(&tmobj->next);
|
|
write_unlock(&svlock);
|
|
__RT(timer_delete(tmobj->timer));
|
__RT(pthread_mutex_unlock(&tmobj->lock));
|
__RT(pthread_mutex_destroy(&tmobj->lock));
|
}
|
|
int timerobj_start(struct timerobj *tmobj,
|
void (*handler)(struct timerobj *tmobj),
|
struct itimerspec *it) /* lock held, dropped */
|
{
|
int ret = 0;
|
|
/*
|
* We hold the queue lock long enough to prevent the timer
|
* from being dequeued by the carrier thread before it has
|
* been armed, e.g. the user handler might destroy it under
|
* our feet if so, causing timer_settime() to fail, which
|
* would in turn lead to a double-deletion if the caller
|
* happens to check the return code then drop the timer
|
* (again).
|
*/
|
write_lock_nocancel(&svlock);
|
|
if (pvholder_linked(&tmobj->next))
|
pvlist_remove_init(&tmobj->next);
|
|
tmobj->handler = handler;
|
tmobj->itspec = *it;
|
|
if (__RT(timer_settime(tmobj->timer, TIMER_ABSTIME, it, NULL))) {
|
ret = __bt(-errno);
|
goto fail;
|
}
|
|
timerobj_enqueue(tmobj);
|
fail:
|
write_unlock(&svlock);
|
timerobj_unlock(tmobj);
|
|
return ret;
|
}
|
|
int timerobj_stop(struct timerobj *tmobj) /* lock held, dropped */
|
{
|
static const struct itimerspec itimer_stop;
|
|
write_lock_nocancel(&svlock);
|
|
if (pvholder_linked(&tmobj->next))
|
pvlist_remove_init(&tmobj->next);
|
|
__RT(timer_settime(tmobj->timer, 0, &itimer_stop, NULL));
|
tmobj->handler = NULL;
|
write_unlock(&svlock);
|
timerobj_unlock(tmobj);
|
|
return 0;
|
}
|
|
int timerobj_pkg_init(void)
|
{
|
pthread_mutexattr_t mattr;
|
int ret;
|
|
pthread_mutexattr_init(&mattr);
|
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
|
pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
|
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
|
ret = __bt(-__RT(pthread_mutex_init(&svlock, &mattr)));
|
pthread_mutexattr_destroy(&mattr);
|
|
return ret;
|
}
|
