2 .\" Copyright (c) 1998 Berkeley Software Design, Inc. 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, this list of conditions and the following disclaimer.
9 .\" 2. Redistributions in binary form must reproduce the above copyright
10 .\" notice, this list of conditions and the following disclaimer in the
11 .\" documentation and/or other materials provided with the distribution.
12 .\" 3. Berkeley Software Design Inc's name may not be used to endorse or
13 .\" promote products derived from this software without specific prior
14 .\" written permission.
16 .\" THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND
17 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 .\" ARE DISCLAIMED. IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE
20 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 .\" from BSDI $Id: mutex.4,v 1.1.2.3 1998/04/27 22:53:13 ewv Exp $
40 .Nm mtx_lock_spin_flags ,
42 .Nm mtx_trylock_flags ,
45 .Nm mtx_unlock_flags ,
46 .Nm mtx_unlock_spin_flags ,
53 .Nd kernel synchronization primitives
59 .Fn mtx_init "struct mtx *mutex" "const char *name" "const char *type" "int opts"
61 .Fn mtx_lock "struct mtx *mutex"
63 .Fn mtx_lock_spin "struct mtx *mutex"
65 .Fn mtx_lock_flags "struct mtx *mutex" "int flags"
67 .Fn mtx_lock_spin_flags "struct mtx *mutex" "int flags"
69 .Fn mtx_trylock "struct mtx *mutex"
71 .Fn mtx_trylock_flags "struct mtx *mutex" "int flags"
73 .Fn mtx_unlock "struct mtx *mutex"
75 .Fn mtx_unlock_spin "struct mtx *mutex"
77 .Fn mtx_unlock_flags "struct mtx *mutex" "int flags"
79 .Fn mtx_unlock_spin_flags "struct mtx *mutex" "int flags"
81 .Fn mtx_destroy "struct mtx *mutex"
83 .Fn mtx_initialized "struct mtx *mutex"
85 .Fn mtx_owned "struct mtx *mutex"
87 .Fn mtx_recursed "struct mtx *mutex"
89 .Cd "options INVARIANTS"
90 .Cd "options INVARIANT_SUPPORT"
92 .Fn mtx_assert "struct mtx *mutex" "int what"
94 .Fn MTX_SYSINIT "name" "struct mutex *mtx" "const char *description" "int opts"
96 Mutexes are the most basic and primary method of thread synchronization.
97 The major design considerations for mutexes are:
100 Acquiring and releasing uncontested mutexes should be as cheap
103 They must have the information and storage space to support
104 priority propagation.
106 A thread must be able to recursively acquire a mutex,
107 provided that the mutex is initialized to support recursion.
110 There are currently two flavors of mutexes, those that context switch
111 when they block and those that do not.
115 mutexes will context switch when they are already held.
117 they may spin for some amount
118 of time before context switching.
119 It is important to remember that since a thread may be preempted at any time,
120 the possible context switch introduced by acquiring a mutex is guaranteed
121 to not break anything that is not already broken.
123 Mutexes which do not context switch are
126 These should only be used to protect data shared with primary interrupt
130 interrupt handlers and low level scheduling code.
131 In all architectures both acquiring and releasing of a
132 uncontested spin mutex is more expensive than the same operation
134 In order to protect an interrupt service routine from blocking
135 against itself all interrupts are either blocked or deferred on a processor
136 while holding a spin lock.
137 It is permissible to hold multiple spin mutexes.
139 Once a spin mutex has been acquired it is not permissible to acquire a
142 The storage needed to implement a mutex is provided by a
144 In general this should be treated as an opaque object and
145 referenced only with the mutex primitives.
149 function must be used to initialize a mutex
150 before it can be passed to any of the other mutex functions.
153 option is used to identify the lock in debugging output etc.
156 option is used by the witness code to classify a mutex when doing checks
163 is used in its place.
164 The pointer passed in as
168 is saved rather than the data it points to.
169 The data pointed to must remain stable
170 until the mutex is destroyed.
173 argument is used to set the type of mutex.
174 It may contain either
179 See below for additional initialization options.
180 It is not permissible to pass the same
184 multiple times without intervening calls to
191 mutual exclusion lock
192 on behalf of the currently running kernel thread.
193 If another kernel thread is holding the mutex,
194 the caller will be disconnected from the CPU
195 until the mutex is available
196 (i.e., it will block).
202 mutual exclusion lock
203 on behalf of the currently running kernel thread.
204 If another kernel thread is holding the mutex,
205 the caller will spin until the mutex becomes available.
206 Interrupts are disabled during the spin and remain disabled
207 following the acquiring of the lock.
209 It is possible for the same thread to recursively acquire a mutex
210 with no ill effects, provided that the
214 during the initialization of the mutex.
219 .Fn mtx_lock_spin_flags
224 lock, respectively, and also accept a
227 In both cases, the only flag presently available for lock acquires is
231 bit is turned on in the
235 tracing is being done,
236 it will be silenced during the lock acquire.
240 attempts to acquire the
244 If the mutex cannot be immediately acquired
247 otherwise the mutex will be acquired
248 and a non-zero value will be returned.
251 .Fn mtx_trylock_flags
252 function has the same behavior as
254 but should be used when the caller desires to pass in a
257 Presently, the only valid value in the
261 and its effects are identical to those described for
269 mutual exclusion lock.
270 The current thread may be preempted if a higher priority thread is waiting
277 mutual exclusion lock.
282 .Fn mtx_unlock_spin_flags
283 functions behave in exactly the same way as do the standard mutex
284 unlock routines above, while also allowing a
286 argument which may specify
290 is identical to its behavior in the mutex lock routines.
294 function is used to destroy
296 so the data associated with it may be freed
297 or otherwise overwritten.
298 Any mutex which is destroyed
299 must previously have been initialized with
301 It is permissible to have a single hold count
302 on a mutex when it is destroyed.
303 It is not permissible to hold the mutex recursively,
304 or have another thread blocked on the mutex
305 when it is destroyed.
309 function returns non-zero if
311 has been initialized and zero otherwise.
315 function returns non-zero
316 if the current thread holds
318 If the current thread does not hold
324 function returns non-zero if the
327 This check should only be made if the running thread already owns
332 function allows assertions specified in
336 If the assertions are not true and the kernel is compiled with
337 .Cd "options INVARIANTS"
339 .Cd "options INVARIANT_SUPPORT" ,
340 the kernel will panic.
341 Currently the following assertions are supported:
342 .Bl -tag -width MA_NOTRECURSED
344 Assert that the current thread
346 pointed to by the first argument.
348 Assert that the current thread
349 does not hold the mutex
350 pointed to by the first argument.
352 Assert that the current thread has recursed on the mutex
353 pointed to by the first argument.
354 This assertion is only valid in conjunction with
356 .It Dv MA_NOTRECURSED
357 Assert that the current thread has not recursed on the mutex
358 pointed to by the first argument.
359 This assertion is only valid in conjunction with
365 macro is used to generate a call to the
367 routine at system startup in order to initialize a given mutex lock.
368 The parameters are the same as
370 but with an additional argument,
372 that is used in generating unique variable names for the related structures associated with the lock and the sysinit routine.
373 .Ss The Default Mutex Type
374 Most kernel code should use the default lock type,
376 The default lock type will allow the thread
377 to be disconnected from the CPU
378 if the lock is already held by another thread.
380 may treat the lock as a short term spin lock
381 under some circumstances.
382 However, it is always safe to use these forms of locks
383 in an interrupt thread
384 without fear of deadlock
385 against an interrupted thread on the same CPU.
386 .Ss The Spin Mutex Type
389 mutex will not relinquish the CPU
390 when it cannot immediately get the requested lock,
391 but will loop, waiting for the mutex to be released by another CPU.
392 This could result in deadlock
393 if another thread interrupted the thread which held a mutex
394 and then tried to acquire the mutex.
395 For this reason spin locks disable all interrupts on the local CPU.
397 Spin locks are fairly specialized locks
398 that are intended to be held for very short periods of time.
399 Their primary purpose is to protect portions of the code
400 that implement other synchronization primitives such as default mutexes,
401 thread scheduling, and interrupt threads.
402 .Ss Initialization Options
403 The options passed in the
407 specify the mutex type.
412 options is required and only one of those two options may be specified.
413 The possibilities are:
414 .Bl -tag -width MTX_NOWITNESS
417 will always allow the current thread to be suspended
418 to avoid deadlock conditions against interrupt threads.
419 The implementation of this lock type
420 may spin for a while before suspending the current thread.
423 will never relinquish the CPU.
424 All interrupts are disabled on the local CPU
425 while any spin lock is held.
427 Specifies that the initialized mutex is allowed to recurse.
428 This bit must be present if the mutex is permitted to recurse.
430 Do not log any mutex operations for this lock.
436 Witness should not log messages about duplicate locks being acquired.
438 .Ss Lock and Unlock Flags
439 The flags passed to the
441 .Fn mtx_lock_spin_flags ,
442 .Fn mtx_unlock_flags ,
444 .Fn mtx_unlock_spin_flags
445 functions provide some basic options to the caller,
446 and are often used only under special circumstances to modify lock or
448 Standard locking and unlocking should be performed with the
455 Only if a flag is required should the corresponding
456 flags-accepting routines be used.
458 Options that modify mutex behavior:
459 .Bl -tag -width MTX_QUIET
461 This option is used to quiet logging messages during individual mutex
463 This can be used to trim superfluous logging messages for debugging purposes.
468 must be acquired, it must be acquired prior to acquiring
470 Put another way: it is impossible to acquire
472 non-recursively while
473 holding another mutex.
474 It is possible to acquire other mutexes while holding
476 and it is possible to acquire
478 recursively while holding other mutexes.
480 Sleeping while holding a mutex (except for
483 and should be avoided.
484 There are numerous assertions which will fail if this is attempted.
485 .Ss Functions Which Access Memory in Userspace
486 No mutexes should be held (except for
488 across functions which
489 access memory in userspace, such as
495 No locks are needed when calling these functions.
500 .Xr MUTEX_PROFILING 9 ,
507 functions appeared in