3c01da5cd3d70eab67dcd2ef91402b9d86d9d735
[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 <afsconfig.h>
11 #include <afs/param.h>
12 #include <roken.h>
13
14 #include <afs/stds.h>
15
16 #include <windows.h>
17 #include <stdlib.h>
18 #include <string.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_AssertWrite(&aclp->backp->rw);
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, afs_uint32 *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 <= time(NULL)) {
84                 /* ticket expired */
85                 osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &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.aclLRUp != aclp) {
95                     /* move to the head of the LRU queue */
96                     osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
97                     osi_QAddH((osi_queue_t **) &cm_data.aclLRUp,
98                               (osi_queue_t **) &cm_data.aclLRUEndp,
99                               &aclp->q);
100                 }
101                 retval = 0;     /* success */
102             }
103             break;
104         }
105     }
106
107     lock_ReleaseWrite(&cm_aclLock);
108     return retval;
109 }
110
111 /*
112  * This function returns a free (not in the LRU queue) acl cache entry.
113  * It must be called with the cm_aclLock lock held
114  */
115 static cm_aclent_t *GetFreeACLEnt(cm_scache_t * scp)
116 {
117     cm_aclent_t *aclp;
118     cm_scache_t *ascp = 0;
119
120     if (cm_data.aclLRUp == NULL)
121         osi_panic("empty aclent LRU", __FILE__, __LINE__);
122
123     if (cm_data.aclLRUEndp == NULL)
124         osi_panic("inconsistent aclent LRUEndp == NULL", __FILE__, __LINE__);
125
126     aclp = cm_data.aclLRUEndp;
127     osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
128
129     if (aclp->backp && scp != aclp->backp) {
130         ascp = aclp->backp;
131         lock_ReleaseWrite(&cm_aclLock);
132         lock_ObtainWrite(&ascp->rw);
133         lock_ObtainWrite(&cm_aclLock);
134     }
135     CleanupACLEnt(aclp);
136
137     if (ascp)
138         lock_ReleaseWrite(&ascp->rw);
139     return aclp;
140 }
141
142 time_t cm_TGTLifeTime(cm_user_t *userp, afs_uint32 cellID)
143 {
144     cm_cell_t *cellp = NULL;
145     cm_ucell_t * ucp = NULL;
146     time_t      expirationTime = 0;
147
148     lock_ObtainMutex(&userp->mx);
149     cellp = cm_FindCellByID(cellID, CM_FLAG_NOPROBE);
150     ucp = cm_GetUCell(userp, cellp);
151     if (ucp->ticketp)
152         expirationTime = ucp->expirationTime;
153     lock_ReleaseMutex(&userp->mx);
154
155     return expirationTime;
156 }
157
158
159 /*
160  * Add rights to an acl cache entry.  Do the right thing if not present,
161  * including digging up an entry from the LRU queue.
162  *
163  * The scp must be locked when this function is called.
164  */
165 long cm_AddACLCache(cm_scache_t *scp, cm_user_t *userp, afs_uint32 rights)
166 {
167     struct cm_aclent *aclp;
168     time_t tgtLifeTime;
169
170     tgtLifeTime = cm_TGTLifeTime(userp, scp->fid.cell);
171
172     lock_ObtainWrite(&cm_aclLock);
173     for (aclp = scp->randomACLp; aclp; aclp = aclp->nextp) {
174         if (aclp->userp == userp) {
175             aclp->randomAccess = rights;
176             if (aclp->tgtLifetime < tgtLifeTime)
177                 aclp->tgtLifetime = tgtLifeTime;
178             if (cm_data.aclLRUp != aclp) {
179                 /* move to the head of the LRU queue */
180                 osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
181                 osi_QAddH((osi_queue_t **) &cm_data.aclLRUp,
182                            (osi_queue_t **) &cm_data.aclLRUEndp,
183                            &aclp->q);
184             }
185             lock_ReleaseWrite(&cm_aclLock);
186             return 0;
187         }
188     }
189
190     /*
191      * Didn't find the dude we're looking for, so take someone from the LRUQ
192      * and  reuse. But first try the free list and see if there's already
193      * someone there.
194      */
195     aclp = GetFreeACLEnt(scp);           /* can't fail, panics instead */
196     osi_QAddH((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
197     aclp->backp = scp;
198     aclp->nextp = scp->randomACLp;
199     scp->randomACLp = aclp;
200     cm_HoldUser(userp);
201     aclp->userp = userp;
202     aclp->randomAccess = rights;
203     aclp->tgtLifetime = tgtLifeTime;
204     lock_ReleaseWrite(&cm_aclLock);
205
206     return 0;
207 }
208
209 long cm_ShutdownACLCache(void)
210 {
211     return 0;
212 }
213
214 long cm_ValidateACLCache(void)
215 {
216     long size = cm_data.stats * 2;
217     long count;
218     cm_aclent_t * aclp;
219
220     if ( cm_data.aclLRUp == NULL && cm_data.aclLRUEndp != NULL ||
221          cm_data.aclLRUp != NULL && cm_data.aclLRUEndp == NULL) {
222         afsi_log("cm_ValidateACLCache failure: inconsistent LRU pointers");
223         fprintf(stderr, "cm_ValidateACLCache failure: inconsistent LRU pointers\n");
224         return -9;
225     }
226
227     for ( aclp = cm_data.aclLRUp, count = 0; aclp;
228           aclp = (cm_aclent_t *) osi_QNext(&aclp->q), count++ ) {
229         if (aclp->magic != CM_ACLENT_MAGIC) {
230             afsi_log("cm_ValidateACLCache failure: acpl->magic != CM_ACLENT_MAGIC");
231             fprintf(stderr, "cm_ValidateACLCache failure: acpl->magic != CM_ACLENT_MAGIC\n");
232             return -1;
233         }
234         if (aclp->nextp && aclp->nextp->magic != CM_ACLENT_MAGIC) {
235             afsi_log("cm_ValidateACLCache failure: acpl->nextp->magic != CM_ACLENT_MAGIC");
236             fprintf(stderr,"cm_ValidateACLCache failure: acpl->nextp->magic != CM_ACLENT_MAGIC\n");
237             return -2;
238         }
239         if (aclp->backp && aclp->backp->magic != CM_SCACHE_MAGIC) {
240             afsi_log("cm_ValidateACLCache failure: acpl->backp->magic != CM_SCACHE_MAGIC");
241             fprintf(stderr,"cm_ValidateACLCache failure: acpl->backp->magic != CM_SCACHE_MAGIC\n");
242             return -3;
243         }
244         if (count != 0 && aclp == cm_data.aclLRUp || count > size) {
245             afsi_log("cm_ValidateACLCache failure: loop in cm_data.aclLRUp list");
246             fprintf(stderr, "cm_ValidateACLCache failure: loop in cm_data.aclLRUp list\n");
247             return -4;
248         }
249     }
250
251     for ( aclp = cm_data.aclLRUEndp, count = 0; aclp;
252           aclp = (cm_aclent_t *) osi_QPrev(&aclp->q), count++ ) {
253         if (aclp->magic != CM_ACLENT_MAGIC) {
254             afsi_log("cm_ValidateACLCache failure: aclp->magic != CM_ACLENT_MAGIC");
255             fprintf(stderr, "cm_ValidateACLCache failure: aclp->magic != CM_ACLENT_MAGIC\n");
256             return -5;
257         }
258         if (aclp->nextp && aclp->nextp->magic != CM_ACLENT_MAGIC) {
259             afsi_log("cm_ValidateACLCache failure: aclp->nextp->magic != CM_ACLENT_MAGIC");
260             fprintf(stderr, "cm_ValidateACLCache failure: aclp->nextp->magic != CM_ACLENT_MAGIC\n");
261             return -6;
262         }
263         if (aclp->backp && aclp->backp->magic != CM_SCACHE_MAGIC) {
264             afsi_log("cm_ValidateACLCache failure: aclp->backp->magic != CM_SCACHE_MAGIC");
265             fprintf(stderr, "cm_ValidateACLCache failure: aclp->backp->magic != CM_SCACHE_MAGIC\n");
266             return -7;
267         }
268
269         if (count != 0 && aclp == cm_data.aclLRUEndp || count > size) {
270             afsi_log("cm_ValidateACLCache failure: loop in cm_data.aclLRUEndp list");
271             fprintf(stderr, "cm_ValidateACLCache failure: loop in cm_data.aclLRUEndp list\n");
272             return -8;
273         }
274     }
275
276     return 0;
277 }
278
279 /*
280  * Initialize the cache to have an entries.  Called during system startup.
281  */
282 long cm_InitACLCache(int newFile, long size)
283 {
284     cm_aclent_t *aclp;
285     long i;
286     static osi_once_t once;
287
288     if (osi_Once(&once)) {
289         lock_InitializeRWLock(&cm_aclLock, "cm_aclLock", LOCK_HIERARCHY_ACL_GLOBAL);
290         osi_EndOnce(&once);
291     }
292
293     lock_ObtainWrite(&cm_aclLock);
294     if ( newFile ) {
295         cm_data.aclLRUp = cm_data.aclLRUEndp = NULL;
296         aclp = (cm_aclent_t *) cm_data.aclBaseAddress;
297         memset(aclp, 0, size * sizeof(cm_aclent_t));
298
299         /*
300          * Put all of these guys on the LRU queue
301          */
302         for (i = 0; i < size; i++) {
303             aclp->magic = CM_ACLENT_MAGIC;
304             osi_QAddH((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
305             aclp++;
306         }
307     } else {
308         aclp = (cm_aclent_t *) cm_data.aclBaseAddress;
309         for (i = 0; i < size; i++) {
310             aclp->userp = NULL;
311             aclp->tgtLifetime = 0;
312             aclp++;
313         }
314     }
315     lock_ReleaseWrite(&cm_aclLock);
316     return 0;
317 }
318
319
320 /*
321  * Free all associated acl entries.  We actually just clear the back pointer
322  * since the acl entries are already in the free list.  The scp must be locked
323  * or completely unreferenced (such as when called while recycling the scp).
324  */
325 void cm_FreeAllACLEnts(cm_scache_t *scp)
326 {
327     cm_aclent_t *aclp;
328     cm_aclent_t *taclp;
329
330     lock_ObtainWrite(&cm_aclLock);
331     for (aclp = scp->randomACLp; aclp; aclp = taclp) {
332         taclp = aclp->nextp;
333         if (aclp->userp) {
334             cm_ReleaseUser(aclp->userp);
335             aclp->userp = NULL;
336         }
337         aclp->backp = (struct cm_scache *) 0;
338     }
339
340     scp->randomACLp = (struct cm_aclent *) 0;
341     scp->anyAccess = 0;         /* reset this, too */
342     lock_ReleaseWrite(&cm_aclLock);
343 }
344
345
346 /*
347  * Invalidate all ACL entries for particular user on this particular vnode.
348  *
349  * The scp must not be locked.
350  */
351 void cm_InvalidateACLUser(cm_scache_t *scp, cm_user_t *userp)
352 {
353     cm_aclent_t *aclp;
354     cm_aclent_t **laclpp;
355     int found = 0;
356     int callback = 0;
357
358     lock_ObtainWrite(&scp->rw);
359     lock_ObtainWrite(&cm_aclLock);
360     laclpp = &scp->randomACLp;
361     for (aclp = *laclpp; aclp; laclpp = &aclp->nextp, aclp = *laclpp) {
362         if (userp == aclp->userp) {     /* One for a given user/scache */
363             *laclpp = aclp->nextp;
364             cm_ReleaseUser(aclp->userp);
365             aclp->userp = NULL;
366             aclp->backp = (struct cm_scache *) 0;
367             found = 1;
368             break;
369         }
370     }
371     lock_ReleaseWrite(&cm_aclLock);
372     if (found)
373         callback = cm_HaveCallback(scp);
374     lock_ReleaseWrite(&scp->rw);
375
376     if (found && callback && RDR_Initialized)
377         RDR_InvalidateObject(scp->fid.cell, scp->fid.volume, scp->fid.vnode, scp->fid.unique,
378                              scp->fid.hash, scp->fileType, AFS_INVALIDATE_CREDS);
379 }
380
381 /*
382  * Invalidate ACL info for a user that has just obtained or lost tokens.
383  */
384 void
385 cm_ResetACLCache(cm_cell_t *cellp, cm_user_t *userp)
386 {
387     cm_volume_t *volp, *nextVolp;
388     cm_scache_t *scp, *nextScp;
389     afs_uint32 hash;
390
391     lock_ObtainRead(&cm_scacheLock);
392     for (hash=0; hash < cm_data.scacheHashTableSize; hash++) {
393         for (scp=cm_data.scacheHashTablep[hash]; scp; scp=nextScp) {
394             nextScp = scp->nextp;
395             if (cellp == NULL ||
396                 scp->fid.cell == cellp->cellID) {
397                 cm_HoldSCacheNoLock(scp);
398                 lock_ReleaseRead(&cm_scacheLock);
399                 cm_InvalidateACLUser(scp, userp);
400                 lock_ObtainRead(&cm_scacheLock);
401                 cm_ReleaseSCacheNoLock(scp);
402             }
403         }
404     }
405     lock_ReleaseRead(&cm_scacheLock);
406
407     cm_EAccesClearUserEntries(userp, cellp->cellID);
408
409     if (RDR_Initialized) {
410         lock_ObtainRead(&cm_volumeLock);
411         for (hash = 0; hash < cm_data.volumeHashTableSize; hash++) {
412             for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = nextVolp) {
413                 nextVolp = volp->vol[RWVOL].nextp;
414                 if ((cellp == NULL || cellp->cellID == volp->cellp->cellID) &&
415                     volp->vol[RWVOL].ID) {
416                     lock_ReleaseRead(&cm_volumeLock);
417                     RDR_InvalidateVolume(volp->cellp->cellID, volp->vol[RWVOL].ID, AFS_INVALIDATE_CREDS);
418                     lock_ObtainRead(&cm_volumeLock);
419                 }
420             }
421             for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = nextVolp) {
422                 nextVolp = volp->vol[ROVOL].nextp;
423                 if ((cellp == NULL || cellp->cellID == volp->cellp->cellID) &&
424                     volp->vol[ROVOL].ID) {
425                     lock_ReleaseRead(&cm_volumeLock);
426                     RDR_InvalidateVolume(volp->cellp->cellID, volp->vol[ROVOL].ID, AFS_INVALIDATE_CREDS);
427                     lock_ObtainRead(&cm_volumeLock);
428                 }
429             }
430             for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = nextVolp) {
431                 nextVolp = volp->vol[BACKVOL].nextp;
432                 if ((cellp == NULL || cellp->cellID == volp->cellp->cellID) &&
433                     volp->vol[BACKVOL].ID) {
434                     lock_ReleaseRead(&cm_volumeLock);
435                     RDR_InvalidateVolume(volp->cellp->cellID, volp->vol[BACKVOL].ID, AFS_INVALIDATE_CREDS);
436                     lock_ObtainRead(&cm_volumeLock);
437                 }
438             }
439         }
440         lock_ReleaseRead(&cm_volumeLock);
441     }
442 }
443
444