mpsleep(9r) [osf1 man page]
mpsleep(9r) mpsleep(9r) NAME
mpsleep - General: Blocks the current kernel thread SYNOPSIS
int mpsleep( caddr_t channel, long pri, char *wmesg, long timo, void *lockp, long flags ); ARGUMENTS
Specifies an address associated with the calling kernel thread to be blocked. Can specify the following values: When set, specifies that the sleep request is interruptible. That is, the kernel thread can take asynchronous signals. Not setting the PCATCH flag causes the process to sleep in an uninterruptible state. When set, specifies that the process can be asynchronously suspended while waiting. On the operating system you cannot use pri to set the scheduling priority of the calling process. Specifies a mnemonic for the type of wait. The ps command uses this mnemonic in its messages about the process. Specifies the maximum amount of time the kernel thread should block. The kernel thread blocks a maximum of timo divided by hz seconds. If you pass the value 0 (zero), mpsleep assumes there is no timeout. Specifies a pointer to a lock structure that you want to unlock before the process sleeps. If you do not want to release a lock, pass the value 0 (zero). Specifies the lock type of the lockp argument and how to handle the lock after blocking. You can specify one of the following valid lock types, defined in the <param.h> file: Calls mpsleep with a simple lock asserted. Calls mpsleep with a read-only lock asserted on entry. Calls mpsleep with a write lock asserted. In addition, you can specify one of the following ways to handle the lock after blocking: Forces mpsleep to relock the lock on fail- ure. Forces mpsleep not to relock after blocking. DESCRIPTION
The mpsleep routine blocks (puts to sleep) the current kernel thread until a wakeup is issued on the address you specify in the channel argument. This routine is the symmetric multiprocessor (SMP) sleep call. The kernel thread blocks a maximum of timo divided by hz seconds. The value0 (zero) means there is no timeout. If you pass the PCATCH flag to the pri argument, the sleep request is interruptible, and the kernel thread can take asynchronous signals. If you pass the PSUSP flag, the process can be asynchronously suspended while waiting. The mpsleep routine allows you to specify a pointer to a simple or complex lock structure that is associated with some resource. If the MS_LOCK_NO_RELOCK flag is set, it does not relock the lock after blocking. If the MS_LOCK_ON_ERROR flag is set (or no flag is set), mpsleep relocks the lock on failure. NOTES
This routine is not intended for general use. It is mostly used by sleep and tsleep and by knowledgeable callers. The mpsleep routine cannot be called from within an Interrupt Service routine (ISI) because it is illegal to block at interrupt context. RETURN VALUES
The mpsleep routine returns the following values: Successful completion. The sleep has been interrupted by a signal. The sleep has been interrupted by a signal on a restartable system call. The timeout has expired. SEE ALSO
Routines: assert_wait_mesg(9r), clear_wait(9r), thread_block(9r), thread_wakeup(9r), thread_wakeup_one(9r) mpsleep(9r)
Check Out this Related Man Page
SLEEP(9) BSD Kernel Developer's Manual SLEEP(9) NAME
msleep, msleep_spin, pause, tsleep, wakeup -- wait for events SYNOPSIS
#include <sys/param.h> #include <sys/systm.h> #include <sys/proc.h> int msleep(void *chan, struct mtx *mtx, int priority, const char *wmesg, int timo); int msleep_spin(void *chan, struct mtx *mtx, const char *wmesg, int timo); void pause(const char *wmesg, int timo); int tsleep(void *chan, int priority, const char *wmesg, int timo); void wakeup(void *chan); void wakeup_one(void *chan); DESCRIPTION
The functions tsleep(), msleep(), msleep_spin(), pause(), wakeup(), and wakeup_one() handle event-based thread blocking. If a thread must wait for an external event, it is put to sleep by tsleep(), msleep(), msleep_spin(), or pause(). Threads may also wait using one of the locking primitive sleep routines mtx_sleep(9), rw_sleep(9), or sx_sleep(9). The parameter chan is an arbitrary address that uniquely identifies the event on which the thread is being put to sleep. All threads sleep- ing on a single chan are woken up later by wakeup(), often called from inside an interrupt routine, to indicate that the resource the thread was blocking on is available now. The parameter priority specifies a new priority for the thread as well as some optional flags. If the new priority is not 0, then the thread will be made runnable with the specified priority when it resumes. PZERO should never be used, as it is for compatibility only. A new pri- ority of 0 means to use the thread's current priority when it is made runnable again. If priority includes the PCATCH flag, signals are checked before and after sleeping, otherwise signals are not checked. If PCATCH is set and a signal needs to be delivered, ERESTART is returned if the current system call should be restarted if possible, and EINTR is returned if the system call should be interrupted by the signal (return EINTR). If PBDRY flag is specified in addition to PCATCH, then the sleeping thread is not stopped while sleeping upon delivery of SIGSTOP or other stop action. Instead, it is waken up, assuming that stop occurs on reaching a stop point when returning to usermode. The flag should be used when sleeping thread owns resources, for instance vnode locks, that should be freed timely. 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 parameter timo specifies a timeout for the sleep. If timo is not 0, then the thread will sleep for at most timo / hz seconds. If the timeout expires, then the sleep function will return EWOULDBLOCK. Several of the sleep functions including msleep(), msleep_spin(), and the locking primitive sleep routines specify an additional lock parame- ter. The lock will be released before sleeping and reacquired before the sleep routine returns. If priority includes the PDROP flag, then the lock will not be reacquired before returning. The lock is used to ensure that a condition can be checked atomically, and that the cur- rent thread can be suspended without missing a change to the condition, or an associated wakeup. In addition, all of the sleep routines will fully drop the Giant mutex (even if recursed) while the thread is suspended and will reacquire the Giant mutex before the function returns. Note that the Giant mutex may be specified as the lock to drop. In that case, however, the PDROP flag is not allowed. To avoid lost wakeups, either a lock should be used to protect against races, or a timeout should be specified to place an upper bound on the delay due to a lost wakeup. As a result, the tsleep() function should only be invoked with a timeout of 0 when the Giant mutex is held. The msleep() function requires that mtx reference a default, i.e. non-spin, mutex. Its use is deprecated in favor of mtx_sleep(9) which pro- vides identical behavior. The msleep_spin() function requires that mtx reference a spin mutex. The msleep_spin() function does not accept a priority parameter and thus does not support changing the current thread's priority, the PDROP flag, or catching signals via the PCATCH flag. The pause() function is a wrapper around tsleep() that suspends execution of the current thread for the indicated timeout. The thread can not be awakened early by signals or calls to wakeup() or wakeup_one(). The wakeup_one() function makes the first thread in the queue that is sleeping on the parameter chan runnable. This reduces the load when a large number of threads are sleeping on the same address, but only one of them can actually do any useful work when made runnable. Due to the way it works, the wakeup_one() function requires that only related threads sleep on a specific chan address. It is the program- mer's responsibility to choose a unique chan value. The older wakeup() function did not require this, though it was never good practice for threads to share a chan value. When converting from wakeup() to wakeup_one(), pay particular attention to ensure that no other threads wait on the same chan. RETURN VALUES
If the thread is awakened by a call to wakeup() or wakeup_one(), the msleep(), msleep_spin(), tsleep(), and locking primitive sleep functions return 0. Otherwise, a non-zero error code is returned. ERRORS
msleep(), msleep_spin(), tsleep(), and the locking primitive sleep functions will fail if: [EINTR] The PCATCH flag was specified, a signal was caught, and the system call should be interrupted. [ERESTART] The PCATCH flag was specified, a signal was caught, and the system call should be restarted. [EWOULDBLOCK] A non-zero timeout was specified and the timeout expired. SEE ALSO
ps(1), locking(9), malloc(9), mi_switch(9), mtx_sleep(9), rw_sleep(9), sx_sleep(9) HISTORY
The functions sleep() and wakeup() were present in Version 1 AT&T UNIX. They were probably also present in the preceding PDP-7 version of UNIX. They were the basic process synchronization model. The tsleep() function appeared in 4.4BSD and added the parameters wmesg and timo. The sleep() function was removed in FreeBSD 2.2. The wakeup_one() function appeared in FreeBSD 2.2. The msleep() function appeared in FreeBSD 5.0, and the msleep_spin() function appeared in FreeBSD 6.2. The pause() function appeared in FreeBSD 7.0. AUTHORS
This manual page was written by Jorg Wunsch <joerg@FreeBSD.org>. BSD
December 12, 2009 BSD