wakeup/sleep handoff.

Is there a need to be able to somehow implement a 'wakeup_one()' that
as part of its semantic is that the woken thread will run immediatly, 
(as in preemprion),
and the old thread will sleep? With preemption, the old thread is left 
in the run queue,
and after the other thread has completed, it will
run again and probably go away and sleep for some reason.. (or at least 
go do some work that isn't
necessarily required..)

Something like handover(wakeupchan, sleepchan, msleep_args...).
 sort of an atomic wakeup/msleep.

This would be used in places where work used to be done by the same 
thread, but is now done
by a server thread..

An example would be kicking off a geom thread, when in the past we would 
have gone all
the way down to the hardware ourself. we want to get as close to acting 
like we are still
going all the way done as we can (performance wise). We may get some 
efficiency by
letting the sleep system, and scheduler know what we are trying to do. 
Possibly with some
priority inherritance implications.. (if we have a high priority, we 
probably want to ensure that the
worker thread is run with at least that priority.)