/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/debug.h>
#include <sys/mutex.h>
#include <sys/atomic.h>
#include <sys/timer.h>
#include <sys/lwp_timer_impl.h>

/*
 * lwp_timer_timeout() is called from a timeout set up in lwp_cond_wait(),
 * lwp_mutex_timedlock(), lwp_sema_timedwait() or lwp_rwlock_lock().
 *
 * It recomputes the time remaining until the absolute time when the
 * wait is supposed to timeout and either calls realtime_timeout()
 * to reschedule itself or calls setrun() on the sleeping thread.
 *
 * This is done to ensure that the waiting thread does not wake up
 * due to timer expiration until the absolute future time of the
 * timeout has been reached.  Until that time, the thread must
 * remain on its sleep queue.
 *
 * An lwp_timer_t structure is used to pass information
 * about the sleeping thread to the timeout function.
 */

static void
lwp_timer_timeout(void *arg)
{
	lwp_timer_t *lwptp = arg;
	kthread_t *t = lwptp->lwpt_thread;
	timespec_t now;

	mutex_enter(&t->t_delay_lock);
	gethrestime(&now);
	/*
	 * Requeue the timeout if no one has reset the system time
	 * and if the absolute future time has not been reached.
	 */
	if (lwptp->lwpt_timecheck == timechanged &&
	    (lwptp->lwpt_rqtime.tv_sec > now.tv_sec ||
	    (lwptp->lwpt_rqtime.tv_sec == now.tv_sec &&
	    lwptp->lwpt_rqtime.tv_nsec > now.tv_nsec))) {
		lwptp->lwpt_imm_timeout = 0;
		lwptp->lwpt_id = realtime_timeout(lwp_timer_timeout, lwptp,
		    timespectohz(&lwptp->lwpt_rqtime, now));
	} else {
		/*
		 * Set the thread running only if it is asleep on
		 * its lwpchan sleep queue (not if it is asleep on
		 * the t_delay_lock mutex).
		 */
		thread_lock(t);
		/* do this for the benefit of upi mutexes */
		(void) atomic_cas_uint(&lwptp->lwpt_imm_timeout, 0, 1);
		if (t->t_state == TS_SLEEP &&
		    (t->t_flag & T_WAKEABLE) &&
		    t->t_wchan0 != NULL)
			setrun_locked(t);
		thread_unlock(t);
	}
	mutex_exit(&t->t_delay_lock);
}

int
lwp_timer_copyin(lwp_timer_t *lwptp, timespec_t *tsp)
{
	timespec_t now;
	int error = 0;

	if (tsp == NULL)	/* not really an error, just need to bzero() */
		goto err;
	lwptp->lwpt_timecheck = timechanged; /* do this before gethrestime() */
	gethrestime(&now);		/* do this before copyin() */
	if (curproc->p_model == DATAMODEL_NATIVE) {
		if (copyin(tsp, &lwptp->lwpt_rqtime, sizeof (timespec_t))) {
			error = EFAULT;
			goto err;
		}
	} else {
		timespec32_t ts32;
		if (copyin(tsp, &ts32, sizeof (timespec32_t))) {
			error = EFAULT;
			goto err;
		}
		TIMESPEC32_TO_TIMESPEC(&lwptp->lwpt_rqtime, &ts32);
	}
	if (itimerspecfix(&lwptp->lwpt_rqtime)) {
		error = EINVAL;
		goto err;
	}
	/*
	 * Unless the requested timeout is zero,
	 * get the precise future (absolute) time at
	 * which we are to time out and return ETIME.
	 * We must not return ETIME before that time.
	 */
	if (lwptp->lwpt_rqtime.tv_sec == 0 && lwptp->lwpt_rqtime.tv_nsec == 0) {
		bzero(lwptp, sizeof (lwp_timer_t));
		lwptp->lwpt_imm_timeout = 1;
	} else {
		lwptp->lwpt_thread = curthread;
		lwptp->lwpt_tsp = tsp;
		lwptp->lwpt_time_error = 0;
		lwptp->lwpt_id = 0;
		lwptp->lwpt_imm_timeout = 0;
		timespecadd(&lwptp->lwpt_rqtime, &now);
	}
	return (0);
err:
	bzero(lwptp, sizeof (lwp_timer_t));
	lwptp->lwpt_time_error = error;
	return (error);
}

int
lwp_timer_enqueue(lwp_timer_t *lwptp)
{
	timespec_t now;

	ASSERT(lwptp->lwpt_thread == curthread);
	ASSERT(MUTEX_HELD(&curthread->t_delay_lock));
	gethrestime(&now);
	if (lwptp->lwpt_timecheck == timechanged &&
	    (lwptp->lwpt_rqtime.tv_sec > now.tv_sec ||
	    (lwptp->lwpt_rqtime.tv_sec == now.tv_sec &&
	    lwptp->lwpt_rqtime.tv_nsec > now.tv_nsec))) {
		/*
		 * Queue the timeout.
		 */
		lwptp->lwpt_imm_timeout = 0;
		lwptp->lwpt_id = realtime_timeout(lwp_timer_timeout, lwptp,
		    timespectohz(&lwptp->lwpt_rqtime, now));
		return (0);
	}

	/*
	 * Time has already run out or someone reset the system time;
	 * just cause an immediate timeout.
	 */
	lwptp->lwpt_imm_timeout = 1;
	return (1);
}

clock_t
lwp_timer_dequeue(lwp_timer_t *lwptp)
{
	kthread_t *t = curthread;
	clock_t tim = -1;
	timeout_id_t tmp_id;

	mutex_enter(&t->t_delay_lock);
	while ((tmp_id = lwptp->lwpt_id) != 0) {
		lwptp->lwpt_id = 0;
		mutex_exit(&t->t_delay_lock);
		tim = untimeout(tmp_id);
		mutex_enter(&t->t_delay_lock);
	}
	mutex_exit(&t->t_delay_lock);
	return (tim);
}

int
lwp_timer_copyout(lwp_timer_t *lwptp, int error)
{
	timespec_t rmtime;
	timespec_t now;

	if (lwptp->lwpt_tsp == NULL)	/* nothing to do */
		return (error);

	rmtime.tv_sec = rmtime.tv_nsec = 0;
	if (error != ETIME) {
		gethrestime(&now);
		if ((now.tv_sec < lwptp->lwpt_rqtime.tv_sec) ||
		    ((now.tv_sec == lwptp->lwpt_rqtime.tv_sec) &&
		    (now.tv_nsec < lwptp->lwpt_rqtime.tv_nsec))) {
			rmtime = lwptp->lwpt_rqtime;
			timespecsub(&rmtime, &now);
		}
	}
	if (curproc->p_model == DATAMODEL_NATIVE) {
		if (copyout(&rmtime, lwptp->lwpt_tsp, sizeof (timespec_t)))
			error = EFAULT;
	} else {
		timespec32_t rmtime32;

		TIMESPEC_TO_TIMESPEC32(&rmtime32, &rmtime);
		if (copyout(&rmtime32, lwptp->lwpt_tsp, sizeof (timespec32_t)))
			error = EFAULT;
	}

	return (error);
}