Whamcloud - gitweb
b=16774 cancel unused osc locks before replay.
[fs/lustre-release.git] / libcfs / libcfs / winnt / winnt-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 (c) 2008, 2010, Oracle and/or its affiliates. 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
38 # define DEBUG_SUBSYSTEM S_LNET
39
40 #include <libcfs/libcfs.h>
41
42
43 #if defined(_X86_)
44
45 void __declspec (naked) FASTCALL
46 cfs_atomic_add(
47     int i,
48     cfs_atomic_t *v
49     )
50 {
51     // ECX = i
52     // EDX = v ; [EDX][0] = v->counter
53
54     __asm {
55         lock add dword ptr [edx][0], ecx
56         ret
57     }
58 }
59
60 void __declspec (naked) FASTCALL
61 cfs_atomic_sub(
62     int i,
63     cfs_atomic_t *v
64    ) 
65 {
66     // ECX = i
67     // EDX = v ; [EDX][0] = v->counter
68
69     __asm {
70         lock sub dword ptr [edx][0], ecx
71         ret
72     }
73 }
74
75 void __declspec (naked) FASTCALL
76 cfs_atomic_inc(
77     cfs_atomic_t *v
78     )
79 {
80     //InterlockedIncrement((PULONG)(&((v)->counter)));
81
82     //` ECX = v ; [ECX][0] = v->counter
83
84     __asm {
85         lock inc dword ptr [ecx][0]
86         ret
87     }
88 }
89
90 void __declspec (naked) FASTCALL
91 cfs_atomic_dec(
92     cfs_atomic_t *v
93     )
94 {
95     // ECX = v ; [ECX][0] = v->counter
96
97     __asm {
98         lock dec dword ptr [ecx][0]
99         ret
100     }
101 }
102
103 int __declspec (naked) FASTCALL 
104 cfs_atomic_sub_and_test(
105     int i,
106     cfs_atomic_t *v
107     )
108 {
109
110     // ECX = i
111     // EDX = v ; [EDX][0] = v->counter
112
113     __asm {
114         xor eax, eax
115         lock sub dword ptr [edx][0], ecx
116         sete al
117         ret
118     }
119 }
120
121 int __declspec (naked) FASTCALL
122 cfs_atomic_inc_and_test(
123     cfs_atomic_t *v
124     )
125 {
126     // ECX = v ; [ECX][0] = v->counter
127
128     __asm {
129         xor eax, eax
130         lock inc dword ptr [ecx][0]
131         sete al
132         ret
133     }
134 }
135
136 int __declspec (naked) FASTCALL
137 cfs_atomic_dec_and_test(
138     cfs_atomic_t *v
139     )
140 {
141     // ECX = v ; [ECX][0] = v->counter
142
143     __asm {
144         xor eax, eax
145         lock dec dword ptr [ecx][0]
146         sete al
147         ret
148     }
149 }
150
151 #elif defined(_AMD64_)
152
153 void FASTCALL
154 cfs_atomic_add(
155     int i,
156     cfs_atomic_t *v
157     )
158 {
159     InterlockedExchangeAdd( (PULONG)(&((v)->counter)) , (LONG) (i));
160 }
161
162 void FASTCALL
163 cfs_atomic_sub(
164     int i,
165     cfs_atomic_t *v
166    ) 
167 {
168     InterlockedExchangeAdd( (PULONG)(&((v)->counter)) , (LONG) (-1*i));
169 }
170
171 void FASTCALL
172 cfs_atomic_inc(
173     cfs_atomic_t *v
174     )
175 {
176    InterlockedIncrement((PULONG)(&((v)->counter)));
177 }
178
179 void FASTCALL
180 cfs_atomic_dec(
181     cfs_atomic_t *v
182     )
183 {
184     InterlockedDecrement((PULONG)(&((v)->counter)));
185 }
186
187 int FASTCALL 
188 cfs_atomic_sub_and_test(
189     int i,
190     cfs_atomic_t *v
191     )
192 {
193     int counter, result;
194
195     do {
196
197         counter = v->counter;
198         result = counter - i;
199
200     } while ( InterlockedCompareExchange(
201                 &(v->counter),
202                 result,
203                 counter) !=  counter);
204
205     return (result == 0);
206 }
207
208 int FASTCALL
209 cfs_atomic_inc_and_test(
210     cfs_atomic_t *v
211     )
212 {
213     int counter, result;
214
215     do {
216
217         counter = v->counter;
218         result = counter + 1;
219
220     } while ( InterlockedCompareExchange(
221                 &(v->counter),
222                 result,
223                 counter) !=  counter);
224
225     return (result == 0);
226 }
227
228 int FASTCALL
229 cfs_atomic_dec_and_test(
230     cfs_atomic_t *v
231     )
232 {
233     int counter, result;
234
235     do {
236
237         counter = v->counter;
238         result = counter - 1;
239
240     } while ( InterlockedCompareExchange(
241                 &(v->counter),
242                 result,
243                 counter) !=  counter);
244
245     return (result == 0);
246 }
247
248 #else
249
250 #error CPU arch type isn't specified.
251
252 #endif
253
254 /**
255  * atomic_add_return - add integer and return
256  * \param v pointer of type atomic_t
257  * \param i integer value to add
258  *
259  * Atomically adds \a i to \a v and returns \a i + \a v
260  */
261 int FASTCALL cfs_atomic_add_return(int i, cfs_atomic_t *v)
262 {
263     int counter, result;
264
265     do {
266
267         counter = v->counter;
268         result = counter + i;
269
270     } while ( InterlockedCompareExchange(
271                 &(v->counter),
272                 result,
273                 counter) !=  counter);
274
275     return result;
276
277 }
278
279 /**
280  * atomic_sub_return - subtract integer and return
281  * \param v pointer of type atomic_t
282  * \param i integer value to subtract
283  *
284  * Atomically subtracts \a i from \a v and returns \a v - \a i
285  */
286 int FASTCALL cfs_atomic_sub_return(int i, cfs_atomic_t *v)
287 {
288         return cfs_atomic_add_return(-i, v);
289 }
290
291 int FASTCALL cfs_atomic_dec_and_lock(cfs_atomic_t *v, cfs_spinlock_t *lock)
292 {
293     if (cfs_atomic_read(v) != 1) {
294         return 0;
295     }
296
297         cfs_spin_lock(lock);
298         if (cfs_atomic_dec_and_test(v))
299                 return 1;
300         cfs_spin_unlock(lock);
301         return 0;
302 }
303
304
305 /*
306  * rw spinlock
307  */
308
309
310 void
311 cfs_rwlock_init(cfs_rwlock_t * rwlock)
312 {
313     cfs_spin_lock_init(&rwlock->guard);
314     rwlock->count = 0;
315 }
316
317 void
318 cfs_rwlock_fini(cfs_rwlock_t * rwlock)
319 {
320 }
321
322 void
323 cfs_read_lock(cfs_rwlock_t * rwlock)
324 {
325     cfs_task_t * task = cfs_current();
326     PTASK_SLOT   slot = NULL;
327
328     if (!task) {
329         /* should bugchk here */
330         cfs_enter_debugger();
331         return;
332     }
333
334     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
335     ASSERT(slot->Magic == TASKSLT_MAGIC);
336    
337     slot->irql = KeRaiseIrqlToDpcLevel();
338
339     while (TRUE) {
340             cfs_spin_lock(&rwlock->guard);
341         if (rwlock->count >= 0)
342             break;
343         cfs_spin_unlock(&rwlock->guard);
344     }
345
346         rwlock->count++;
347         cfs_spin_unlock(&rwlock->guard);
348 }
349
350 void
351 cfs_read_unlock(cfs_rwlock_t * rwlock)
352 {
353     cfs_task_t * task = cfs_current();
354     PTASK_SLOT   slot = NULL;
355
356     if (!task) {
357         /* should bugchk here */
358         cfs_enter_debugger();
359         return;
360     }
361
362     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
363     ASSERT(slot->Magic == TASKSLT_MAGIC);
364    
365     cfs_spin_lock(&rwlock->guard);
366         ASSERT(rwlock->count > 0);
367     rwlock->count--;
368     if (rwlock < 0) {
369         cfs_enter_debugger();
370     }
371         cfs_spin_unlock(&rwlock->guard);
372
373     KeLowerIrql(slot->irql);
374 }
375
376 void
377 cfs_write_lock(cfs_rwlock_t * rwlock)
378 {
379     cfs_task_t * task = cfs_current();
380     PTASK_SLOT   slot = NULL;
381
382     if (!task) {
383         /* should bugchk here */
384         cfs_enter_debugger();
385         return;
386     }
387
388     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
389     ASSERT(slot->Magic == TASKSLT_MAGIC);
390    
391     slot->irql = KeRaiseIrqlToDpcLevel();
392
393     while (TRUE) {
394             cfs_spin_lock(&rwlock->guard);
395         if (rwlock->count == 0)
396             break;
397         cfs_spin_unlock(&rwlock->guard);
398     }
399
400         rwlock->count = -1;
401         cfs_spin_unlock(&rwlock->guard);
402 }
403
404 void
405 cfs_write_unlock(cfs_rwlock_t * rwlock)
406 {
407     cfs_task_t * task = cfs_current();
408     PTASK_SLOT   slot = NULL;
409
410     if (!task) {
411         /* should bugchk here */
412         cfs_enter_debugger();
413         return;
414     }
415
416     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
417     ASSERT(slot->Magic == TASKSLT_MAGIC);
418    
419     cfs_spin_lock(&rwlock->guard);
420         ASSERT(rwlock->count == -1);
421     rwlock->count = 0;
422         cfs_spin_unlock(&rwlock->guard);
423
424     KeLowerIrql(slot->irql);
425 }