ulock-rellock-actually-returns-void-20031212
[openafs.git] / src / ubik / lock.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #include <sys/types.h>
17 #ifndef AFS_NT40_ENV
18 #include <sys/file.h>
19 #endif
20 #include <errno.h>
21 #include <lock.h>
22 #include <rx/xdr.h>
23
24 #define UBIK_INTERNALS 1
25 #include "ubik.h"
26 #include "ubik_int.h"
27
28 /* Locks hang off of each transaction, with all the transaction hanging off of
29  * the appropriate dbase.  This package expects to be used in a two-phase locking
30  * protocol, so it doesn't provide a way to release anything but all of the locks in the
31  * transaction.
32  *
33  * At present, it doesn't support the setting of more than one byte-position lock at a time, that is
34  * the length field must be 1.  This doesn't mean that a single transaction can't set more than
35  * one lock, however.
36  *
37  * It is the responsibility of the user to avoid deadlock by setting locks in a partial order.
38  *
39  * EWOULDBLOCK has been replaced in this file by EAGAIN. Many Unix's but not
40  * all (eg. HP) do not replace EWOULDBLOCK with EAGAIN. The bad news is this
41  * goes over the wire. The good news is that the code path is never triggered
42  * as it requires ulock_getLock to be called with await = 0. And ulock_SetLock
43  * isn't even used in this code base. Since NT doesn't have a native
44  * EAGAIN, we are replacing all instances of EWOULDBLOCK with EAGAIN.
45  * 
46  */
47
48 #define WouldReadBlock(lock)\
49   ((((lock)->excl_locked & WRITE_LOCK) || (lock)->wait_states) ? 0 : 1)
50 #define WouldWriteBlock(lock)\
51   ((((lock)->excl_locked & WRITE_LOCK) || (lock)->readers_reading) ? 0 : 1)
52
53 struct Lock rwlock;
54 int rwlockinit = 1;
55
56 /* Set a transaction lock.  Atype is LOCKREAD or LOCKWRITE, await is
57  * true if you want to wait for the lock instead of returning
58  * EWOULDLBOCK.
59  *
60  * The DBHOLD lock must be held.
61  */
62 ulock_getLock(atrans, atype, await)
63      struct ubik_trans *atrans;
64      int atype, await;
65 {
66     struct ubik_dbase *dbase = atrans->dbase;
67
68     /* On first pass, initialize the lock */
69     if (rwlockinit) {
70         Lock_Init(&rwlock);
71         rwlockinit = 0;
72     }
73
74     if ((atype != LOCKREAD) && (atype != LOCKWRITE))
75         return EINVAL;
76
77     if (atrans->flags & TRDONE)
78         return UDONE;
79
80     if (atrans->locktype != 0) {
81         ubik_print("Ubik: Internal Error: attempted to take lock twice\n");
82         abort();
83     }
84
85 /*
86  *ubik_print("Ubik: DEBUG: Thread 0x%x request %s lock\n", lwp_cpptr,
87  *           ((atype == LOCKREAD) ? "READ" : "WRITE"));
88  */
89
90     /* Check if the lock would would block */
91     if (!await) {
92         if (atype == LOCKREAD) {
93             if (WouldReadBlock(&rwlock))
94                 return EAGAIN;
95         } else {
96             if (WouldWriteBlock(&rwlock))
97                 return EAGAIN;
98         }
99     }
100
101     /* Create new lock record and add to spec'd transaction:
102      * #if defined(UBIK_PAUSE)
103      * * locktype.  Before doing that, set TRSETLOCK,
104      * * to tell udisk_end that another thread (us) is waiting.
105      * #else
106      * * locktype. This field also tells us if the thread is 
107      * * waiting for a lock: It will be equal to LOCKWAIT.
108      * #endif 
109      */
110 #if defined(UBIK_PAUSE)
111     if (atrans->flags & TRSETLOCK) {
112         printf("Ubik: Internal Error: TRSETLOCK already set?\n");
113         return EBUSY;
114     }
115     atrans->flags |= TRSETLOCK;
116 #else
117     atrans->locktype = LOCKWAIT;
118 #endif /* UBIK_PAUSE */
119     DBRELE(dbase);
120     if (atype == LOCKREAD) {
121         ObtainReadLock(&rwlock);
122     } else {
123         ObtainWriteLock(&rwlock);
124     }
125     DBHOLD(dbase);
126     atrans->locktype = atype;
127 #if defined(UBIK_PAUSE)
128     atrans->flags &= ~TRSETLOCK;
129 #if 0
130     /* We don't do this here, because this can only happen in SDISK_Lock,
131      *  and there's already code there to catch this condition.
132      */
133     if (atrans->flags & TRSTALE) {
134         udisk_end(atrans);
135         return UINTERNAL;
136     }
137 #endif
138 #endif /* UBIK_PAUSE */
139
140 /*
141  *ubik_print("Ubik: DEBUG: Thread 0x%x took %s lock\n", lwp_cpptr,
142  *           ((atype == LOCKREAD) ? "READ" : "WRITE"));
143  */
144     return 0;
145 }
146
147 /* Release the transaction lock */
148 void
149 ulock_relLock(atrans)
150      struct ubik_trans *atrans;
151 {
152     if (rwlockinit)
153         return;
154
155     if (atrans->locktype == LOCKREAD) {
156         ReleaseReadLock(&rwlock);
157     } else if (atrans->locktype == LOCKWRITE) {
158         ReleaseWriteLock(&rwlock);
159     }
160
161 /*
162  *ubik_print("Ubik: DEBUG: Thread 0x%x %s unlock\n", lwp_cpptr,
163  *           ((atrans->locktype == LOCKREAD) ? "READ" : "WRITE"));
164  */
165
166     atrans->locktype = 0;
167     return;
168 }
169
170 /* debugging hooks */
171 ulock_Debug(aparm)
172      struct ubik_debug *aparm;
173 {
174     if (rwlockinit) {
175         aparm->anyReadLocks = 0;
176         aparm->anyWriteLocks = 0;
177     } else {
178         aparm->anyReadLocks = rwlock.readers_reading;
179         aparm->anyWriteLocks = ((rwlock.excl_locked == WRITE_LOCK) ? 1 : 0);
180     }
181     return 0;
182 }