/*
 * Copyright (C) 2005 Philippe Gerum <rpm@xenomai.org>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <linux/module.h>
#include <linux/cred.h>
#include <linux/err.h>
#include "internal.h"
#include "thread.h"
#include "timer.h"
#include "clock.h"
#include "signal.h"

void cobalt_timer_handler(struct xntimer *xntimer)
{
	struct cobalt_timer *timer;
	/*
	 * Deliver the timer notification via a signal (unless
	 * SIGEV_NONE was given). If we can't do this because the
	 * target thread disappeared, then stop the timer. It will go
	 * away when timer_delete() is called, or the owner's process
	 * exits, whichever comes first.
	 */
	timer = container_of(xntimer, struct cobalt_timer, timerbase);
	if (timer->sigp.si.si_signo &&
	    cobalt_signal_send_pid(timer->target, &timer->sigp) == -ESRCH)
		xntimer_stop(&timer->timerbase);
}
EXPORT_SYMBOL_GPL(cobalt_timer_handler);

static inline struct cobalt_thread *
timer_init(struct cobalt_timer *timer,
	   const struct sigevent *__restrict__ evp) /* nklocked, IRQs off. */
{
	struct cobalt_thread *owner = cobalt_current_thread(), *target = NULL;
	struct xnclock *clock;

	/*
	 * First, try to offload this operation to the extended
	 * personality the current thread might originate from.
	 */
	if (cobalt_initcall_extension(timer_init, &timer->extref,
				      owner, target, evp) && target)
		return target;

	/*
	 * Ok, we have no extension available, or we do but it does
	 * not want to overload the standard behavior: handle this
	 * timer the pure Cobalt way then.
	 */
	if (evp == NULL || evp->sigev_notify == SIGEV_NONE) {
		target = owner;	/* Assume SIGEV_THREAD_ID. */
		goto init;
	}

	if (evp->sigev_notify != SIGEV_THREAD_ID)
		return ERR_PTR(-EINVAL);

	/*
	 * Recipient thread must be a Xenomai shadow in user-space,
	 * living in the same process than our caller.
	 */
	target = cobalt_thread_find_local(evp->sigev_notify_thread_id);
	if (target == NULL)
		return ERR_PTR(-EINVAL);
init:
	clock = cobalt_clock_find(timer->clockid);
	if (IS_ERR(clock))
		return ERR_PTR(PTR_ERR(clock));

	xntimer_init(&timer->timerbase, clock, cobalt_timer_handler,
		     target->threadbase.sched, XNTIMER_UGRAVITY);

	return target;
}

static inline int timer_alloc_id(struct cobalt_process *cc)
{
	int id;

	id = find_first_bit(cc->timers_map, CONFIG_XENO_OPT_NRTIMERS);
	if (id == CONFIG_XENO_OPT_NRTIMERS)
		return -EAGAIN;

	__clear_bit(id, cc->timers_map);

	return id;
}

static inline void timer_free_id(struct cobalt_process *cc, int id)
{
	__set_bit(id, cc->timers_map);
}

struct cobalt_timer *
cobalt_timer_by_id(struct cobalt_process *cc, timer_t timer_id)
{
	if (timer_id < 0 || timer_id >= CONFIG_XENO_OPT_NRTIMERS)
		return NULL;

	if (test_bit(timer_id, cc->timers_map))
		return NULL;

	return cc->timers[timer_id];
}

static inline int timer_create(clockid_t clockid,
			       const struct sigevent *__restrict__ evp,
			       timer_t * __restrict__ timerid)
{
	struct cobalt_process *cc;
	struct cobalt_thread *target;
	struct cobalt_timer *timer;
	int signo, ret = -EINVAL;
	timer_t timer_id;
	spl_t s;

	cc = cobalt_current_process();
	if (cc == NULL)
		return -EPERM;

	timer = xnmalloc(sizeof(*timer));
	if (timer == NULL)
		return -ENOMEM;

	timer->sigp.si.si_errno = 0;
	timer->sigp.si.si_code = SI_TIMER;
	timer->sigp.si.si_overrun = 0;
	INIT_LIST_HEAD(&timer->sigp.next);
	timer->clockid = clockid;
	timer->overruns = 0;

	xnlock_get_irqsave(&nklock, s);

	ret = timer_alloc_id(cc);
	if (ret < 0)
		goto out;

	timer_id = ret;

	if (evp == NULL) {
		timer->sigp.si.si_int = timer_id;
		signo = SIGALRM;
	} else {
		if (evp->sigev_notify == SIGEV_NONE)
			signo = 0; /* Don't notify. */
		else {
			signo = evp->sigev_signo;
			if (signo < 1 || signo > _NSIG) {
				ret = -EINVAL;
				goto fail;
			}
			timer->sigp.si.si_value = evp->sigev_value;
		}
	}

	timer->sigp.si.si_signo = signo;
	timer->sigp.si.si_tid = timer_id;
	timer->id = timer_id;

	target = timer_init(timer, evp);
	if (target == NULL) {
		ret = -EPERM;
		goto fail;
	}

	if (IS_ERR(target)) {
		ret = PTR_ERR(target);
		goto fail;
	}

	timer->target = xnthread_host_pid(&target->threadbase);
	cc->timers[timer_id] = timer;

	xnlock_put_irqrestore(&nklock, s);

	*timerid = timer_id;

	return 0;
fail:
	timer_free_id(cc, timer_id);
out:
	xnlock_put_irqrestore(&nklock, s);

	xnfree(timer);

	return ret;
}

static void timer_cleanup(struct cobalt_process *p, struct cobalt_timer *timer)
{
	xntimer_destroy(&timer->timerbase);

	if (!list_empty(&timer->sigp.next))
		list_del(&timer->sigp.next);

	timer_free_id(p, cobalt_timer_id(timer));
	p->timers[cobalt_timer_id(timer)] = NULL;
}

static inline int
timer_delete(timer_t timerid)
{
	struct cobalt_process *cc;
	struct cobalt_timer *timer;
	int ret = 0;
	spl_t s;

	cc = cobalt_current_process();
	if (cc == NULL)
		return -EPERM;

	xnlock_get_irqsave(&nklock, s);

	timer = cobalt_timer_by_id(cc, timerid);
	if (timer == NULL) {
		xnlock_put_irqrestore(&nklock, s);
		return -EINVAL;
	}
	/*
	 * If an extension runs and actually handles the deletion, we
	 * should not call the timer_cleanup extension handler for
	 * this timer, but we shall destroy the core timer. If the
	 * handler returns on error, the whole deletion process is
	 * aborted, leaving the timer untouched. In all other cases,
	 * we do the core timer cleanup work, firing the timer_cleanup
	 * extension handler if defined.
	 */
  	if (cobalt_call_extension(timer_delete, &timer->extref, ret) && ret < 0)
		goto out;

	if (ret == 0)
		cobalt_call_extension(timer_cleanup, &timer->extref, ret);
	else
		ret = 0;

	timer_cleanup(cc, timer);
	xnlock_put_irqrestore(&nklock, s);
	xnfree(timer);

	return ret;

out:
	xnlock_put_irqrestore(&nklock, s);

	return ret;
}

void __cobalt_timer_getval(struct xntimer *__restrict__ timer,
			   struct itimerspec64 *__restrict__ value)
{
	ns2ts(&value->it_interval, xntimer_interval(timer));

	if (!xntimer_running_p(timer)) {
		value->it_value.tv_sec = 0;
		value->it_value.tv_nsec = 0;
	} else {
		ns2ts(&value->it_value, xntimer_get_timeout(timer));
	}
}

static inline void
timer_gettimeout(struct cobalt_timer *__restrict__ timer,
		 struct itimerspec64 *__restrict__ value)
{
	int ret = 0;

	if (cobalt_call_extension(timer_gettime, &timer->extref,
				  ret, value) && ret != 0)
		return;

	__cobalt_timer_getval(&timer->timerbase, value);
}

int __cobalt_timer_setval(struct xntimer *__restrict__ timer, int clock_flag,
			  const struct itimerspec64 *__restrict__ value)
{
	xnticks_t start, period;

	if (value->it_value.tv_nsec == 0 && value->it_value.tv_sec == 0) {
		xntimer_stop(timer);
		return 0;
	}

	if ((unsigned long)value->it_value.tv_nsec >= ONE_BILLION ||
	    ((unsigned long)value->it_interval.tv_nsec >= ONE_BILLION &&
	     (value->it_value.tv_sec != 0 || value->it_value.tv_nsec != 0)))
		return -EINVAL;

	start = ts2ns(&value->it_value) + 1;
	period = ts2ns(&value->it_interval);

	/*
	 * Now start the timer. If the timeout data has already
	 * passed, the caller will handle the case.
	 */
	return xntimer_start(timer, start, period, clock_flag);
}

static inline int timer_set(struct cobalt_timer *timer, int flags,
			    const struct itimerspec64 *__restrict__ value)
{				/* nklocked, IRQs off. */
	struct cobalt_thread *thread;
	int ret = 0;

	/* First, try offloading the work to an extension. */

	if (cobalt_call_extension(timer_settime, &timer->extref,
				  ret, value, flags) && ret != 0)
		return ret < 0 ? ret : 0;

	/*
	 * No extension, or operation not handled. Default to plain
	 * POSIX behavior.
	 *
	 * If the target thread vanished, just don't start the timer.
	 */
	thread = cobalt_thread_find(timer->target);
	if (thread == NULL)
		return 0;

	/*
	 * Make the timer affine to the CPU running the thread to be
	 * signaled if possible.
	 */
	xntimer_set_affinity(&timer->timerbase, thread->threadbase.sched);

	return __cobalt_timer_setval(&timer->timerbase,
				     clock_flag(flags, timer->clockid), value);
}

static inline void
timer_deliver_late(struct cobalt_process *cc, timer_t timerid)
{
	struct cobalt_timer *timer;
	spl_t s;

	xnlock_get_irqsave(&nklock, s);
	/*
	 * We dropped the lock shortly, revalidate the timer handle in
	 * case a deletion slipped in.
	 */
	timer = cobalt_timer_by_id(cc, timerid);
	if (timer)
		cobalt_timer_handler(&timer->timerbase);

	xnlock_put_irqrestore(&nklock, s);
}

int __cobalt_timer_settime(timer_t timerid, int flags,
			   const struct itimerspec64 *__restrict__ value,
			   struct itimerspec64 *__restrict__ ovalue)
{
	struct cobalt_timer *timer;
	struct cobalt_process *cc;
	int ret;
	spl_t s;

	cc = cobalt_current_process();
	XENO_BUG_ON(COBALT, cc == NULL);

	xnlock_get_irqsave(&nklock, s);

	timer = cobalt_timer_by_id(cc, timerid);
	if (timer == NULL) {
		ret = -EINVAL;
		goto out;
	}

	if (ovalue)
		timer_gettimeout(timer, ovalue);

	ret = timer_set(timer, flags, value);
	if (ret == -ETIMEDOUT) {
		/*
		 * Time has already passed, deliver a notification
		 * immediately. Since we are about to dive into the
		 * signal machinery for this, let's drop the nklock to
		 * break the atomic section temporarily.
		 */
		xnlock_put_irqrestore(&nklock, s);
		timer_deliver_late(cc, timerid);
		return 0;
	}
out:
	xnlock_put_irqrestore(&nklock, s);

	return ret;
}

int __cobalt_timer_gettime(timer_t timerid, struct itimerspec64 *value)
{
	struct cobalt_timer *timer;
	struct cobalt_process *cc;
	spl_t s;

	cc = cobalt_current_process();
	if (cc == NULL)
		return -EPERM;

	xnlock_get_irqsave(&nklock, s);

	timer = cobalt_timer_by_id(cc, timerid);
	if (timer == NULL)
		goto fail;

	timer_gettimeout(timer, value);

	xnlock_put_irqrestore(&nklock, s);

	return 0;
fail:
	xnlock_put_irqrestore(&nklock, s);

	return -EINVAL;
}

COBALT_SYSCALL(timer_delete, current, (timer_t timerid))
{
	return timer_delete(timerid);
}

int __cobalt_timer_create(clockid_t clock,
			  const struct sigevent *sev,
			  timer_t __user *u_tm)
{
	timer_t timerid = 0;
	int ret;

	ret = timer_create(clock, sev, &timerid);
	if (ret)
		return ret;

	if (cobalt_copy_to_user(u_tm, &timerid, sizeof(timerid))) {
		timer_delete(timerid);
		return -EFAULT;
	}

	return 0;
}

COBALT_SYSCALL(timer_create, current,
	       (clockid_t clock,
		const struct sigevent __user *u_sev,
		timer_t __user *u_tm))
{
	struct sigevent sev, *evp = NULL;

	if (u_sev) {
		evp = &sev;
		if (cobalt_copy_from_user(&sev, u_sev, sizeof(sev)))
			return -EFAULT;
	}

	return __cobalt_timer_create(clock, evp, u_tm);
}

COBALT_SYSCALL(timer_settime, primary,
	       (timer_t tm, int flags,
		const struct __user_old_itimerspec __user *u_newval,
		struct __user_old_itimerspec __user *u_oldval))
{
	struct itimerspec64 newv, oldv, *oldvp = &oldv;
	int ret;

	if (u_oldval == NULL)
		oldvp = NULL;

	if (cobalt_get_u_itimerspec(&newv, u_newval))
		return -EFAULT;

	ret = __cobalt_timer_settime(tm, flags, &newv, oldvp);
	if (ret)
		return ret;

	if (oldvp && cobalt_put_u_itimerspec(u_oldval, oldvp)) {
		__cobalt_timer_settime(tm, flags, oldvp, NULL);
		return -EFAULT;
	}

	return 0;
}

COBALT_SYSCALL(timer_gettime, current,
	       (timer_t tm, struct __user_old_itimerspec __user *u_val))
{
	struct itimerspec64 val;
	int ret;

	ret = __cobalt_timer_gettime(tm, &val);
	if (ret)
		return ret;

	return cobalt_put_u_itimerspec(u_val, &val);
}

COBALT_SYSCALL(timer_getoverrun, current, (timer_t timerid))
{
	struct cobalt_timer *timer;
	struct cobalt_process *cc;
	int overruns;
	spl_t s;

	cc = cobalt_current_process();
	if (cc == NULL)
		return -EPERM;

	xnlock_get_irqsave(&nklock, s);

	timer = cobalt_timer_by_id(cc, timerid);
	if (timer == NULL)
		goto fail;

	overruns = timer->overruns;

	xnlock_put_irqrestore(&nklock, s);

	return overruns;
fail:
	xnlock_put_irqrestore(&nklock, s);

	return -EINVAL;
}

int cobalt_timer_deliver(struct cobalt_thread *waiter, timer_t timerid) /* nklocked, IRQs off. */
{
	struct cobalt_timer *timer;
	xnticks_t now;

	timer = cobalt_timer_by_id(cobalt_current_process(), timerid);
	if (timer == NULL)
		/* Killed before ultimate delivery, who cares then? */
		return 0;

	if (!xntimer_periodic_p(&timer->timerbase))
		timer->overruns = 0;
	else {
		now = xnclock_read_raw(xntimer_clock(&timer->timerbase));
		timer->overruns = xntimer_get_overruns(&timer->timerbase,
					       &waiter->threadbase, now);
		if ((unsigned int)timer->overruns > COBALT_DELAYMAX)
			timer->overruns = COBALT_DELAYMAX;
	}

	return timer->overruns;
}

void cobalt_timer_reclaim(struct cobalt_process *p)
{
	struct cobalt_timer *timer;
	unsigned id;
	spl_t s;
	int ret;

	xnlock_get_irqsave(&nklock, s);

	if (find_first_zero_bit(p->timers_map, CONFIG_XENO_OPT_NRTIMERS) ==
		CONFIG_XENO_OPT_NRTIMERS)
		goto out;

	for (id = 0; id < ARRAY_SIZE(p->timers); id++) {
		timer = cobalt_timer_by_id(p, id);
		if (timer == NULL)
			continue;

		cobalt_call_extension(timer_cleanup, &timer->extref, ret);
		timer_cleanup(p, timer);
		xnlock_put_irqrestore(&nklock, s);
		xnfree(timer);
		xnlock_get_irqsave(&nklock, s);
	}
out:
	xnlock_put_irqrestore(&nklock, s);
}