Whamcloud - gitweb
3a8d6cb816d025ae9def4194563398799c81432b
[fs/lustre-release.git] / libcfs / libcfs / winnt / winnt-sync.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
37 #define DEBUG_SUBSYSTEM S_LNET
38
39 #include <libcfs/libcfs.h>
40
41
42 /*
43  * Wait queue routines
44  */
45
46 /*
47  * cfs_waitq_init
48  *   To initialize the wait queue
49  *
50  * Arguments:
51  *   waitq:  pointer to the cfs_waitq_t structure
52  *
53  * Return Value:
54  *   N/A
55  *
56  * Notes: 
57  *   N/A
58  */
59
60 void cfs_waitq_init(cfs_waitq_t *waitq)
61 {
62     waitq->magic = CFS_WAITQ_MAGIC;
63     waitq->flags = 0;
64     CFS_INIT_LIST_HEAD(&(waitq->waiters));
65     cfs_spin_lock_init(&(waitq->guard));
66 }
67
68 /*
69  * cfs_waitlink_init
70  *   To initialize the wake link node
71  *
72  * Arguments:
73  *   link:  pointer to the cfs_waitlink_t structure
74  *
75  * Return Value:
76  *   N/A
77  *
78  * Notes: 
79  *   N/A
80  */
81
82 void cfs_waitlink_init(cfs_waitlink_t *link)
83 {
84     cfs_task_t * task = cfs_current();
85     PTASK_SLOT   slot = NULL;
86
87     if (!task) {
88         /* should bugchk here */
89         cfs_enter_debugger();
90         return;
91     }
92
93     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
94     cfs_assert(slot->Magic == TASKSLT_MAGIC);
95
96     memset(link, 0, sizeof(cfs_waitlink_t));
97
98     link->magic = CFS_WAITLINK_MAGIC;
99     link->flags = 0;
100
101     link->event = &(slot->Event);
102     link->hits  = &(slot->hits);
103
104     cfs_atomic_inc(&slot->count);
105
106     CFS_INIT_LIST_HEAD(&(link->waitq[0].link));
107     CFS_INIT_LIST_HEAD(&(link->waitq[1].link));
108
109     link->waitq[0].waitl = link->waitq[1].waitl = link;
110 }
111
112
113 /*
114  * cfs_waitlink_fini
115  *   To finilize the wake link node
116  *
117  * Arguments:
118  *   link:  pointer to the cfs_waitlink_t structure
119  *
120  * Return Value:
121  *   N/A
122  *
123  * Notes: 
124  *   N/A
125  */
126
127 void cfs_waitlink_fini(cfs_waitlink_t *link)
128 {
129     cfs_task_t * task = cfs_current();
130     PTASK_SLOT   slot = NULL;
131
132     if (!task) {
133         /* should bugchk here */
134         cfs_enter_debugger();
135         return;
136     }
137
138     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
139     cfs_assert(slot->Magic == TASKSLT_MAGIC);
140     cfs_assert(link->magic == CFS_WAITLINK_MAGIC);
141     cfs_assert(link->waitq[0].waitq == NULL);
142     cfs_assert(link->waitq[1].waitq == NULL);
143
144     cfs_atomic_dec(&slot->count);
145 }
146
147
148 /*
149  * cfs_waitq_add_internal
150  *   To queue the wait link node to the wait queue
151  *
152  * Arguments:
153  *   waitq:  pointer to the cfs_waitq_t structure
154  *   link:   pointer to the cfs_waitlink_t structure
155  *   int:    queue no (Normal or Forward waitq)
156  *
157  * Return Value:
158  *   N/A
159  *
160  * Notes: 
161  *   N/A
162  */
163
164 void cfs_waitq_add_internal(cfs_waitq_t *waitq,
165                             cfs_waitlink_t *link,
166                             __u32 waitqid )
167
168     LASSERT(waitq != NULL);
169     LASSERT(link != NULL);
170     LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
171     LASSERT(link->magic == CFS_WAITLINK_MAGIC);
172     LASSERT(waitqid < CFS_WAITQ_CHANNELS);
173
174     cfs_spin_lock(&(waitq->guard));
175     LASSERT(link->waitq[waitqid].waitq == NULL);
176     link->waitq[waitqid].waitq = waitq;
177     if (link->flags & CFS_WAITQ_EXCLUSIVE) {
178         cfs_list_add_tail(&link->waitq[waitqid].link, &waitq->waiters);
179     } else {
180         cfs_list_add(&link->waitq[waitqid].link, &waitq->waiters);
181     }
182     cfs_spin_unlock(&(waitq->guard));
183 }
184 /*
185  * cfs_waitq_add
186  *   To queue the wait link node to the wait queue
187  *
188  * Arguments:
189  *   waitq:  pointer to the cfs_waitq_t structure
190  *   link:  pointer to the cfs_waitlink_t structure
191  *
192  * Return Value:
193  *   N/A
194  *
195  * Notes: 
196  *   N/A
197  */
198
199 void cfs_waitq_add(cfs_waitq_t *waitq,
200                    cfs_waitlink_t *link)
201
202     cfs_waitq_add_internal(waitq, link, CFS_WAITQ_CHAN_NORMAL);
203 }
204
205 /*
206  * cfs_waitq_add_exclusive
207  *   To set the wait link node to exclusive mode
208  *   and queue it to the wait queue
209  *
210  * Arguments:
211  *   waitq:  pointer to the cfs_waitq_t structure
212  *   link:  pointer to the cfs_wait_link structure
213  *
214  * Return Value:
215  *   N/A
216  *
217  * Notes: 
218  *   N/A
219  */
220
221 void cfs_waitq_add_exclusive( cfs_waitq_t *waitq,
222                               cfs_waitlink_t *link)
223 {
224     LASSERT(waitq != NULL);
225     LASSERT(link != NULL);
226     LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
227     LASSERT(link->magic == CFS_WAITLINK_MAGIC);
228
229         link->flags |= CFS_WAITQ_EXCLUSIVE;
230     cfs_waitq_add(waitq, link);
231 }
232
233 /*
234  * cfs_waitq_del
235  *   To remove the wait link node from the waitq
236  *
237  * Arguments:
238  *   waitq:  pointer to the cfs_ waitq_t structure
239  *   link:  pointer to the cfs_waitlink_t structure
240  *
241  * Return Value:
242  *   N/A
243  *
244  * Notes: 
245  *   N/A
246  */
247
248 void cfs_waitq_del( cfs_waitq_t *waitq,
249                     cfs_waitlink_t *link)
250 {
251     int i = 0;
252
253     LASSERT(waitq != NULL);
254     LASSERT(link != NULL);
255
256     LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
257     LASSERT(link->magic == CFS_WAITLINK_MAGIC);
258
259     cfs_spin_lock(&(waitq->guard));
260
261     for (i=0; i < CFS_WAITQ_CHANNELS; i++) {
262         if (link->waitq[i].waitq == waitq)
263             break;
264     }
265
266     if (i < CFS_WAITQ_CHANNELS) {
267         link->waitq[i].waitq = NULL;
268         cfs_list_del_init(&link->waitq[i].link);
269     } else {
270         cfs_enter_debugger();
271     }
272
273     cfs_spin_unlock(&(waitq->guard));
274 }
275
276 /*
277  * cfs_waitq_active
278  *   Is the waitq active (not empty) ?
279  *
280  * Arguments:
281  *   waitq:  pointer to the cfs_ waitq_t structure
282  *
283  * Return Value:
284  *   Zero: the waitq is empty
285  *   Non-Zero: the waitq is active
286  *
287  * Notes: 
288  *   We always returns TRUE here, the same to Darwin.
289  */
290
291 int cfs_waitq_active(cfs_waitq_t *waitq)
292 {
293     LASSERT(waitq != NULL);
294     LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
295
296         return (1);
297 }
298
299 /*
300  * cfs_waitq_signal_nr
301  *   To wake up all the non-exclusive tasks plus nr exclusive
302  *   ones in the waitq
303  *
304  * Arguments:
305  *   waitq:  pointer to the cfs_waitq_t structure
306  *   nr:    number of exclusive tasks to be woken up
307  *
308  * Return Value:
309  *   N/A
310  *
311  * Notes: 
312  *   N/A
313  */
314
315
316 void cfs_waitq_signal_nr(cfs_waitq_t *waitq, int nr)
317 {
318     int     result;
319     cfs_waitlink_channel_t * scan;
320
321     LASSERT(waitq != NULL);
322     LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
323
324     cfs_spin_lock(&waitq->guard);
325     cfs_list_for_each_entry_typed(scan, &waitq->waiters, 
326                             cfs_waitlink_channel_t,
327                             link) {
328
329         cfs_waitlink_t *waitl = scan->waitl;
330
331         result = cfs_wake_event(waitl->event);
332         LASSERT( result == FALSE || result == TRUE );
333
334         if (result) {
335             cfs_atomic_inc(waitl->hits);
336         }
337
338         if ((waitl->flags & CFS_WAITQ_EXCLUSIVE) && --nr == 0)
339             break;
340     }
341
342     cfs_spin_unlock(&waitq->guard);
343     return;
344 }
345
346 /*
347  * cfs_waitq_signal
348  *   To wake up all the non-exclusive tasks and 1 exclusive
349  *
350  * Arguments:
351  *   waitq:  pointer to the cfs_waitq_t structure
352  *
353  * Return Value:
354  *   N/A
355  *
356  * Notes: 
357  *   N/A
358  */
359
360 void cfs_waitq_signal(cfs_waitq_t *waitq)
361 {
362     cfs_waitq_signal_nr(waitq, 1);
363 }
364
365
366 /*
367  * cfs_waitq_broadcast
368  *   To wake up all the tasks in the waitq
369  *
370  * Arguments:
371  *   waitq:  pointer to the cfs_waitq_t structure
372  *
373  * Return Value:
374  *   N/A
375  *
376  * Notes: 
377  *   N/A
378  */
379
380 void cfs_waitq_broadcast(cfs_waitq_t *waitq)
381 {
382     LASSERT(waitq != NULL);
383     LASSERT(waitq->magic ==CFS_WAITQ_MAGIC);
384
385         cfs_waitq_signal_nr(waitq, 0);
386 }
387
388 /*
389  * cfs_waitq_wait
390  *   To wait on the link node until it is signaled.
391  *
392  * Arguments:
393  *   link:  pointer to the cfs_waitlink_t structure
394  *
395  * Return Value:
396  *   N/A
397  *
398  * Notes: 
399  *   N/A
400  */
401
402 void cfs_waitq_wait(cfs_waitlink_t *link, cfs_task_state_t state)
403
404     LASSERT(link != NULL);
405     LASSERT(link->magic == CFS_WAITLINK_MAGIC);
406
407     if (cfs_atomic_read(link->hits) > 0) {
408         cfs_atomic_dec(link->hits);
409         LASSERT((__u32)cfs_atomic_read(link->hits) < (__u32)0xFFFFFF00);
410     } else {
411         cfs_wait_event_internal(link->event, 0);
412     }
413 }
414
415 /*
416  * cfs_waitq_timedwait
417  *   To wait the link node to be signaled with a timeout limit
418  *
419  * Arguments:
420  *   link:   pointer to the cfs_waitlink_t structure
421  *   timeout: the timeout limitation
422  *
423  * Return Value:
424  *   Woken up: return the difference of the current time and
425  *             the timeout
426  *   Timeout:  return 0
427  *
428  * Notes: 
429  *   What if it happens to be woken up at the just timeout time !?
430  */
431
432 int64_t cfs_waitq_timedwait( cfs_waitlink_t *link,
433                              cfs_task_state_t state,
434                              int64_t timeout)
435
436
437     if (cfs_atomic_read(link->hits) > 0) {
438         cfs_atomic_dec(link->hits);
439         LASSERT((__u32)cfs_atomic_read(link->hits) < (__u32)0xFFFFFF00);
440         return (int64_t)TRUE;
441     }
442
443     return (int64_t)cfs_wait_event_internal(link->event, timeout);
444 }