--- old/usr/src/uts/common/os/ddi_timer.c	Wed Jul 24 19:01:29 2013
+++ /dev/null	Wed Jul 24 19:01:29 2013
@@ -1,901 +0,0 @@
-/*
- * 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/atomic.h>
-#include <sys/callb.h>
-#include <sys/conf.h>
-#include <sys/cmn_err.h>
-#include <sys/taskq.h>
-#include <sys/dditypes.h>
-#include <sys/ddi_timer.h>
-#include <sys/disp.h>
-#include <sys/kobj.h>
-#include <sys/note.h>
-#include <sys/param.h>
-#include <sys/sysmacros.h>
-#include <sys/systm.h>
-#include <sys/time.h>
-#include <sys/types.h>
-
-/*
- * global variables for timeout request
- */
-static kmem_cache_t *req_cache;		/* kmem cache for timeout request */
-
-/*
- * taskq parameters for cyclic_timer
- *
- * timer_taskq_num:
- * timer_taskq_num represents the number of taskq threads.
- * Currently 4 threads are pooled to handle periodic timeout requests.
- * This number is chosen based on the fact that the callout (one-time
- * timeout framework) uses 8 threads with TQ_NOSLEEP; the periodic timeout
- * calls taskq_dispatch() with TQ_SLEEP instead, and in this case, 4 threads
- * should be sufficient to handle periodic timeout requests. (see also
- * timer_taskq_max_num below)
- *
- * timer_taskq_min_num:
- * timer_taskq_min_num represents the number of pre-populated taskq_ent
- * structures, and this variable holds the same value as timer_taskq_num does.
- *
- * timer_taskq_max_num:
- * Since TQ_SLEEP is set when taskq_dispatch() is called, the framework waits
- * for one second if more taskq_ent structures than timer_taskq_max_num are
- * required. However, from the timeout point of view, one second is much longer
- * than expected, and to prevent this occurrence, timer_taskq_max_num should
- * hold a sufficiently-large value, which is 128 here. Note that since the size
- * of taskq_ent_t is relatively small, this doesn't use up the resource so much.
- * (Currently the size is less than 8k at most)
- *
- * About the detailed explanation of the taskq function arguments, please see
- * usr/src/uts/common/os/taskq.c.
- */
-int timer_taskq_num = 4;		/* taskq thread number */
-int timer_taskq_min_num = 4;		/* min. number of taskq_ent structs */
-int timer_taskq_max_num = 128;		/* max. number of taskq_ent structs */
-static taskq_t *tm_taskq;		/* taskq thread pool */
-static kthread_t *tm_work_thread;	/* work thread invoking taskq */
-
-/*
- * timer variables
- */
-static cyc_timer_t *ddi_timer;		/* ddi timer based on the cyclic */
-static volatile hrtime_t timer_hrtime;	/* current tick time on the timer */
-
-/*
- * Variable used for the suspend/resume.
- */
-static volatile boolean_t timer_suspended;
-
-/*
- * Kernel taskq queue to ddi timer
- */
-static list_t kern_queue;	/* kernel thread request queue */
-static kcondvar_t kern_cv;	/* condition variable for taskq queue */
-
-/*
- * Software interrupt queue dedicated to ddi timer
- */
-static list_t intr_queue;	/* software interrupt request queue */
-static uint_t intr_state;	/* software interrupt state */
-
-/*
- * This lock is used to protect the intr_queue and kern_queue.
- * It's also used to protect the intr_state which represents the software
- * interrupt state for the timer.
- */
-static kmutex_t	disp_req_lock;
-
-/*
- * the periodic timer interrupt priority level
- */
-enum {
-	TM_IPL_0 = 0,			/* kernel context */
-	TM_IPL_1, TM_IPL_2, TM_IPL_3,	/* level 1-3 */
-	TM_IPL_4, TM_IPL_5, TM_IPL_6,	/* level 4-6 */
-	TM_IPL_7, TM_IPL_8, TM_IPL_9,	/* level 7-9 */
-	TM_IPL_10			/* level 10 */
-};
-
-/*
- * A callback handler used by CPR to stop and resume callouts.
- * Since the taskq uses TASKQ_CPR_SAFE, the function just set the boolean
- * flag to timer_suspended here.
- */
-/*ARGSUSED*/
-static boolean_t
-timer_cpr_callb(void *arg, int code)
-{
-	timer_suspended = (code == CB_CODE_CPR_CHKPT);
-	return (B_TRUE);
-}
-
-/*
- * Return a proposed timeout request id. add_req() determines whether
- * or not the proposed one is used. If it's not suitable, add_req()
- * recalls get_req_cnt(). To reduce the lock contention between the
- * timer and i_untimeout(), the atomic instruction should be used here.
- */
-static timeout_t
-get_req_cnt(void)
-{
-	static volatile ulong_t timeout_cnt = 0;
-	return ((timeout_t)atomic_inc_ulong_nv(&timeout_cnt));
-}
-
-/*
- * Get the system resolution.
- * Note. currently there is a restriction about the system resolution, and
- * the 10ms tick (the default clock resolution) is only supported now.
- */
-static hrtime_t
-i_get_res(void)
-{
-	return ((hrtime_t)10000000); /* 10ms tick only */
-}
-
-/*
- * Return the value for the cog of the timing wheel.
- * TICK_FACTOR is used to gain a finer cog on the clock resolution.
- */
-static hrtime_t
-tw_tick(hrtime_t time)
-{
-	return ((time << TICK_FACTOR) / ddi_timer->res);
-}
-
-/*
- * Calculate the expiration time for the timeout request.
- */
-static hrtime_t
-expire_tick(tm_req_t *req)
-{
-	return (tw_tick(req->exp_time));
-}
-
-/*
- * Register a timeout request to the timer. This function is used
- * in i_timeout().
- */
-static timeout_t
-add_req(tm_req_t *req)
-{
-	timer_tw_t *tid, *tw;
-	tm_req_t *next;
-	timeout_t id;
-
-retry:
-	/*
-	 * Retrieve a timeout request id. Since i_timeout() needs to return
-	 * a non-zero value, re-try if the zero is gotten.
-	 */
-	if ((id = get_req_cnt()) == 0)
-		id = get_req_cnt();
-
-	/*
-	 * Check if the id is not used yet. Since the framework now deals
-	 * with the periodic timeout requests, we cannot assume the id
-	 * allocated (long) before doesn't exist any more when it will
-	 * be re-assigned again (especially on 32bit) but need to handle
-	 * this case to solve the conflicts. If it's used already, retry
-	 * another.
-	 */
-	tid = &ddi_timer->idhash[TM_HASH((uintptr_t)id)];
-	mutex_enter(&tid->lock);
-	for (next = list_head(&tid->req); next != NULL;
-	    next = list_next(&tid->req, next)) {
-		if (next->id == id) {
-			mutex_exit(&tid->lock);
-			goto retry;
-		}
-	}
-	/* Nobody uses this id yet */
-	req->id = id;
-
-	/*
-	 * Register this request to the timer.
-	 * The list operation must be list_insert_head().
-	 * Other operations can degrade performance.
-	 */
-	list_insert_head(&tid->req, req);
-	mutex_exit(&tid->lock);
-
-	tw = &ddi_timer->exhash[TM_HASH(expire_tick(req))];
-	mutex_enter(&tw->lock);
-	/*
-	 * Other operations than list_insert_head() can
-	 * degrade performance here.
-	 */
-	list_insert_head(&tw->req, req);
-	mutex_exit(&tw->lock);
-
-	return (id);
-}
-
-/*
- * Periodic timeout requests cannot be removed until they are canceled
- * explicitly. Until then, they need to be re-registerd after they are
- * fired. transfer_req() re-registers the requests for the next fires.
- * Note. transfer_req() sends the cv_signal to timeout_execute(), which
- * runs in interrupt context. Make sure this function will not be blocked,
- * otherwise the deadlock situation can occur.
- */
-static void
-transfer_req(tm_req_t *req, timer_tw_t *tw)
-{
-	timer_tw_t *new_tw;
-	hrtime_t curr_time;
-	ASSERT(tw && MUTEX_HELD(&tw->lock));
-
-	/* Calculate the next expiration time by interval */
-	req->exp_time += req->interval;
-	curr_time = gethrtime();
-
-	/*
-	 * If a long time (more than 1 clock resolution) has already
-	 * passed for some reason (e.g. debugger or high interrupt),
-	 * round up the next expiration to the appropriate one
-	 * since this request is periodic and never catches with it.
-	 */
-	if (curr_time - req->exp_time >= ddi_timer->res) {
-		req->exp_time = roundup(curr_time + req->interval,
-		    ddi_timer->res);
-	}
-
-	/*
-	 * Re-register this request.
-	 * Note. since it is guaranteed that the timer is invoked on only
-	 * one CPU at any time (by the cyclic subsystem), a deadlock
-	 * cannot occur regardless of the lock order here.
-	 */
-	new_tw = &ddi_timer->exhash[TM_HASH(expire_tick(req))];
-
-	/*
-	 * If it's on the timer cog already, there is nothing
-	 * to do. Just return.
-	 */
-	if (new_tw == tw)
-		return;
-
-	/* Remove this request from the timer */
-	list_remove(&tw->req, req);
-
-	/* Re-register this request to the timer */
-	mutex_enter(&new_tw->lock);
-
-	/*
-	 * Other operations than list_insert_head() can
-	 * degrade performance here.
-	 */
-	list_insert_head(&new_tw->req, req);
-	mutex_exit(&new_tw->lock);
-
-	/*
-	 * Set the TM_TRANSFER flag and notify the request is transfered
-	 * completely. This prevents a race in the case that this request
-	 * is serviced on another CPU already.
-	 */
-	mutex_enter(&req->lock);
-	req->flags |= TM_TRANSFER;
-	cv_signal(&req->cv);
-	mutex_exit(&req->lock);
-}
-
-/*
- * Execute timeout requests.
- * Note. since timeout_execute() can run in interrupt context and block
- * on condition variables, there are restrictions on the timer code that
- * signals these condition variables (see i_untimeout(), transfer_req(),
- * and condvar(9F)). Functions that signal these cvs must ensure that
- * they will not be blocked (for memory allocations or any other reason)
- * since condition variables don't support priority inheritance.
- */
-static void
-timeout_execute(void *arg)
-{
-	tm_req_t *req = (tm_req_t *)arg;
-	ASSERT(req->flags & TM_INVOKING && !(req->flags & TM_EXECUTING));
-
-	for (;;) {
-		/*
-		 * Check if this request is canceled. If it's canceled, do not
-		 * execute this request.
-		 */
-		mutex_enter(&req->lock);
-		if (!(req->flags & TM_CANCEL)) {
-			/*
-			 * Set the current thread to prevent a dead lock
-			 * situation in case that this timeout request is
-			 * canceled in the handler being invoked now.
-			 * (this doesn't violate the spec) Set TM_EXECUTING
-			 * to show this handler is invoked soon.
-			 */
-			req->h_thread = curthread;
-			req->flags |= TM_EXECUTING;
-			mutex_exit(&req->lock);
-
-			/* The handler is invoked without holding any locks */
-			(*req->handler)(req->arg);
-
-			mutex_enter(&req->lock);
-		}
-
-		/*
-		 * Check if this request is canceled or not. If not, prepare
-		 * for the next fire.
-		 */
-		if (req->flags & TM_CANCEL) {
-			timer_tw_t *tw;
-			/*
-			 * Wait until the timer finishes all things for
-			 * this request.
-			 */
-			while (!(req->flags & TM_TRANSFER))
-				cv_wait(&req->cv, &req->lock);
-			mutex_exit(&req->lock);
-			ASSERT(req->flags & TM_TRANSFER);
-
-			/* Remove this request from the timer */
-			tw = &ddi_timer->exhash[TM_HASH(expire_tick(req))];
-			mutex_enter(&tw->lock);
-			list_remove(&tw->req, req);
-			mutex_exit(&tw->lock);
-
-			/* Free this request */
-			kmem_cache_free(req_cache, req);
-			return;
-		}
-		ASSERT(req->flags & TM_EXECUTING);
-
-		/*
-		 * TM_EXECUTING must be set at this point.
-		 * Unset the flag.
-		 */
-		req->flags &= ~(TM_EXECUTING | TM_TRANSFER);
-
-		/*
-		 * Decrease the request cnt. The reqest cnt shows
-		 * how many times this request is executed now.
-		 * If this counter becomes the zero, drop TM_INVOKING
-		 * to show there is no requests to do now.
-		 */
-		req->cnt--;
-		if (req->cnt == 0) {
-			req->flags &= ~TM_INVOKING;
-			mutex_exit(&req->lock);
-			return;
-		}
-		mutex_exit(&req->lock);
-	}
-}
-
-/*
- * Timeout worker thread for processing task queue.
- */
-static void
-timeout_taskq_thread(void *arg)
-{
-	_NOTE(ARGUNUSED(arg));
-	tm_req_t *kern_req;
-	callb_cpr_t cprinfo;
-
-	CALLB_CPR_INIT(&cprinfo, &disp_req_lock, callb_generic_cpr,
-	    "timeout_taskq_thread");
-
-	/*
-	 * This thread is wakened up when a new request is added to
-	 * the queue. Then pick up all requests and dispatch them
-	 * via taskq_dispatch().
-	 */
-	for (;;) {
-		/*
-		 * Check the queue and pick up a request if the queue
-		 * is not NULL.
-		 */
-		mutex_enter(&disp_req_lock);
-		while ((kern_req = list_head(&kern_queue)) == NULL) {
-			CALLB_CPR_SAFE_BEGIN(&cprinfo);
-			cv_wait(&kern_cv, &disp_req_lock);
-			CALLB_CPR_SAFE_END(&cprinfo, &disp_req_lock);
-		}
-		list_remove(&kern_queue, kern_req);
-		mutex_exit(&disp_req_lock);
-
-		/* Execute the timeout request via the taskq thread */
-		(void) taskq_dispatch(tm_taskq, timeout_execute,
-		    (void *)kern_req, TQ_SLEEP);
-	}
-}
-
-/*
- * Dispatch the timeout request based on the level specified.
- * If the level is equal to zero, notify the worker thread to
- * call taskq_dispatch() in kernel context. If the level is bigger
- * than zero, add a software interrupt request to the queue and raise
- * the interrupt level to the specified one.
- */
-static void
-timeout_dispatch(tm_req_t *req)
-{
-	int level = req->level;
-	extern void sir_on(int);
-
-	if (level == TM_IPL_0) {
-		/* Add a new request to the tail */
-		mutex_enter(&disp_req_lock);
-		list_insert_tail(&kern_queue, req);
-		mutex_exit(&disp_req_lock);
-
-		/*
-		 * notify the worker thread that this request
-		 * is newly added to the queue.
-		 * Note. this cv_signal() can be called after the
-		 * mutex_lock.
-		 */
-		cv_signal(&kern_cv);
-	} else {
-		/* Add a new request to the tail */
-		mutex_enter(&disp_req_lock);
-		list_insert_tail(&intr_queue, req);
-
-		/* Issue the software interrupt */
-		if (intr_state & TM_INTR_START(level)) {
-			/*
-			 * timer_softintr() is already running; no need to
-			 * raise a siron. Due to lock protection of
-			 * the intr_queue and intr_state, we know that
-			 * timer_softintr() will see the new addition to
-			 * the intr_queue.
-			 */
-			mutex_exit(&disp_req_lock);
-		} else {
-			intr_state |= TM_INTR_SET(level);
-			mutex_exit(&disp_req_lock);
-
-			/* Raise an interrupt to execute timeout requests */
-			sir_on(level);
-		}
-	}
-}
-
-/*
- * Check the software interrupt queue and invoke requests at the specified
- * interrupt level.
- * Note that the queue may change during call so that the disp_req_lock
- * and the intr_state are used to protect it.
- * The software interrupts supported here are up to the level 10. Higher
- * than 10 interrupts cannot be supported.
- */
-void
-timer_softintr(int level)
-{
-	tm_req_t *intr_req;
-	ASSERT(level >= TM_IPL_1 && level <= TM_IPL_10);
-
-	/* Check if we are asked to process the softcall list */
-	mutex_enter(&disp_req_lock);
-	if (!(intr_state & TM_INTR_SET(level))) {
-		mutex_exit(&disp_req_lock);
-		return;
-	}
-
-	/* Notify this software interrupt request will be executed soon */
-	intr_state |= TM_INTR_START(level);
-	intr_state &= ~TM_INTR_SET(level);
-
-	/* loop the link until there is no requests */
-	for (intr_req = list_head(&intr_queue); intr_req != NULL;
-	    /* Nothing */) {
-
-		/* Check the interrupt level */
-		if (intr_req->level != level) {
-			intr_req = list_next(&intr_queue, intr_req);
-			continue;
-		}
-		list_remove(&intr_queue, intr_req);
-		mutex_exit(&disp_req_lock);
-
-		/* Execute the software interrupt request */
-		timeout_execute(intr_req);
-
-		mutex_enter(&disp_req_lock);
-		/* Restart the loop since new requests might be added */
-		intr_req = list_head(&intr_queue);
-	}
-
-	/* reset the interrupt state */
-	intr_state &= ~TM_INTR_START(level);
-	mutex_exit(&disp_req_lock);
-}
-
-/*
- *  void
- *  cyclic_timer(void)
- *
- *  Overview
- *   cyclic_timer() is a function invoked periodically by the cyclic
- *   subsystem.
- *
- *   The function calls timeout_invoke() with timeout requests whose
- *   expiration time is already reached.
- *
- *  Arguments
- *   Nothing
- *
- *  Return value
- *   Nothing
- */
-void
-cyclic_timer(void)
-{
-	tm_req_t *req;
-	timer_tw_t *tw;
-	hrtime_t curr_tick, curr;
-
-	/* If the system is suspended, just return */
-	if (timer_suspended)
-		return;
-
-	/* Get the current time */
-	timer_hrtime = ddi_timer->tick_time = curr = gethrtime();
-	curr_tick = tw_tick(ddi_timer->tick_time);
-
-restart:
-	/*
-	 * Check the timer cogs to see if there are timeout requests
-	 * who reach the expiration time. Call timeout_invoke() to execute
-	 * the requests, then.
-	 */
-	while (curr_tick >= ddi_timer->tick) {
-		tm_req_t *next;
-		tw = &ddi_timer->exhash[TM_HASH(ddi_timer->tick)];
-		mutex_enter(&tw->lock);
-		for (req = list_head(&tw->req); req != NULL; req = next) {
-			next = list_next(&tw->req, req);
-			/*
-			 * If this request is already obsolete, free
-			 * it here.
-			 */
-			if (req->flags & TM_UTMCOMP) {
-				/*
-				 * Remove this request from the timer,
-				 * then free it.
-				 */
-				list_remove(&tw->req, req);
-				kmem_cache_free(req_cache, req);
-			} else if (curr >= req->exp_time) {
-				mutex_enter(&req->lock);
-				/*
-				 * Check if this request is canceled, but not
-				 * being executed now.
-				 */
-				if (req->flags & TM_CANCEL &&
-				    !(req->flags & TM_INVOKING)) {
-					mutex_exit(&req->lock);
-					continue;
-				}
-				/*
-				 * Record how many times timeout_execute()
-				 * must be invoked.
-				 */
-				req->cnt++;
-				/*
-				 * Invoke timeout_execute() via taskq or
-				 * software interrupt.
-				 */
-				if (req->flags & TM_INVOKING) {
-					/*
-					 * If it's already invoked,
-					 * There is nothing to do.
-					 */
-					mutex_exit(&req->lock);
-				} else {
-					req->flags |= TM_INVOKING;
-					mutex_exit(&req->lock);
-					/*
-					 * Dispatch this timeout request.
-					 * timeout_dispatch() chooses either
-					 * a software interrupt or taskq thread
-					 * based on the level.
-					 */
-					timeout_dispatch(req);
-				}
-				/*
-				 * Periodic timeout requests must prepare for
-				 * the next fire.
-				 */
-				transfer_req(req, tw);
-			}
-		}
-		mutex_exit(&tw->lock);
-		ddi_timer->tick++;
-	}
-
-	/*
-	 * Check the current time. If we spend some amount of time,
-	 * double-check if some of the requests reaches the expiration
-	 * time during the work.
-	 */
-	curr = gethrtime();
-	curr_tick = tw_tick(curr);
-	if (curr_tick >= ddi_timer->tick) {
-		ddi_timer->tick -= 1;
-		goto restart;
-	}
-	/* Adjustment for the next rolling */
-	ddi_timer->tick -= 1;
-}
-
-/*
- *  void
- *  timer_init(void)
- *
- *  Overview
- *    timer_init() allocates the internal data structures used by
- *    i_timeout(), i_untimeout() and the timer.
- *
- *  Arguments
- *    Nothing
- *
- *  Return value
- *    Nothing
- *
- *  Caller's context
- *    timer_init() can be called in kernel context only.
- */
-void
-timer_init(void)
-{
-	int i;
-
-	/* Create kmem_cache for timeout requests */
-	req_cache = kmem_cache_create("timeout_request", sizeof (tm_req_t),
-	    0, NULL, NULL, NULL, NULL, NULL, 0);
-
-	/* Initialize the timer which is invoked by the cyclic subsystem */
-	ddi_timer = kmem_alloc(sizeof (cyc_timer_t), KM_SLEEP);
-	ddi_timer->res = nsec_per_tick;
-	ddi_timer->tick = tw_tick(gethrtime());
-	ddi_timer->tick_time = 0;
-
-	/* Initialize the timing wheel */
-	bzero((char *)&ddi_timer->idhash[0], TM_HASH_SZ * sizeof (timer_tw_t));
-	bzero((char *)&ddi_timer->exhash[0], TM_HASH_SZ * sizeof (timer_tw_t));
-
-	for (i = 0; i < TM_HASH_SZ; i++) {
-		list_create(&ddi_timer->idhash[i].req, sizeof (tm_req_t),
-		    offsetof(tm_req_t, id_req));
-		mutex_init(&ddi_timer->idhash[i].lock, NULL, MUTEX_ADAPTIVE,
-		    NULL);
-
-		list_create(&ddi_timer->exhash[i].req, sizeof (tm_req_t),
-		    offsetof(tm_req_t, ex_req));
-		mutex_init(&ddi_timer->exhash[i].lock, NULL, MUTEX_ADAPTIVE,
-		    NULL);
-	}
-
-	/* Create a taskq thread pool */
-	tm_taskq = taskq_create_instance("timeout_taskq", 0,
-	    timer_taskq_num, MAXCLSYSPRI,
-	    timer_taskq_min_num, timer_taskq_max_num,
-	    TASKQ_PREPOPULATE | TASKQ_CPR_SAFE);
-
-	/*
-	 * Initialize the taskq queue which is dedicated to this timeout
-	 * interface/timer.
-	 */
-	list_create(&kern_queue, sizeof (tm_req_t),
-	    offsetof(tm_req_t, disp_req));
-
-	/* Create a worker thread to dispatch the taskq thread */
-	tm_work_thread = thread_create(NULL, 0, timeout_taskq_thread, NULL,
-	    0, &p0, TS_RUN, MAXCLSYSPRI);
-
-	/*
-	 * Initialize the software interrupt queue which is dedicated to
-	 * this timeout interface/timer.
-	 */
-	list_create(&intr_queue, sizeof (tm_req_t),
-	    offsetof(tm_req_t, disp_req));
-
-	/*
-	 * Initialize the mutex lock used for both of kern_queue and
-	 * intr_queue.
-	 */
-	mutex_init(&disp_req_lock, NULL, MUTEX_ADAPTIVE, NULL);
-	cv_init(&kern_cv, NULL, CV_DEFAULT, NULL);
-
-	/* Register the callback handler for the system suspend/resume */
-	(void) callb_add(timer_cpr_callb, 0, CB_CL_CPR_CALLOUT, "cyclicTimer");
-}
-
-/*
- *  timeout_t
- *  i_timeout(void (*func)(void *), void *arg,  hrtime_t interval,
- *      int level, int flags)
- *
- *  Overview
- *    i_timeout() is an internal function scheduling the passed function
- *    to be invoked in the interval in nanoseconds. The callback function
- *    keeps invoked until the request is explicitly canceled by i_untimeout().
- *    This function is used for ddi_periodic_add(9F).
- *
- *  Arguments
- *
- *    func: the callback function
- *          the callback function will be invoked in kernel context if
- *          the level passed is the zero. Otherwise be invoked in interrupt
- *          context at the specified level by the argument "level".
- *
- *          Note that It's guaranteed by the cyclic subsystem that the
- *          function is invoked on the only one CPU and is never executed
- *          simultaneously even on MP system.
- *
- *     arg: the argument passed to the callback function
- *
- * interval: interval time in nanoseconds
- *          if the interval is the zero, the timer resolution is used.
- *
- *  level : callback interrupt level
- *          If the value is 0 (the zero), the callback function is invoked
- *          in kernel context. If the value is more than 0 (the zero), but
- *          less than or equal to 10, the callback function is invoked in
- *          interrupt context at the specified interrupt level.
- *          This value must be in range of 0-10.
- *
- *  Return value
- *    returns a non-zero opaque value (timeout_t) on success.
- *
- *  Caller's context
- *    i_timeout() can be called in user or kernel context.
- */
-timeout_t
-i_timeout(void (*func)(void *), void *arg, hrtime_t interval, int level)
-{
-	hrtime_t start_time = gethrtime(), res;
-	tm_req_t *req = NULL;
-
-	/* Allocate and initialize the timeout request */
-	req = kmem_cache_alloc(req_cache, KM_SLEEP);
-	req->handler = func;
-	req->arg = arg;
-	req->h_thread = NULL;
-	req->level = level;
-	req->flags = 0;
-	req->cnt = 0;
-	mutex_init(&req->lock, NULL, MUTEX_ADAPTIVE, NULL);
-	cv_init(&req->cv, NULL, CV_DEFAULT, NULL);
-
-	/*
-	 * The resolution must be finer than or equal to
-	 * the requested interval. If it's not, set the resolution
-	 * to the interval.
-	 * Note. There is a restriction currently. Regardless of the
-	 * clock resolution used here, 10ms is set as the timer resolution.
-	 * Even on the 1ms resolution timer, the minimum interval is 10ms.
-	 */
-	if ((res = i_get_res()) > interval) {
-		uintptr_t pc = (uintptr_t)req->handler;
-		ulong_t off;
-		cmn_err(CE_WARN,
-		    "The periodic timeout (handler=%s, interval=%lld) "
-		    "requests a finer interval than the supported resolution. "
-		    "It rounds up to %lld\n", kobj_getsymname(pc, &off),
-		    interval, res);
-		interval = res;
-	}
-
-	/*
-	 * If the specified interval is already multiples of
-	 * the resolution, use it as is. Otherwise, it rounds
-	 * up to multiples of the timer resolution.
-	 */
-	req->interval = roundup(interval, i_get_res());
-
-	/*
-	 * For the periodic timeout requests, the first expiration time will
-	 * be adjusted to the timer tick edge to take advantage of the cyclic
-	 * subsystem. In that case, the first fire is likely not an expected
-	 * one, but the fires later can be more accurate due to this.
-	 */
-	req->exp_time = roundup(start_time + req->interval, i_get_res());
-
-	/* Add the request to the timer */
-	return (add_req(req));
-}
-
-/*
- *  void
- *  i_untimeout(timeout_t req)
- *
- *  Overview
- *    i_untimeout() is an internal function canceling the i_timeout()
- *    request previously issued.
- *    This function is used for ddi_periodic_delete(9F).
- *
- *  Argument
- *      req: timeout_t opaque value i_timeout() returned previously.
- *
- *  Return value
- *      Nothing.
- *
- *  Caller's context
- *    i_untimeout() can be called in user, kernel or interrupt context.
- *    It cannot be called in high interrupt context.
- *
- *  Note. This function is used by ddi_periodic_delete(), which cannot
- *  be called in interrupt context. As a result, this function is called
- *  in user or kernel context only in practice.
- */
-void
-i_untimeout(timeout_t timeout_req)
-{
-	timer_tw_t *tid;
-	tm_req_t *req;
-	timeout_t id;
-
-	/* Retrieve the id for this timeout request */
-	id = (timeout_t)timeout_req;
-	tid = &ddi_timer->idhash[TM_HASH((uintptr_t)id)];
-
-	mutex_enter(&tid->lock);
-	for (req = list_head(&tid->req); req != NULL;
-	    req = list_next(&tid->req, req)) {
-		if (req->id == id)
-			break;
-	}
-	if (req == NULL) {
-		/* There is no requests with this id after all */
-		mutex_exit(&tid->lock);
-		return;
-	}
-	mutex_enter(&req->lock);
-
-	/* Unregister this request first */
-	list_remove(&tid->req, req);
-
-	/* Notify that this request is canceled */
-	req->flags |= TM_CANCEL;
-
-	/* Check if the handler is invoked */
-	if (req->flags & TM_INVOKING) {
-		/*
-		 * This request will be removed by timeout_execute() later,
-		 * so that there is no extra thing to do any more.
-		 */
-		mutex_exit(&req->lock);
-		mutex_exit(&tid->lock);
-		return;
-	}
-	mutex_exit(&req->lock);
-	mutex_exit(&tid->lock);
-
-	/*
-	 * Notify untimeout() is about to be finished, and this request
-	 * can be freed.
-	 */
-	atomic_or_uint(&req->flags, TM_UTMCOMP);
-}
