man.bsd.lv manual page server

DESCRIPTION

The parameter ident is an arbitrary address that uniquely identifies the event on which the process is being asleep. All processes sleeping on a single ident are woken up later by wakeup(), often called from inside an interrupt routine, to indicate that the resource the process/thread was blocking on is available now.

The parameter wmesg is a string describing the sleep condition for tools like ps(1). Due to the limited space of those programs to display arbitrary strings, this message should not be longer than 6 characters.

The tsleep() function is general in its use and suspends the current process/thread until a wakeup is performed on the specified identifier. The process/thread will then be made runnable. The process/thread will sleep at most timo / hz seconds (0 means no timeout). If flags contains the PCATCH flag, signals are checked before and after sleeping, else signals are ignored.

The tsleep_interlock() function is similar to tsleep(), in that it queues a thread on a sleep queue, but it does not actually put the thread to sleep. This allows coupling tsleep with higher-level synchronization primitives. The pattern is:

(acquire high level synchronization primitive)
(test condition of interest)
tsleep_interlock(ident, flags)
(release high level synchronization primitive)
tsleep(..., flags | PINTERLOCKED, ...)

For example, to implement ssleep():

spin_lock(&important_lock);
if (important_condition == 0) {
	tsleep_interlock(ident, flags);
	spin_unlock(&important_lock);
	tsleep(..., flags | PINTERLOCKED, ...);
}

The ssleep() function works like tsleep() while at the same time releasing the exclusive spinlock spin before sleeping and reacquiring it before ssleep() returns. This is an atomic operation, which guarantees that a wakeup() interlocked by spin will not be missed.

The lksleep() function works like tsleep() while at the same time releasing the exclusive lockmgr lock lock before sleeping and reacquiring it before lksleep() returns. This is an atomic operation, which guarantees that a wakeup() interlocked by lock will not be missed.

The mtxsleep() function works like tsleep() while at the same time atomically releasing the mutex mtx before sleeping and reacquiring it in exclusive state before mtxsleep() returns.

The zsleep() function works like tsleep() while at the same time releasing the serializer slz before sleeping and reacquiring it before zsleep() returns. This is an atomic operation, which guarantees that a wakeup() interlocked by slz will not be missed.

The wakeup_one() function is used to make the first process/thread in the queue that is sleeping on the parameter ident runnable. This can prevent the system from becoming saturated when a large number of processes/threads are sleeping on the same address, but only one of them can actually do any useful work when made runnable.