/*******************************************************************************

    Copyright(C) Jonas 'Sortie' Termansen 2013, 2014.

    This file is part of Sortix.

    Sortix 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 3 of the License, or (at your option) any later
    version.

    Sortix 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
    Sortix. If not, see <http://www.gnu.org/licenses/>.

    user-timer.cpp
    Timers that send signals when triggered.

*******************************************************************************/

#include <sys/types.h>

#include <errno.h>
#include <limits.h>
#include <timespec.h>

#include <sortix/clock.h>
#include <sortix/signal.h>
#include <sortix/sigevent.h>
#include <sortix/time.h>
#include <sortix/tmns.h>

#include <sortix/kernel/copy.h>
#include <sortix/kernel/interrupt.h>
#include <sortix/kernel/kernel.h>
#include <sortix/kernel/kthread.h>
#include <sortix/kernel/process.h>
#include <sortix/kernel/syscall.h>
#include <sortix/kernel/time.h>
#include <sortix/kernel/user-timer.h>

namespace Sortix {

// TODO: We also need to fetch the pthread attr if there is one.
static bool FetchSigevent(struct sigevent* dst, const struct sigevent* src)
{
	if ( src )
		return CopyFromUser(dst, src, sizeof(struct sigevent));
	dst->sigev_notify = SIGEV_SIGNAL;
	dst->sigev_signo = SIGALRM;
	// TODO: "and the sigev_value member having the value of the timer ID."
	//  - Does POSIX want the caller to be psychic and should we write back the
	//    final default sigevent?
	return true;
}

static UserTimer* LookupUserTimer(Process* process, timer_t timerid)
{
	if ( PROCESS_TIMER_NUM_MAX <= timerid )
		return errno = EINVAL, (UserTimer*) NULL;
	UserTimer* user_timer = &process->user_timers[timerid];
	if ( !user_timer->timer.IsAttached() )
		return errno = EINVAL, (UserTimer*) NULL;
	return user_timer;
}

static Timer* LookupTimer(Process* process, timer_t timerid)
{
	UserTimer* user_timer = LookupUserTimer(process, timerid);
	return user_timer ? &user_timer->timer : (Timer*) NULL;
}

static int sys_timer_create(clockid_t clockid, struct sigevent* sigevp,
                            timer_t* timerid_ptr)
{
	Process* process = CurrentProcess();
	ScopedLock lock(&process->user_timers_lock);

	Clock* clock = Time::GetClock(clockid);
	if ( !clock )
		return -1;

	struct sigevent sigev;
	if ( !FetchSigevent(&sigev, sigevp) )
		return -1;

	// Allocate a timer for this request.
	timer_t timerid;
	for ( timerid = 0; timerid < PROCESS_TIMER_NUM_MAX; timerid++ )
	{
		Timer* timer = &process->user_timers[timerid].timer;
		if ( timer->IsAttached() )
			continue;
		timer->Attach(clock);
		break;
	}

	if ( PROCESS_TIMER_NUM_MAX <= timerid )
		return -1;

	if ( !CopyToUser(timerid_ptr, &timerid, sizeof(timerid)) )
	{
		process->user_timers[timerid].timer.Detach();
		return -1;
	}

	process->user_timers[timerid].process = process;
	process->user_timers[timerid].event = sigev;
	process->user_timers[timerid].timerid = timerid;

	return 0;
}

static int sys_timer_delete(timer_t timerid)
{
	Process* process = CurrentProcess();
	ScopedLock lock(&process->user_timers_lock);

	Timer* timer = LookupTimer(process, timerid);
	if ( !timer )
		return -1;

	timer->Cancel();
	timer->Detach();

	return 0;
}

static int sys_timer_getoverrun(timer_t timerid)
{
	Process* process = CurrentProcess();
	ScopedLock lock(&process->user_timers_lock);

	Timer* timer = LookupTimer(process, timerid);
	if ( !timer )
		return -1;

	if ( (size_t) INT_MAX < timer->num_overrun_events)
		return INT_MAX;

	// TODO: How does the caller reset the overrun count back to 0? Should we
	//       adopt the Linux semantics where it resets back to 0 after INT_MAX?
	//       How about signed overflow in the kernel and in the user process?

	return 0;
}

static int sys_timer_gettime(timer_t timerid, struct itimerspec* user_value)
{
	Process* process = CurrentProcess();
	ScopedLock lock(&process->user_timers_lock);

	Timer* timer = LookupTimer(process, timerid);
	if ( !timer )
		return -1;

	struct itimerspec value;
	timer->Get(&value);

	return CopyToUser(user_value, &value, sizeof(value)) ? 0 : -1;
}

static void timer_callback(Clock* /*clock*/, Timer* timer, void* user)
{
	UserTimer* user_timer = (UserTimer*) user;
	Process* process = user_timer->process;
	ScopedLock lock(&process->user_timers_lock);

	// TODO: This delivery facility is insufficient! sigevent is much more
	//       powerful than sending a simple old-school signal.
	if ( !process->DeliverSignal(user_timer->event.sigev_signo) &&
	      errno == ESIGPENDING )
	{
		if ( timer->num_overrun_events < SIZE_MAX )
			timer->num_overrun_events++;
	}
}

static int sys_timer_settime(timer_t timerid, int flags,
                             const struct itimerspec* user_value,
                             struct itimerspec* user_ovalue)
{
	Process* process = CurrentProcess();
	ScopedLock lock(&process->user_timers_lock);

	UserTimer* user_timer = LookupUserTimer(process, timerid);
	if ( !user_timer )
		return -1;

	Timer* timer = &user_timer->timer;

	struct itimerspec value, ovalue;
	if ( !CopyFromUser(&value, user_value, sizeof(value)) )
		return -1;

	if ( timespec_lt(value.it_value, timespec_nul()) ||
	     timespec_lt(value.it_interval, timespec_nul()) ||
	     (flags & ~(TIMER_ABSTIME)) != 0 )
		return errno = EINVAL, -1;

	int timer_flags = 0;
	if ( flags & TIMER_ABSTIME )
		timer_flags |= TIMER_ABSOLUTE;

	timer->Set(&value, &ovalue, timer_flags, timer_callback, user_timer);

	// Let the caller know how much time was left on the timer.
	if ( user_ovalue && !CopyToUser(user_ovalue, &ovalue, sizeof(ovalue)) )
		return -1;

	return 0;
}

static int sys_clock_gettimeres(clockid_t clockid, struct timespec* time,
                                                   struct timespec* res)
{
	Clock* clock = Time::GetClock(clockid);
	if ( !clock )
		return -1;

	struct timespec ktime, kres;
	clock->Get(&ktime, &kres);

	return (!time || CopyToUser(time, &ktime, sizeof(ktime))) &&
	       (!res || CopyToUser(res, &kres, sizeof(kres))) ? 0 : -1;
}

static int sys_clock_settimeres(clockid_t clockid, const struct timespec* time,
                                                   const struct timespec* res)
{
	Clock* clock = Time::GetClock(clockid);
	if ( !clock )
		return -1;

	struct timespec ktime, kres;
	if ( (time && !CopyFromUser(&ktime, time, sizeof(ktime))) ||
	     (res && !CopyFromUser(&kres, res, sizeof(kres))) )
		return -1;

	clock->Set(time ? &ktime : NULL, res ? &kres : NULL);

	return 0;
}

static int sys_clock_nanosleep(clockid_t clockid, int flags,
                               const struct timespec* user_duration,
                               struct timespec* user_remainder)
{
	struct timespec time;

	Clock* clock = Time::GetClock(clockid);
	if ( !clock )
		return -1;

	if ( !CopyFromUser(&time, user_duration, sizeof(time)) )
		return -1;

	time = flags & TIMER_ABSTIME ? clock->SleepUntil(time) :
	                               clock->SleepDelay(time);

	if ( user_remainder && !CopyToUser(user_remainder, &time, sizeof(time)) )
		return -1;

	return timespec_eq(time, timespec_nul()) ? 0 : (errno = EINTR, -1);
}

static int sys_timens(struct tmns* user_tmns)
{
	Clock* execute_clock = Time::GetClock(CLOCK_PROCESS_CPUTIME_ID);
	Clock* system_clock = Time::GetClock(CLOCK_PROCESS_SYSTIME_ID);
	Clock* child_execute_clock = Time::GetClock(CLOCK_CHILD_CPUTIME_ID);
	Clock* child_system_clock = Time::GetClock(CLOCK_CHILD_SYSTIME_ID);

	// Note: It is safe to access the clocks in this manner as each of them are
	//       locked by disabling interrupts. This is perhaps not SMP-ready, but
	//       it will do for now.
	struct tmns tmns;
	Interrupt::Disable();
	tmns.tmns_utime = execute_clock->current_time;
	tmns.tmns_stime = system_clock->current_time;
	tmns.tmns_cutime = child_execute_clock->current_time;
	tmns.tmns_cstime = child_system_clock->current_time;
	Interrupt::Enable();

	return CopyToUser(user_tmns, &tmns, sizeof(tmns)) ? 0 : -1;
}

void UserTimer::Init()
{
	Syscall::Register(SYSCALL_CLOCK_GETTIMERES, (void*) sys_clock_gettimeres);
	Syscall::Register(SYSCALL_CLOCK_NANOSLEEP, (void*) sys_clock_nanosleep);
	Syscall::Register(SYSCALL_CLOCK_SETTIMERES, (void*) sys_clock_settimeres);
	Syscall::Register(SYSCALL_TIMENS, (void*) sys_timens);
	Syscall::Register(SYSCALL_TIMER_CREATE, (void*) sys_timer_create);
	Syscall::Register(SYSCALL_TIMER_DELETE, (void*) sys_timer_delete);
	Syscall::Register(SYSCALL_TIMER_GETOVERRUN, (void*) sys_timer_getoverrun);
	Syscall::Register(SYSCALL_TIMER_GETTIME, (void*) sys_timer_gettime);
	Syscall::Register(SYSCALL_TIMER_SETTIME, (void*) sys_timer_settime);
}

} // namespace Sortix