Whamcloud - gitweb
d36a17b3c170cddf96d797d0850dd43c9d25ebdc
[fs/lustre-release.git] / libcfs / libcfs / user-lock.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * libcfs/libcfs/user-lock.c
37  *
38  * Author: Nikita Danilov <nikita@clusterfs.com>
39  */
40
41 /* Implementations of portable synchronization APIs for liblustre */
42
43 /*
44  * liblustre is single-threaded, so most "synchronization" APIs are trivial.
45  *
46  * XXX Liang: There are several branches share lnet with b_hd_newconfig,
47  * if we define lock APIs at here, there will be conflict with liblustre
48  * in other branches.
49  */
50
51 #ifndef __KERNEL__
52
53 #include <libcfs/libcfs.h>
54
55 /*
56  * Optional debugging (magic stamping and checking ownership) can be added.
57  */
58
59 /*
60  * spin_lock
61  *
62  * - spin_lock_init(x)
63  * - spin_lock(x)
64  * - spin_lock_nested(x, subclass)
65  * - spin_unlock(x)
66  * - spin_trylock(x)
67  *
68  * - spin_lock_irqsave(x, f)
69  * - spin_unlock_irqrestore(x, f)
70  *
71  * No-op implementation.
72  */
73
74 void spin_lock_init(spinlock_t *lock)
75 {
76         LASSERT(lock != NULL);
77         (void)lock;
78 }
79
80 void spin_lock(spinlock_t *lock)
81 {
82         (void)lock;
83 }
84
85 void spin_unlock(spinlock_t *lock)
86 {
87         (void)lock;
88 }
89
90 int spin_trylock(spinlock_t *lock)
91 {
92         (void)lock;
93         return 1;
94 }
95
96 void spin_lock_bh_init(spinlock_t *lock)
97 {
98         LASSERT(lock != NULL);
99         (void)lock;
100 }
101
102 void spin_lock_bh(spinlock_t *lock)
103 {
104         LASSERT(lock != NULL);
105         (void)lock;
106 }
107
108 void spin_unlock_bh(spinlock_t *lock)
109 {
110         LASSERT(lock != NULL);
111         (void)lock;
112 }
113
114 /*
115  * Semaphore
116  *
117  * - sema_init(x, v)
118  * - __down(x)
119  * - __up(x)
120  */
121
122 void sema_init(struct semaphore *s, int val)
123 {
124         LASSERT(s != NULL);
125         (void)s;
126         (void)val;
127 }
128
129 void __down(struct semaphore *s)
130 {
131         LASSERT(s != NULL);
132         (void)s;
133 }
134
135 void __up(struct semaphore *s)
136 {
137         LASSERT(s != NULL);
138         (void)s;
139 }
140
141
142 /*
143  * Completion:
144  *
145  * - init_completion(c)
146  * - complete(c)
147  * - wait_for_completion(c)
148  */
149
150 static cfs_wait_handler_t wait_handler;
151
152 void init_completion_module(cfs_wait_handler_t handler)
153 {
154         wait_handler = handler;
155 }
156
157 void init_completion(struct completion *c)
158 {
159         LASSERT(c != NULL);
160         c->done = 0;
161         cfs_waitq_init(&c->wait);
162 }
163
164 void complete(struct completion *c)
165 {
166         LASSERT(c != NULL);
167         c->done  = 1;
168         cfs_waitq_signal(&c->wait);
169 }
170
171 void wait_for_completion(struct completion *c)
172 {
173         LASSERT(c != NULL);
174         do {
175                 if (wait_handler)
176                         wait_handler(1000);
177                 else
178                         break;
179         } while (c->done == 0);
180 }
181
182 int wait_for_completion_interruptible(struct completion *c)
183 {
184         LASSERT(c != NULL);
185         do {
186                 if (wait_handler)
187                         wait_handler(1000);
188                 else
189                         break;
190         } while (c->done == 0);
191         return 0;
192 }
193
194 /*
195  * rw_semaphore:
196  *
197  * - DECLARE_RWSEM(x)
198  * - init_rwsem(x)
199  * - down_read(x)
200  * - up_read(x)
201  * - down_write(x)
202  * - up_write(x)
203  */
204
205 void init_rwsem(struct rw_semaphore *s)
206 {
207         LASSERT(s != NULL);
208         (void)s;
209 }
210
211 void down_read(struct rw_semaphore *s)
212 {
213         LASSERT(s != NULL);
214         (void)s;
215 }
216
217 int down_read_trylock(struct rw_semaphore *s)
218 {
219         LASSERT(s != NULL);
220         (void)s;
221         return 1;
222 }
223
224 void down_write(struct rw_semaphore *s)
225 {
226         LASSERT(s != NULL);
227         (void)s;
228 }
229
230 int down_write_trylock(struct rw_semaphore *s)
231 {
232         LASSERT(s != NULL);
233         (void)s;
234         return 1;
235 }
236
237 void up_read(struct rw_semaphore *s)
238 {
239         LASSERT(s != NULL);
240         (void)s;
241 }
242
243 void up_write(struct rw_semaphore *s)
244 {
245         LASSERT(s != NULL);
246         (void)s;
247 }
248
249 void fini_rwsem(struct rw_semaphore *s)
250 {
251         LASSERT(s != NULL);
252         (void)s;
253 }
254
255 #ifdef HAVE_LIBPTHREAD
256
257 /*
258  * Completion
259  */
260
261 void cfs_init_completion(struct cfs_completion *c)
262 {
263         LASSERT(c != NULL);
264         c->c_done = 0;
265         pthread_mutex_init(&c->c_mut, NULL);
266         pthread_cond_init(&c->c_cond, NULL);
267 }
268
269 void cfs_fini_completion(struct cfs_completion *c)
270 {
271         LASSERT(c != NULL);
272         pthread_mutex_destroy(&c->c_mut);
273         pthread_cond_destroy(&c->c_cond);
274 }
275
276 void cfs_complete(struct cfs_completion *c)
277 {
278         LASSERT(c != NULL);
279         pthread_mutex_lock(&c->c_mut);
280         c->c_done++;
281         pthread_cond_signal(&c->c_cond);
282         pthread_mutex_unlock(&c->c_mut);
283 }
284
285 void cfs_wait_for_completion(struct cfs_completion *c)
286 {
287         LASSERT(c != NULL);
288         pthread_mutex_lock(&c->c_mut);
289         while (c->c_done == 0)
290                 pthread_cond_wait(&c->c_cond, &c->c_mut);
291         c->c_done--;
292         pthread_mutex_unlock(&c->c_mut);
293 }
294
295 /*
296  * atomic primitives
297  */
298
299 static pthread_mutex_t atomic_guard_lock = PTHREAD_MUTEX_INITIALIZER;
300
301 int cfs_atomic_read(cfs_atomic_t *a)
302 {
303         int r;
304
305         pthread_mutex_lock(&atomic_guard_lock);
306         r = a->counter;
307         pthread_mutex_unlock(&atomic_guard_lock);
308         return r;
309 }
310
311 void cfs_atomic_set(cfs_atomic_t *a, int b)
312 {
313         pthread_mutex_lock(&atomic_guard_lock);
314         a->counter = b;
315         pthread_mutex_unlock(&atomic_guard_lock);
316 }
317
318 int cfs_atomic_dec_and_test(cfs_atomic_t *a)
319 {
320         int r;
321
322         pthread_mutex_lock(&atomic_guard_lock);
323         r = --a->counter;
324         pthread_mutex_unlock(&atomic_guard_lock);
325         return (r == 0);
326 }
327
328 void cfs_atomic_inc(cfs_atomic_t *a)
329 {
330         pthread_mutex_lock(&atomic_guard_lock);
331         ++a->counter;
332         pthread_mutex_unlock(&atomic_guard_lock);
333 }
334
335 void cfs_atomic_dec(cfs_atomic_t *a)
336 {
337         pthread_mutex_lock(&atomic_guard_lock);
338         --a->counter;
339         pthread_mutex_unlock(&atomic_guard_lock);
340 }
341 void cfs_atomic_add(int b, cfs_atomic_t *a)
342
343 {
344         pthread_mutex_lock(&atomic_guard_lock);
345         a->counter += b;
346         pthread_mutex_unlock(&atomic_guard_lock);
347 }
348
349 void cfs_atomic_sub(int b, cfs_atomic_t *a)
350 {
351         pthread_mutex_lock(&atomic_guard_lock);
352         a->counter -= b;
353         pthread_mutex_unlock(&atomic_guard_lock);
354 }
355
356 #endif /* HAVE_LIBPTHREAD */
357
358
359 /* !__KERNEL__ */
360 #endif
361
362 /*
363  * Local variables:
364  * c-indentation-style: "K&R"
365  * c-basic-offset: 8
366  * tab-width: 8
367  * fill-column: 80
368  * scroll-step: 1
369  * End:
370  */