Manual Reference Pages - LOCKING (9)
- kernel synchronization primitives
Sleepable Read-Mostly Locks
Bounded vs. Unbounded Sleep
Context mode table
kernel is written to run across multiple CPUs and as such provides
several different synchronization primitives to allow developers
to safely access and manipulate many data types.
Mutexes (also called "blocking mutexes") are the most commonly used
synchronization primitive in the kernel.
A thread acquires (locks) a mutex before accessing data shared with other
threads (including interrupt threads), and releases (unlocks) it afterwards.
If the mutex cannot be acquired, the thread requesting it will wait.
Mutexes are adaptive by default, meaning that
if the owner of a contended mutex is currently running on another CPU,
then a thread attempting to acquire the mutex will spin rather than yielding
Mutexes fully support priority propagation.
Spin mutexes are a variation of basic mutexes; the main difference between
the two is that spin mutexes never block.
Instead, they spin while waiting for the lock to be released.
To avoid deadlock, a thread that holds a spin mutex must never yield its CPU.
Unlike ordinary mutexes, spin mutexes disable interrupts when acquired.
Since disabling interrupts can be expensive, they are generally slower to
acquire and release.
Spin mutexes should be used only when absolutely necessary,
e.g. to protect data shared
with interrupt filter code (see
or for scheduler internals.
With most synchronization primitives, such as mutexes, the programmer must
provide memory to hold the primitive.
For example, a mutex may be embedded inside the structure it protects.
Mutex pools provide a preallocated set of mutexes to avoid this
Note that mutexes from a pool may only be used as leaf locks.
Reader/writer locks allow shared access to protected data by multiple threads
or exclusive access by a single thread.
The threads with shared access are known as
since they should only read the protected data.
A thread with exclusive access is known as a
since it may modify protected data.
Reader/writer locks can be treated as mutexes (see above and
with shared/exclusive semantics.
Reader/writer locks support priority propagation like mutexes,
but priority is propagated only to an exclusive holder.
This limitation comes from the fact that shared owners
Read-mostly locks are similar to
locks but optimized for very infrequent write locking.
locks implement full priority propagation by tracking shared owners
using a caller-supplied
Sleepable Read-Mostly Locks
Sleepable read-mostly locks are a variation on read-mostly locks.
Threads holding an exclusive lock may sleep,
but threads holding a shared lock may not.
Priority is propagated to shared owners but not to exclusive owners.
Shared/exclusive locks are similar to reader/writer locks; the main difference
between them is that shared/exclusive locks may be held during unbounded sleep.
Acquiring a contested shared/exclusive lock can perform an unbounded sleep.
These locks do not support priority propagation.
Lockmanager locks are sleepable shared/exclusive locks used mostly in
and in the buffer cache
They have features other lock types do not have such as sleep
timeouts, blocking upgrades,
writer starvation avoidance, draining, and an interlock mutex,
but this makes them complicated both to use and to implement;
for this reason, they should be avoided.
Counting semaphores provide a mechanism for synchronizing access
to a pool of resources.
Unlike mutexes, semaphores do not have the concept of an owner,
so they can be useful in situations where one thread needs
to acquire a resource, and another thread needs to release it.
They are largely deprecated.
Condition variables are used in conjunction with locks to wait for
a condition to become true.
A thread must hold the associated lock before calling one of the
When a thread waits on a condition, the lock
is atomically released before the thread yields the processor
and reacquired before the function call returns.
Condition variables may be used with blocking mutexes,
reader/writer locks, read-mostly locks, and shared/exclusive locks.
also handle event-based thread blocking.
Unlike condition variables,
arbitrary addresses may be used as wait channels and a dedicated
structure does not need to be allocated.
However, care must be taken to ensure that wait channel addresses are
unique to an event.
If a thread must wait for an external event, it is put to sleep by
Threads may also wait using one of the locking primitive sleep routines
is an arbitrary address that uniquely identifies the event on which
the thread is being put to sleep.
All threads sleeping on a single
are woken up later by
(often called from inside an interrupt routine)
to indicate that the
event the thread was blocking on has occurred.
Several of the sleep functions including
and the locking primitive sleep routines specify an additional lock
The lock will be released before sleeping and reacquired
before the sleep routine returns.
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
(even if recursed)
while the thread is suspended and will reacquire the
(restoring any recursion)
before the function returns.
function is a special sleep function that waits for a specified
amount of time to pass before the thread resumes execution.
This sleep cannot be terminated early by either an explicit
or a signal.
Giant is a special mutex used to protect data structures that do not
yet have their own locks.
Since it provides semantics akin to the old
Giant has special characteristics:
- It is recursive.
- Drivers can request that Giant be locked around them
by not marking themselves MPSAFE.
Note that infrastructure to do this is slowly going away as non-MPSAFE
drivers either became properly locked or disappear.
- Giant must be locked before other non-sleepable locks.
- Giant is dropped during unbounded sleeps and reacquired after wakeup.
- There are places in the kernel that drop Giant and pick it back up
Sleep locks will do this before sleeping.
Parts of the network or VM code may do this as well.
This means that you cannot count on Giant keeping other code from
running if your code sleeps, even if you want it to.
The primitives can interact and have a number of rules regarding how
they can and can not be combined.
Many of these rules are checked by
Bounded vs. Unbounded Sleep
In a bounded sleep
(also referred to as
the only resource needed to resume execution of a thread
is CPU time for the owner of a lock that the thread is waiting to acquire.
In an unbounded sleep
often referred to as simply
a thread waits for an external event or for a condition
to become true.
a dependency chain of threads in bounded sleeps should always make forward
since there is always CPU time available.
This requires that no thread in a bounded sleep is waiting for a lock held
by a thread in an unbounded sleep.
To avoid priority inversions,
a thread in a bounded sleep lends its priority to the owner of the lock
that it is waiting for.
The following primitives perform bounded sleeps:
mutexes, reader/writer locks and read-mostly locks.
The following primitives perform unbounded sleeps:
sleepable read-mostly locks, shared/exclusive locks, lockmanager locks,
counting semaphores, condition variables, and sleep/wakeup.
The following table shows what you can and can not do while holding
one of the locking primitives discussed. Note that
any of the
and any of the
| You want: spin mtx mutex/rw rmlock sleep rm sx/lk sleep
You have: -------- -------- ------ -------- ------ ------
spin mtx ok no no no no no-1
mutex/rw ok ok ok no no no-1
rmlock ok ok ok no no no-1
sleep rm ok ok ok ok-2 ok-2 ok-2/3
sx ok ok ok ok ok ok-3
lockmgr ok ok ok ok ok ok
There are calls that atomically release this primitive when going to sleep
and reacquire it on wakeup
These cases are only allowed while holding a write lock on a sleepable
Though one can sleep while holding this lock,
one can also use a
function to atomically release this primitive when going to sleep and
reacquire it on wakeup.
Note that non-blocking try operations on locks are always permitted.
Context mode table
The next table shows what can be used in different contexts.
At this time this is a rather easy to remember table.
| Context: spin mtx mutex/rw rmlock sleep rm sx/lk sleep
interrupt filter: ok no no no no no
interrupt thread: ok ok ok no no no
callout: ok ok ok no no no
direct callout: ok no no no no no
system call: ok ok ok ok ok ok
functions appeared in
.Fx 7.0 .
There are too many locking primitives to choose from.
Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.