windows-aclent-deadlock-20050713
[openafs.git] / src / WINNT / afsd / cm_aclent.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 <afs/param.h>
11 #include <afs/stds.h>
12
13 #ifndef DJGPP
14 #include <windows.h>
15 #endif
16 #include <stdlib.h>
17 #include <string.h>
18 #include <malloc.h>
19
20 #include "afsd.h"
21 #include <osisleep.h>
22
23 /* 
24  * This next lock controls access to all cm_aclent structures in the system,
25  * in either the free list or in the LRU queue.  A read lock prevents someone
26  * from modifying the list(s), and a write lock is required for modifying
27  * the list.  The actual data stored in the randomUid and randomAccess fields
28  * is actually maintained as up-to-date or not via the scache lock.
29  * An aclent structure is free if it has no back vnode pointer.
30  */
31 osi_rwlock_t cm_aclLock;                /* lock for system's aclents */
32
33 /* This must be called with cm_aclLock and the aclp->back->mx held */
34 static void CleanupACLEnt(cm_aclent_t * aclp)
35 {
36     cm_aclent_t *taclp;
37     cm_aclent_t **laclpp;
38         
39     if (aclp->backp) {
40         if (aclp->backp->randomACLp) {
41             /* 
42              * Remove the entry from the vnode's list 
43              */
44             lock_AssertMutex(&aclp->backp->mx);
45             laclpp = &aclp->backp->randomACLp;
46             for (taclp = *laclpp; taclp; laclpp = &taclp->nextp, taclp = *laclpp) {
47                 if (taclp == aclp) 
48                     break;
49             }
50             if (!taclp) 
51                 osi_panic("CleanupACLEnt race", __FILE__, __LINE__);
52             *laclpp = aclp->nextp;                      /* remove from vnode list */
53         }
54         aclp->backp = NULL;
55     }
56
57     /* release the old user */
58     if (aclp->userp) {
59         cm_ReleaseUser(aclp->userp);
60         aclp->userp = NULL;
61     }
62
63     aclp->randomAccess = 0;
64     aclp->tgtLifetime = 0;
65 }
66
67 /* 
68  * Get an acl cache entry for a particular user and file, or return that it doesn't exist.
69  * Called with the scp locked.
70  */
71 long cm_FindACLCache(cm_scache_t *scp, cm_user_t *userp, long *rightsp)
72 {
73     cm_aclent_t *aclp;
74     long retval = -1;
75
76     lock_ObtainWrite(&cm_aclLock);
77     *rightsp = 0;   /* get a new acl from server if we don't find a
78                      * current entry 
79                      */
80
81     for (aclp = scp->randomACLp; aclp; aclp = aclp->nextp) {
82         if (aclp->userp == userp) {
83             if (aclp->tgtLifetime && aclp->tgtLifetime <= osi_Time()) {
84                 /* ticket expired */
85                 osi_QRemove((osi_queue_t **) &cm_data.aclLRUp, &aclp->q);
86                 CleanupACLEnt(aclp);
87
88                 /* move to the tail of the LRU queue */
89                 osi_QAddT((osi_queue_t **) &cm_data.aclLRUp,
90                            (osi_queue_t **) &cm_data.aclLRUEndp,
91                            &aclp->q);
92             } else {
93                 *rightsp = aclp->randomAccess;
94                 if (cm_data.aclLRUEndp == aclp)
95                     cm_data.aclLRUEndp = (cm_aclent_t *) osi_QPrev(&aclp->q);
96
97                 /* move to the head of the LRU queue */
98                 osi_QRemove((osi_queue_t **) &cm_data.aclLRUp, &aclp->q);
99                 osi_QAddH((osi_queue_t **) &cm_data.aclLRUp,
100                            (osi_queue_t **) &cm_data.aclLRUEndp,
101                            &aclp->q);
102                 retval = 0;     /* success */
103             }               
104             break;
105         }
106     }
107
108     lock_ReleaseWrite(&cm_aclLock);
109     return retval;
110 }       
111
112 /* 
113  * This function returns a free (not in the LRU queue) acl cache entry.
114  * It must be called with the cm_aclLock lock held
115  */
116 static cm_aclent_t *GetFreeACLEnt(cm_scache_t * scp)
117 {
118     cm_aclent_t *aclp;
119     cm_scache_t *ascp = 0;
120         
121     if (cm_data.aclLRUp == NULL)
122         osi_panic("empty aclent LRU", __FILE__, __LINE__);
123
124     aclp = cm_data.aclLRUEndp;
125     cm_data.aclLRUEndp = (cm_aclent_t *) osi_QPrev(&aclp->q);
126     osi_QRemove((osi_queue_t **) &cm_data.aclLRUp, &aclp->q);
127
128     if (aclp->backp && scp != aclp->backp) {
129         ascp = aclp->backp;
130         lock_ReleaseWrite(&cm_aclLock);
131         lock_ObtainMutex(&ascp->mx);
132         lock_ObtainWrite(&cm_aclLock);
133     }
134     CleanupACLEnt(aclp);
135
136     if (ascp)
137         lock_ReleaseMutex(&ascp->mx);
138     return aclp;
139 }
140
141
142 /* 
143  * Add rights to an acl cache entry.  Do the right thing if not present, 
144  * including digging up an entry from the LRU queue.
145  *
146  * The scp must be locked when this function is called.
147  */
148 long cm_AddACLCache(cm_scache_t *scp, cm_user_t *userp, long rights)
149 {
150     register struct cm_aclent *aclp;
151
152     lock_ObtainWrite(&cm_aclLock);
153     for (aclp = scp->randomACLp; aclp; aclp = aclp->nextp) {
154         if (aclp->userp == userp) {
155             aclp->randomAccess = rights;
156             if (aclp->tgtLifetime == 0) 
157                 aclp->tgtLifetime = cm_TGTLifeTime(pag);
158             lock_ReleaseWrite(&cm_aclLock);
159             return 0;
160         }
161     }
162
163     /* 
164      * Didn't find the dude we're looking for, so take someone from the LRUQ 
165      * and  reuse. But first try the free list and see if there's already 
166      * someone there.
167      */
168     aclp = GetFreeACLEnt(scp);           /* can't fail, panics instead */
169     osi_QAddH((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
170     aclp->backp = scp;
171     aclp->nextp = scp->randomACLp;
172     scp->randomACLp = aclp;
173     cm_HoldUser(userp);
174     aclp->userp = userp;
175     aclp->randomAccess = rights;
176     aclp->tgtLifetime = cm_TGTLifeTime(userp);
177     lock_ReleaseWrite(&cm_aclLock);
178
179     return 0;
180 }
181
182 long cm_ShutdownACLCache(void)
183 {
184     return 0;
185 }
186
187 long cm_ValidateACLCache(void)
188 {
189     long size = cm_data.stats * 2;
190     long count;
191     cm_aclent_t * aclp;
192
193     for ( aclp = cm_data.aclLRUp, count = 0; aclp;
194           aclp = (cm_aclent_t *) osi_QNext(&aclp->q), count++ ) {
195         if (aclp->magic != CM_ACLENT_MAGIC) {
196             afsi_log("cm_ValidateACLCache failure: acpl->magic != CM_ACLENT_MAGIC");
197             fprintf(stderr, "cm_ValidateACLCache failure: acpl->magic != CM_ACLENT_MAGIC\n");
198             return -1;
199         }
200         if (aclp->nextp && aclp->nextp->magic != CM_ACLENT_MAGIC) {
201             afsi_log("cm_ValidateACLCache failure: acpl->nextp->magic != CM_ACLENT_MAGIC");
202             fprintf(stderr,"cm_ValidateACLCache failure: acpl->nextp->magic != CM_ACLENT_MAGIC\n");
203             return -2;
204         }
205         if (aclp->backp && aclp->backp->magic != CM_SCACHE_MAGIC) {
206             afsi_log("cm_ValidateACLCache failure: acpl->backp->magic != CM_SCACHE_MAGIC");
207             fprintf(stderr,"cm_ValidateACLCache failure: acpl->backp->magic != CM_SCACHE_MAGIC\n");
208             return -3;
209         }
210         if (count != 0 && aclp == cm_data.aclLRUp || count > size) {
211             afsi_log("cm_ValidateACLCache failure: loop in cm_data.aclLRUp list");
212             fprintf(stderr, "cm_ValidateACLCache failure: loop in cm_data.aclLRUp list\n");
213             return -4;
214         }
215     }
216
217     for ( aclp = cm_data.aclLRUEndp, count = 0; aclp;
218           aclp = (cm_aclent_t *) osi_QPrev(&aclp->q), count++ ) {
219         if (aclp->magic != CM_ACLENT_MAGIC) {
220             afsi_log("cm_ValidateACLCache failure: aclp->magic != CM_ACLENT_MAGIC");
221             fprintf(stderr, "cm_ValidateACLCache failure: aclp->magic != CM_ACLENT_MAGIC\n");
222             return -5;
223         }
224         if (aclp->nextp && aclp->nextp->magic != CM_ACLENT_MAGIC) {
225             afsi_log("cm_ValidateACLCache failure: aclp->nextp->magic != CM_ACLENT_MAGIC");
226             fprintf(stderr, "cm_ValidateACLCache failure: aclp->nextp->magic != CM_ACLENT_MAGIC\n");
227             return -6;
228         }
229         if (aclp->backp && aclp->backp->magic != CM_SCACHE_MAGIC) {
230             afsi_log("cm_ValidateACLCache failure: aclp->backp->magic != CM_SCACHE_MAGIC");
231             fprintf(stderr, "cm_ValidateACLCache failure: aclp->backp->magic != CM_SCACHE_MAGIC\n");
232             return -7;
233         }
234
235         if (count != 0 && aclp == cm_data.aclLRUEndp || count > size) {
236             afsi_log("cm_ValidateACLCache failure: loop in cm_data.aclLRUEndp list");
237             fprintf(stderr, "cm_ValidateACLCache failure: loop in cm_data.aclLRUEndp list\n");
238             return -8;
239         }
240     }
241
242     return 0;
243 }
244
245 /* 
246  * Initialize the cache to have an entries.  Called during system startup.
247  */
248 long cm_InitACLCache(int newFile, long size)
249 {
250     cm_aclent_t *aclp;
251     long i;
252     static osi_once_t once;
253
254     if (osi_Once(&once)) {
255         lock_InitializeRWLock(&cm_aclLock, "cm_aclLock");
256         osi_EndOnce(&once);
257     }
258
259     lock_ObtainWrite(&cm_aclLock);
260     if ( newFile ) {
261         cm_data.aclLRUp = cm_data.aclLRUEndp = NULL;
262         aclp = (cm_aclent_t *) cm_data.aclBaseAddress;
263         memset(aclp, 0, size * sizeof(cm_aclent_t));
264
265         /* 
266          * Put all of these guys on the LRU queue 
267          */
268         for (i = 0; i < size; i++) {
269             aclp->magic = CM_ACLENT_MAGIC;
270             osi_QAddH((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
271             aclp++;
272         }
273     } else {
274         aclp = (cm_aclent_t *) cm_data.aclBaseAddress;
275         for (i = 0; i < size; i++) {
276             aclp->userp = NULL;
277             aclp->tgtLifetime = 0;
278             aclp++;
279         }
280     }
281     lock_ReleaseWrite(&cm_aclLock);
282     return 0;
283 }
284
285
286 /* 
287  * Free all associated acl entries.  We actually just clear the back pointer
288  * since the acl entries are already in the free list.  The scp must be locked
289  * or completely unreferenced (such as when called while recycling the scp).
290  */
291 void cm_FreeAllACLEnts(cm_scache_t *scp)
292 {
293     cm_aclent_t *aclp;
294     cm_aclent_t *taclp;
295
296     lock_ObtainWrite(&cm_aclLock);
297     for (aclp = scp->randomACLp; aclp; aclp = taclp) {
298         taclp = aclp->nextp;
299         if (aclp->userp) {
300             cm_ReleaseUser(aclp->userp);
301             aclp->userp = NULL;
302         }
303         aclp->backp = (struct cm_scache *) 0;
304     }
305
306     scp->randomACLp = (struct cm_aclent *) 0;
307     scp->anyAccess = 0;         /* reset this, too */
308     lock_ReleaseWrite(&cm_aclLock);
309 }
310
311
312 /* 
313  * Invalidate all ACL entries for particular user on this particular vnode.
314  *
315  * The scp must be locked.
316  */
317 void cm_InvalidateACLUser(cm_scache_t *scp, cm_user_t *userp)
318 {
319     cm_aclent_t *aclp;
320     cm_aclent_t **laclpp;
321
322     lock_ObtainWrite(&cm_aclLock);
323     laclpp = &scp->randomACLp;
324     for (aclp = *laclpp; aclp; laclpp = &aclp->nextp, aclp = *laclpp) {
325         if (userp == aclp->userp) {     /* One for a given user/scache */
326             *laclpp = aclp->nextp;
327             cm_ReleaseUser(aclp->userp);
328             aclp->userp = NULL;
329             aclp->backp = (struct cm_scache *) 0;
330             break;
331         }
332     }
333     lock_ReleaseWrite(&cm_aclLock);
334 }