lwp_timer.c revision 51b32bdd07bc63a6e416c5759f0f445147703107
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#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>
#include <sys/callo.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, delta;
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;
delta = lwptp->lwpt_rqtime;
timespecsub(&delta, &now);
lwptp->lwpt_id = timeout_generic(CALLOUT_REALTIME,
lwp_timer_timeout, lwptp, ts2hrt(&delta), nsec_per_tick,
(CALLOUT_FLAG_HRESTIME | CALLOUT_FLAG_ROUNDUP));
} 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, delta;
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;
delta = lwptp->lwpt_rqtime;
timespecsub(&delta, &now);
lwptp->lwpt_id = timeout_generic(CALLOUT_REALTIME,
lwp_timer_timeout, lwptp, ts2hrt(&delta), nsec_per_tick,
(CALLOUT_FLAG_HRESTIME | CALLOUT_FLAG_ROUNDUP));
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;
callout_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_default(tmp_id, 0);
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);
}