f66de0942f866d0c46686f634d77a2becafb773b
[dragonfly.git] / lib / libc / sys / umtx.2
1 .\" Copyright (c) 2003,2004 The DragonFly Project.  All rights reserved.
2 .\"
3 .\" This code is derived from software contributed to The DragonFly Project
4 .\" by Matthew Dillon <dillon@backplane.com>
5 .\"
6 .\" Redistribution and use in source and binary forms, with or without
7 .\" modification, are permitted provided that the following conditions
8 .\" are met:
9 .\"
10 .\" 1. Redistributions of source code must retain the above copyright
11 .\"    notice, this list of conditions and the following disclaimer.
12 .\" 2. Redistributions in binary form must reproduce the above copyright
13 .\"    notice, this list of conditions and the following disclaimer in
14 .\"    the documentation and/or other materials provided with the
15 .\"    distribution.
16 .\" 3. Neither the name of The DragonFly Project nor the names of its
17 .\"    contributors may be used to endorse or promote products derived
18 .\"    from this software without specific, prior written permission.
19 .\"
20 .\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 .\" ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 .\" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 .\" FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
24 .\" COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 .\" INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 .\" BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 .\" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 .\" AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 .\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 .\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 .\" SUCH DAMAGE.
32 .\"
33 .\" $DragonFly: src/lib/libc/sys/umtx.2,v 1.3 2005/02/23 21:54:01 swildner Exp $
34 .\"
35 .Dd February 21, 2005
36 .Dt UMTX 2
37 .Os
38 .Sh NAME
39 .Nm umtx_sleep ,
40 .Nm umtx_wakeup
41 .Nd kernel support for userland mutexes
42 .Sh LIBRARY
43 .Lb libc
44 .Sh SYNOPSIS
45 .Ft int
46 .Fn umtx_sleep "const int *ptr" "int value" "int timeout"
47 .Ft int
48 .Fn umtx_wakeup "const int *ptr" "int count"
49 .Sh DESCRIPTION
50 The
51 .Fn umtx_sleep
52 system call will put the calling process to sleep for
53 .Fa timeout
54 microseconds if the contents of the specified point matches 
55 the specified value.
56 Specifying a timeout of 0 indicates an indefinite timeout.
57 The comparison is not atomic with the sleep but is properly
58 interlocked against another process calling
59 .Fn umtx_wakeup .
60 In particular, while it is possible for two userland threads to race, one
61 going to sleep simultaniously with another releasing the mutex, this condition
62 is caught when the second userland thread calls
63 .Fn umtx_wakeup
64 after releasing the contended mutex.
65 The
66 .Fa timeout
67 is limited to the range 0-1000000 microseconds.
68 .Pp
69 The
70 .Fn umtx_wakeup
71 system call will wakeup the specified number of processes sleeping
72 in
73 .Fn umtx_sleep
74 on the specified user address.  A count of 0 will wake up all sleeping
75 processes.  This function may wake up more processes then the specified
76 count but will never wake up fewer processes (unless there are simply not
77 that many currently sleeping on the address).  The current DragonFly
78 implementation optimized the count = 1 case but otherwise just wakes up
79 all processes sleeping on the address.
80 .Pp
81 Kernel support for userland mutexes is based on the physical memory backing
82 the user address.  Two userland programs may use this facility through
83 .Fn mmap ,
84 .Fn sysv ,
85 and
86 .Fn rfork
87 based shared memory.  It is important to note that the kernel does not
88 take responsibility for adjusting the contents of the mutex or for the
89 userland implementation of the mutex.
90 .Sh RETURN VALUES
91 .Fn umtx_sleep
92 will return 0 if it successfully slept and was then woken up.  Otherwise
93 it will return -1 and set
94 .Li errno
95 as shown below.
96 .Pp
97 .Fn umtx_wakeup
98 will generally return 0 unless the address is bad. 
99 .Sh ERRORS
100 .Bl -tag -width Er
101 .It Bq Er EBUSY
102 The contents of
103 .Fa *ptr
104 did not match
105 .Fa value
106 .It Bq Er ETIMEDOUT
107 The specified timeout occured.
108 .It Bq Er EINTR
109 The
110 .Fn umtx_sleep
111 call was interrupted by a signal.
112 .It Bq Er EINVAL
113 An invalid parameter (typically an invalid timeout) was specified.
114 .El
115 .Sh EXAMPLE
116 .Bd -literal -compact
117
118 void
119 userland_get_mutex(struct umtx *mtx)
120 {
121     int v;
122
123     for (;;) {
124         v = mtx->lock;
125         if ((v & MTX_LOCKED) == 0) {
126             /*
127              * not locked, attempt to lock.
128              */
129             if (cmp_and_exg(&mtx->lock, v, v | MTX_LOCKED) == 0)
130                 return;
131         } else {
132             /*
133              * Locked, bump the contested count and obtain the contested
134              * mutex.
135              */
136             if (cmp_and_exg(&mtx->lock, v, v + 1) == 0) {
137                 userland_get_mutex_contested(mtx);
138                 return;
139             }
140         }
141     }
142 }
143
144 static void
145 userland_get_mutex_contested(struct umtx *mtx)
146 {
147     int v;
148
149     for (;;) {
150         v = mtx->lock;
151         assert(v & ~MTX_LOCKED);        /* our contesting count still there */
152         if ((v & MTX_LOCKED) == 0) {
153             /*
154              * not locked, attempt to remove our contested count and
155              * lock at the same time.
156              */
157             if (cmp_and_exg(&mtx->lock, v, (v - 1) | MTX_LOCKED) == 0)
158                 return;
159         } else {
160             /*
161              * Still locked, sleep and try again.
162              */
163             umtx_sleep(&mtx->lock, v, 0);
164             /*
165              * XXX note: if we are woken up here but do not proceed to
166              * attempt to obtain the mutex, we should chain the 
167              * umtx_wakeup() along.
168              */
169         }
170     }
171 }
172
173 void
174 userland_rel_mutex(struct umtx *mtx)
175 {
176     int v;
177
178     for (;;) {
179         v = mtx->lock;
180         assert(v & MTX_LOCKED); /* we still have it locked */
181         if (v == MTX_LOCKED) {
182             /*
183              * We hold an uncontested lock, try to set to an unlocked
184              * state.
185              */
186             if (cmp_and_exg(&mtx->lock, MTX_LOCKED, 0) == 0)
187                 return;
188         } else {
189             /*
190              * We hold a contested lock, unlock and wakeup exactly
191              * one sleeper.  It is possible for this to race a new
192              * thread obtaining a lock, in which case any contested
193              * sleeper we wake up will simply go back to sleep.
194              */
195             if (cmp_and_exg(&mtx->lock, v, v & ~MTX_LOCKED) == 0) {
196                 umtx_wakeup(&mtx->lock, 1);
197                 return;
198             }
199         }
200     }
201 }
202 .Ed
203
204 .Sh SEE ALSO
205 .Xr tls 2  
206
207 .Sh HISTORY
208 The
209 .Fn umtx_sleep ,
210 and
211 .Fn umtx_wakeup
212 function calls first appeared in DragonFly 1.1 .