2 .\" Copyright (C) 2001 Jason Evans <jasone@FreeBSD.org>. All rights reserved.
4 .\" Redistribution and use in source and binary forms, with or without
5 .\" modification, are permitted provided that the following conditions
7 .\" 1. Redistributions of source code must retain the above copyright
8 .\" notice(s), this list of conditions and the following disclaimer as
9 .\" the first lines of this file unmodified other than the possible
10 .\" addition of one or more copyright notices.
11 .\" 2. Redistributions in binary form must reproduce the above copyright
12 .\" notice(s), this list of conditions and the following disclaimer in the
13 .\" documentation and/or other materials provided with the distribution.
15 .\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
16 .\" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 .\" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 .\" DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
19 .\" DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 .\" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 .\" SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
22 .\" CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
53 .Nd kernel shared/exclusive lock
59 .Fn sx_init "struct sx *sx" "const char *description"
61 .Fn sx_init_flags "struct sx *sx" "const char *description" "int opts"
63 .Fn sx_destroy "struct sx *sx"
65 .Fn sx_slock "struct sx *sx"
67 .Fn sx_xlock "struct sx *sx"
69 .Fn sx_slock_sig "struct sx *sx"
71 .Fn sx_xlock_sig "struct sx *sx"
73 .Fn sx_try_slock "struct sx *sx"
75 .Fn sx_try_xlock "struct sx *sx"
77 .Fn sx_sunlock "struct sx *sx"
79 .Fn sx_xunlock "struct sx *sx"
81 .Fn sx_unlock "struct sx *sx"
83 .Fn sx_try_upgrade "struct sx *sx"
85 .Fn sx_downgrade "struct sx *sx"
87 .Fn sx_sleep "void *chan" "struct sx *sx" "int priority" "const char *wmesg" "int timo"
89 .Fn sx_xholder "struct sx *sx"
91 .Fn sx_xlocked "const struct sx *sx"
93 .Cd "options INVARIANTS"
94 .Cd "options INVARIANT_SUPPORT"
96 .Fn sx_assert "const struct sx *sx" "int what"
98 .Fn SX_SYSINIT "name" "struct sx *sx" "const char *description"
100 Shared/exclusive locks are used to protect data that are read far more often
101 than they are written.
102 Shared/exclusive locks do not implement priority propagation like mutexes and
103 reader/writer locks to prevent priority inversions, so
104 shared/exclusive locks should be used prudently.
106 Shared/exclusive locks are created with either
112 is a pointer to space for a
116 is a pointer to a null-terminated character string that describes the
117 shared/exclusive lock.
122 specifies a set of optional flags to alter the behavior of
124 It contains one or more of the following flags:
125 .Bl -tag -width SX_NOADAPTIVE
127 Disable adaptive spinning, rather than sleeping, for lock operations
128 while an exclusive lock holder is executing on another CPU.
129 Adaptive spinning is the default unless the kernel is compiled with
130 .Cd "options NO_ADAPTIVE_SX" .
132 Witness should not log messages about duplicate locks being acquired.
138 Do not profile this lock.
140 Allow threads to recursively acquire exclusive locks for
143 Do not log any operations for this lock via
146 If the kernel has been compiled with
147 .Cd "options INVARIANTS" ,
151 has not been initialized multiple times without intervening calls to
153 unless this option is specified.
156 Shared/exclusive locks are destroyed with
160 must not be locked by any thread when it is destroyed.
162 Threads acquire and release a shared lock by calling
171 Threads acquire and release an exclusive lock by calling
180 A thread can attempt to upgrade a currently held shared lock to an exclusive
183 A thread that has an exclusive lock can downgrade it to a shared lock by
190 will return 0 if the shared/exclusive lock cannot be acquired immediately;
191 otherwise the shared/exclusive lock will be acquired and a non-zero value will
195 will return 0 if the shared lock cannot be upgraded to an exclusive lock
196 immediately; otherwise the exclusive lock will be acquired and a non-zero value
202 do the same as their normal versions but performing an interruptible sleep.
203 They return a non-zero value if the sleep has been interrupted by a signal
204 or an interrupt, otherwise 0.
206 A thread can atomically release a shared/exclusive lock while waiting for an
209 For more details on the parameters to this function,
214 .Cd "options INVARIANTS"
216 .Cd "options INVARIANT_SUPPORT" ,
221 for the assertions specified in
223 and panics if they are not met.
224 One of the following assertions must be specified:
225 .Bl -tag -width ".Dv SA_UNLOCKED"
227 Assert that the current thread has either a shared or an exclusive lock on the
229 lock pointed to by the first argument.
231 Assert that the current thread has a shared lock on the
236 Assert that the current thread has an exclusive lock on the
239 by the first argument.
241 Assert that the current thread has no lock on the
244 by the first argument.
247 In addition, one of the following optional assertions may be included with
254 .Bl -tag -width ".Dv SA_NOTRECURSED"
256 Assert that the current thread has a recursed lock on
258 .It Dv SA_NOTRECURSED
259 Assert that the current thread does not have a recursed lock on
264 will return a pointer to the thread which currently holds an exclusive lock on
266 If no thread holds an exclusive lock on
273 will return non-zero if the current thread holds the exclusive lock;
274 otherwise, it will return zero.
276 For ease of programming,
278 is provided as a macro frontend to the respective functions,
282 Algorithms that are aware of what state the lock is in should use either
283 of the two specific functions for a minor performance benefit.
287 macro is used to generate a call to the
289 routine at system startup in order to initialize a given
292 The parameters are the same as
294 but with an additional argument,
296 that is used in generating unique variable names for the related
297 structures associated with the lock and the sysinit routine.
299 A thread may not hold both a shared lock and an exclusive lock on the same
301 attempting to do so will result in deadlock.
303 A thread may hold a shared or exclusive lock on an
308 lock may not be acquired while holding a mutex.
309 Otherwise, if one thread slept while holding an
311 lock while another thread blocked on the same
313 lock after acquiring a mutex, then the second thread would effectively
314 end up sleeping while holding a mutex, which is not allowed.
325 cannot assert whether the current thread does or does not hold a shared lock.
331 thread holds a shared lock.
332 They cannot ensure that the current thread holds a shared lock.
335 can only assert that the current thread does not hold an exclusive lock.