Whamcloud - gitweb
5a3fabdca45765fc0a7cfba54f51565804924ce1
[fs/lustre-release.git] / lnet / include / libcfs / darwin / darwin-sync.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Implementation of standard libcfs synchronization primitives for XNU
5  * kernel.
6  *
7  *  Copyright (c) 2004 Cluster File Systems, Inc.
8  *
9  *   This file is part of Lustre, http://www.lustre.org.
10  *
11  *   Lustre is free software; you can redistribute it and/or modify it under
12  *   the terms of version 2 of the GNU General Public License as published by
13  *   the Free Software Foundation. Lustre is distributed in the hope that it
14  *   will be useful, but WITHOUT ANY WARRANTY; without even the implied
15  *   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *   GNU General Public License for more details. You should have received a
17  *   copy of the GNU General Public License along with Lustre; if not, write
18  *   to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
19  *   USA.
20  */
21
22 /*
23  * xnu_sync.h
24  *
25  * Created by nikita on Sun Jul 18 2004.
26  *
27  * Prototypes of XNU synchronization primitives.
28  */
29
30 #ifndef __LIBCFS_DARWIN_XNU_SYNC_H__
31 #define __LIBCFS_DARWIN_XNU_SYNC_H__
32
33 #ifndef __LIBCFS_LIBCFS_H__
34 #error Do not #include this file directly. #include <libcfs/libcfs.h> instead
35 #endif
36
37 #define XNU_SYNC_DEBUG (1)
38
39 #if XNU_SYNC_DEBUG
40 #define ON_SYNC_DEBUG(e) e
41 #else
42 #define ON_SYNC_DEBUG(e)
43 #endif
44
45 enum {
46         /* "egrep -i '^(o?x)?[abcdeflo]*$' /usr/dict/words" is your friend */
47         KMUT_MAGIC  = 0x0bac0cab, /* [a, [b, c]] = b (a, c) - c (a, b) */
48         KSEM_MAGIC  = 0x1abe11ed,
49         KCOND_MAGIC = 0xb01dface,
50         KRW_MAGIC   = 0xdabb1edd,
51         KSPIN_MAGIC = 0xca11ab1e,
52         KRW_SPIN_MAGIC    = 0xbabeface,
53         KSLEEP_CHAN_MAGIC = 0x0debac1e,
54         KSLEEP_LINK_MAGIC = 0xacc01ade,
55         KTIMER_MAGIC      = 0xbefadd1e
56 };
57
58 /* ------------------------- spin lock ------------------------- */
59
60 /*
61  * XXX nikita: don't use NCPUS it's hardcoded to (1) in cpus.h
62  */
63 #define SMP (1)
64
65 #include <libcfs/list.h>
66
67 #ifdef __DARWIN8__
68
69 #include <sys/param.h>
70 #include <sys/systm.h>
71 #include <sys/kernel.h>
72 #include <kern/locks.h>
73
74 /*
75  * hw_lock is not available in Darwin8 (hw_lock_* are not exported at all), 
76  * so use lck_spin_t. we can hack out lck_spin_t easily, it's the only 
77  * hacking in Darwin8.x. We did so because it'll take a lot of time to 
78  * add lock_done for all locks, maybe it should be done in the future.
79  * If lock_done for all locks were added, we can:
80  *
81  * typedef lck_spin_t      *xnu_spin_t;
82  */
83 #if defined (__ppc__)
84 typedef struct {
85         unsigned int    opaque[3];
86 } xnu_spin_t;
87 #elif defined (__i386__)
88 typedef struct {
89         unsigned int    opaque[10];
90 } xnu_spin_t;
91 #endif
92
93 /* 
94  * wait_queue is not available in Darwin8 (wait_queue_* are not exported), 
95  * use assert_wait/wakeup/wake_one (wait_queue in kernel hash).
96  */
97 typedef void * xnu_wait_queue_t;
98
99 /* DARWIN8 */
100 #else
101
102 #include <mach/mach_types.h>
103 #include <sys/types.h>
104 #include <kern/simple_lock.h>
105
106 typedef hw_lock_data_t          xnu_spin_t;
107 typedef struct wait_queue       xnu_wait_queue_t;
108
109 /* DARWIN8 */
110 #endif
111
112 struct kspin {
113 #if SMP
114         xnu_spin_t      lock;
115 #endif
116 #if XNU_SYNC_DEBUG
117         unsigned        magic;
118         thread_t        owner;
119 #endif
120 };
121
122 void kspin_init(struct kspin *spin);
123 void kspin_done(struct kspin *spin);
124 void kspin_lock(struct kspin *spin);
125 void kspin_unlock(struct kspin *spin);
126 int  kspin_trylock(struct kspin *spin);
127
128 #if XNU_SYNC_DEBUG
129 /*
130  * two functions below are for use in assertions
131  */
132 /* true, iff spin-lock is locked by the current thread */
133 int kspin_islocked(struct kspin *spin);
134 /* true, iff spin-lock is not locked by the current thread */
135 int kspin_isnotlocked(struct kspin *spin);
136 #else
137 #define kspin_islocked(s) (1)
138 #define kspin_isnotlocked(s) (1)
139 #endif
140
141 /* ------------------------- rw spinlock ----------------------- */
142 struct krw_spin {
143         struct kspin      guard;
144         int               count;
145 #if XNU_SYNC_DEBUG
146         unsigned          magic;
147 #endif
148 };
149
150 void krw_spin_init(struct krw_spin *sem);
151 void krw_spin_done(struct krw_spin *sem);
152 void krw_spin_down_r(struct krw_spin *sem);
153 void krw_spin_down_w(struct krw_spin *sem);
154 void krw_spin_up_r(struct krw_spin *sem);
155 void krw_spin_up_w(struct krw_spin *sem);
156
157 /* ------------------------- semaphore ------------------------- */
158
159 struct ksem {
160         struct kspin      guard;
161         xnu_wait_queue_t  q;
162         int               value;
163 #if XNU_SYNC_DEBUG
164         unsigned          magic;
165 #endif
166 };
167
168 void ksem_init(struct ksem *sem, int value);
169 void ksem_done(struct ksem *sem);
170 int  ksem_up  (struct ksem *sem, int value);
171 void ksem_down(struct ksem *sem, int value);
172 int  ksem_trydown(struct ksem *sem, int value);
173
174 /* ------------------------- mutex ------------------------- */
175
176 struct kmut {
177         struct ksem s;
178 #if XNU_SYNC_DEBUG
179         unsigned    magic;
180         thread_t    owner;
181 #endif
182 };
183
184 void kmut_init(struct kmut *mut);
185 void kmut_done(struct kmut *mut);
186
187 void kmut_lock   (struct kmut *mut);
188 void kmut_unlock (struct kmut *mut);
189 int  kmut_trylock(struct kmut *mut);
190
191 #if XNU_SYNC_DEBUG
192 /*
193  * two functions below are for use in assertions
194  */
195 /* true, iff mutex is locked by the current thread */
196 int kmut_islocked(struct kmut *mut);
197 /* true, iff mutex is not locked by the current thread */
198 int kmut_isnotlocked(struct kmut *mut);
199 #else
200 #define kmut_islocked(m) (1)
201 #define kmut_isnotlocked(m) (1)
202 #endif
203
204 /* ------------------------- condition variable ------------------------- */
205
206 struct kcond_link {
207         struct kcond_link *next;
208         struct ksem        sem;
209 };
210
211 struct kcond {
212         struct kspin       guard;
213         struct kcond_link *waiters;
214 #if XNU_SYNC_DEBUG
215         unsigned           magic;
216 #endif
217 };
218
219 void kcond_init(struct kcond *cond);
220 void kcond_done(struct kcond *cond);
221 void kcond_wait(struct kcond *cond, struct kspin *lock);
222 void kcond_signal(struct kcond *cond);
223 void kcond_broadcast(struct kcond *cond);
224
225 void kcond_wait_guard(struct kcond *cond);
226 void kcond_signal_guard(struct kcond *cond);
227 void kcond_broadcast_guard(struct kcond *cond);
228
229 /* ------------------------- read-write semaphore ------------------------- */
230
231 struct krw_sem {
232         int          count;
233         struct kcond cond;
234 #if XNU_SYNC_DEBUG
235         unsigned     magic;
236 #endif
237 };
238
239 void krw_sem_init(struct krw_sem *sem);
240 void krw_sem_done(struct krw_sem *sem);
241 void krw_sem_down_r(struct krw_sem *sem);
242 int krw_sem_down_r_try(struct krw_sem *sem);
243 void krw_sem_down_w(struct krw_sem *sem);
244 int krw_sem_down_w_try(struct krw_sem *sem);
245 void krw_sem_up_r(struct krw_sem *sem);
246 void krw_sem_up_w(struct krw_sem *sem);
247
248 /* ------------------------- sleep-channel ------------------------- */
249
250 struct ksleep_chan {
251         struct kspin     guard;
252         struct list_head waiters;
253 #if XNU_SYNC_DEBUG
254         unsigned     magic;
255 #endif
256 };
257
258 #define KSLEEP_CHAN_INITIALIZER         {{{0}}}
259
260 struct ksleep_link {
261         int                 flags;
262         event_t             event;
263         int                 hits;
264         struct ksleep_chan *forward;
265         struct list_head    linkage;
266 #if XNU_SYNC_DEBUG
267         unsigned     magic;
268 #endif
269 };
270
271 enum {
272         KSLEEP_EXCLUSIVE = 1
273 };
274
275 void ksleep_chan_init(struct ksleep_chan *chan);
276 void ksleep_chan_done(struct ksleep_chan *chan);
277
278 void ksleep_link_init(struct ksleep_link *link);
279 void ksleep_link_done(struct ksleep_link *link);
280
281 void ksleep_add(struct ksleep_chan *chan, struct ksleep_link *link);
282 void ksleep_del(struct ksleep_chan *chan, struct ksleep_link *link);
283
284 void ksleep_wait(struct ksleep_chan *chan, int state);
285 int64_t  ksleep_timedwait(struct ksleep_chan *chan, int state, uint64_t timeout);
286
287 void ksleep_wake(struct ksleep_chan *chan);
288 void ksleep_wake_all(struct ksleep_chan *chan);
289 void ksleep_wake_nr(struct ksleep_chan *chan, int nr);
290
291 #define KSLEEP_LINK_DECLARE(name)               \
292 {                                               \
293         .flags   = 0,                           \
294         .event   = 0,                           \
295         .hits    = 0,                           \
296         .linkage = CFS_LIST_HEAD(name.linkage), \
297         .magic   = KSLEEP_LINK_MAGIC            \
298 }
299
300 /* ------------------------- timer ------------------------- */
301
302 struct ktimer {
303         struct kspin   guard;
304         void         (*func)(void *);
305         void          *arg;
306         u_int64_t      deadline; /* timer deadline in absolute nanoseconds */
307         int            armed;
308 #if XNU_SYNC_DEBUG
309         unsigned     magic;
310 #endif
311 };
312
313 void ktimer_init(struct ktimer *t, void (*func)(void *), void *arg);
314 void ktimer_done(struct ktimer *t);
315 void ktimer_arm(struct ktimer *t, u_int64_t deadline);
316 void ktimer_disarm(struct ktimer *t);
317 int  ktimer_is_armed(struct ktimer *t);
318
319 u_int64_t ktimer_deadline(struct ktimer *t);
320
321 /* __XNU_SYNC_H__ */
322 #endif
323
324 /*
325  * Local variables:
326  * c-indentation-style: "K&R"
327  * c-basic-offset: 8
328  * tab-width: 8
329  * fill-column: 80
330  * scroll-step: 1
331  * End:
332  */