msleep_spin (9)
Leading comments
Copyright (c) 1996 Joerg Wunsch All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or othe...
NAME
msleep msleep_sbt msleep_spin msleep_spin_sbt pause pause_sbt tsleep tsleep_sbt wakeup - wait for eventsSYNOPSIS
In sys/param.h In sys/systm.h In sys/proc.h Ft int Fn msleep void *chan struct mtx *mtx int priority const char *wmesg int timo Ft int Fn msleep_sbt void *chan struct mtx *mtx int priority const char *wmesg sbintime_t sbt sbintime_t pr int flags Ft int Fn msleep_spin void *chan struct mtx *mtx const char *wmesg int timo Ft int Fn msleep_spin_sbt void *chan struct mtx *mtx const char *wmesg sbintime_t sbt sbintime_t pr int flags Ft void Fn pause const char *wmesg int timo Ft void Fn pause_sbt const char *wmesg sbintime_t sbt sbintime_t print flags Ft int Fn tsleep void *chan int priority const char *wmesg int timo Ft int Fn tsleep_sbt void *chan int priority const char *wmesg sbintime_t sbt sbintime_t pr int flags Ft void Fn wakeup void *chan Ft void Fn wakeup_one void *chan
DESCRIPTION
The functions Fn tsleep , Fn msleep , Fn msleep_spin , Fn pause , Fn wakeup , and Fn wakeup_one handle event-based thread blocking. If a thread must wait for an external event, it is put to sleep by Fn tsleep , Fn msleep , Fn msleep_spin , or Fn pause . Threads may also wait using one of the locking primitive sleep routines mtx_sleep9, rw_sleep9, or sx_sleep9.The parameter Fa chan is an arbitrary address that uniquely identifies the event on which the thread is being put to sleep. All threads sleeping on a single Fa chan are woken up later by Fn wakeup , often called from inside an interrupt routine, to indicate that the resource the thread was blocking on is available now.
The parameter Fa 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 Fa priority when it resumes. PZERO should never be used, as it is for compatibility only. A new priority of 0 means to use the thread's current priority when it is made runnable again.
If Fa priority includes the PCATCH flag, pending signals are allowed to interrupt the sleep, otherwise pending signals are ignored during the sleep. If PCATCH is set and a signal becomes pending, Er ERESTART is returned if the current system call should be restarted if possible, and Er EINTR is returned if the system call should be interrupted by the signal (return Er EINTR ) . If the PBDRY flag is specified in addition to PCATCH then the sleeping thread is not stopped when SIGSTOP becomes pending or some other stop action occurs while it is sleeping. Instead, it is woken up, with the assumption that the stop will occur on reaching a stop point when returning to usermode. The flag should be used when the sleeping thread owns resources, for instance vnode locks, that should be released in a timely fashion.
The parameter Fa 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 Fa timo specifies a timeout for the sleep. If Fa timo is not 0, then the thread will sleep for at most Fa timo No / Va hz seconds. If the timeout expires, then the sleep function will return Er EWOULDBLOCK .
Fn msleep_sbt , Fn msleep_spin_sbt , Fn pause_sbt and Fn tsleep_sbt functions take Fa sbt parameter instead of Fa timo . It allows the caller to specify relative or absolute wakeup time with higher resolution in form of Vt sbintime_t . The parameter Fa pr allows the caller to specify wanted absolute event precision. The parameter Fa flags allows the caller to pass additional Fn callout_reset_sbt flags.
Several of the sleep functions including Fn msleep , Fn msleep_spin , and the locking primitive sleep routines specify an additional lock parameter. The lock will be released before sleeping and reacquired before the sleep routine returns. If Fa 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 current 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 Fn tsleep function should only be invoked with a timeout of 0 when the Giant mutex is held.
The Fn msleep function requires that Fa mtx reference a default, i.e. non-spin, mutex. Its use is deprecated in favor of mtx_sleep9 which provides identical behavior.
The Fn msleep_spin function requires that Fa mtx reference a spin mutex. The Fn msleep_spin function does not accept a Fa priority parameter and thus does not support changing the current thread's priority, the PDROP flag, or catching signals via the PCATCH flag.
The Fn pause function is a wrapper around Fn tsleep that suspends execution of the current thread for the indicated timeout. The thread can not be awakened early by signals or calls to Fn wakeup or Fn wakeup_one .
The Fn wakeup_one function makes the first thread in the queue that is sleeping on the parameter Fa 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 Fn wakeup_one function requires that only related threads sleep on a specific Fa chan address. It is the programmer's responsibility to choose a unique Fa chan value. The older Fn wakeup function did not require this, though it was never good practice for threads to share a Fa chan value. When converting from Fn wakeup to Fn wakeup_one , pay particular attention to ensure that no other threads wait on the same Fa chan .
RETURN VALUES
When awakened by a call to Fn wakeup or Fn wakeup_one , if a signal is pending and PCATCH is specified, a non-zero error code is returned. If the thread is awakened by a call to Fn wakeup or Fn wakeup_one , the Fn msleep , Fn msleep_spin , Fn tsleep , and locking primitive sleep functions return 0. Otherwise, a non-zero error code is returned.ERRORS
Fn msleep , Fn msleep_spin , Fn tsleep , and the locking primitive sleep functions will fail if:- Bq Er EINTR
- The PCATCH flag was specified, a signal was caught, and the system call should be interrupted.
- Bq Er ERESTART
- The PCATCH flag was specified, a signal was caught, and the system call should be restarted.
- Bq Er EWOULDBLOCK
- A non-zero timeout was specified and the timeout expired.
SEE ALSO
ps(1), locking(9), malloc(9), mi_switch9, mtx_sleep9, rw_sleep9, sx_sleep9, timeout(9)HISTORY
The functions Fn sleep and Fn wakeup were present in AT&T System v1 . They were probably also present in the preceding PDP-7 version of UNIX They were the basic process synchronization model.The Fn tsleep function appeared in BSD 4.4 and added the parameters Fa wmesg and Fa timo . The Fn sleep function was removed in Fx 2.2 . The Fn wakeup_one function appeared in Fx 2.2 . The Fn msleep function appeared in Fx 5.0 , and the Fn msleep_spin function appeared in Fx 6.2 . The Fn pause function appeared in Fx 7.0 .