vcache-cleanup-20050529
[openafs.git] / src / afs / afs_vcache.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 /*
11  * Implements:
12  * afs_FlushVCache
13  * afs_AllocCBR
14  * afs_FreeCBR
15  * afs_FlushVCBs
16  * afs_QueueVCB
17  * afs_RemoveVCB
18  * afs_NewVCache
19  * afs_FlushActiveVcaches
20  * afs_VerifyVCache2
21  * afs_WriteVCache
22  * afs_SimpleVStat
23  * afs_ProcessFS
24  * TellALittleWhiteLie
25  * afs_RemoteLookup
26  * afs_GetVCache
27  * afs_LookupVCache
28  * afs_GetRootVCache
29  * afs_FetchStatus
30  * afs_StuffVcache
31  * afs_PutVCache
32  * afs_FindVCache
33  * afs_NFSFindVCache
34  * afs_vcacheInit
35  * shutdown_vcache
36  *
37  */
38 #include <afsconfig.h>
39 #include "afs/param.h"
40
41 RCSID
42     ("$Header$");
43
44 #include "afs/sysincludes.h"    /*Standard vendor system headers */
45 #include "afsincludes.h"        /*AFS-based standard headers */
46 #include "afs/afs_stats.h"
47 #include "afs/afs_cbqueue.h"
48 #include "afs/afs_osidnlc.h"
49
50 #ifdef AFS_OSF_ENV
51 afs_int32 afs_maxvcount = 0;    /* max number of vcache entries */
52 afs_int32 afs_vcount = 0;       /* number of vcache in use now */
53 #endif /* AFS_OSF_ENV */
54
55 #ifdef AFS_SGI_ENV
56 int afsvnumbers = 0;
57 #endif
58
59 #ifdef AFS_SGI64_ENV
60 char *makesname();
61 #endif /* AFS_SGI64_ENV */
62
63 /* Exported variables */
64 afs_rwlock_t afs_xvcache;       /*Lock: alloc new stat cache entries */
65 afs_lock_t afs_xvcb;            /*Lock: fids on which there are callbacks */
66 struct vcache *freeVCList;      /*Free list for stat cache entries */
67 struct vcache *Initial_freeVCList;      /*Initial list for above */
68 struct afs_q VLRU;              /*vcache LRU */
69 afs_int32 vcachegen = 0;
70 unsigned int afs_paniconwarn = 0;
71 struct vcache *afs_vhashT[VCSIZE];
72 struct vcache *afs_vhashTV[VCSIZE];
73 static struct afs_cbr *afs_cbrHashT[CBRSIZE];
74 afs_int32 afs_bulkStatsLost;
75 int afs_norefpanic = 0;
76
77 /* Forward declarations */
78 static afs_int32 afs_QueueVCB(struct vcache *avc);
79
80 /*
81  * afs_HashCBRFid
82  *
83  * Generate an index into the hash table for a given Fid.
84  */
85 static int
86 afs_HashCBRFid(struct AFSFid *fid)
87 {
88     return (fid->Volume + fid->Vnode + fid->Unique) % CBRSIZE;
89 }
90
91 /*
92  * afs_InsertHashCBR
93  *
94  * Insert a CBR entry into the hash table.
95  * Must be called with afs_xvcb held.
96  */
97 static void
98 afs_InsertHashCBR(struct afs_cbr *cbr)
99 {
100     int slot = afs_HashCBRFid(&cbr->fid);
101
102     cbr->hash_next = afs_cbrHashT[slot];
103     if (afs_cbrHashT[slot])
104         afs_cbrHashT[slot]->hash_pprev = &cbr->hash_next;
105
106     cbr->hash_pprev = &afs_cbrHashT[slot];
107     afs_cbrHashT[slot] = cbr;
108 }
109
110 /*
111  * afs_FlushVCache
112  *
113  * Description:
114  *      Flush the given vcache entry.
115  *
116  * Parameters:
117  *      avc : Pointer to vcache entry to flush.
118  *      slept : Pointer to int to set 1 if we sleep/drop locks, 0 if we don't.
119  *
120  * Environment:
121  *      afs_xvcache lock must be held for writing upon entry to
122  *      prevent people from changing the vrefCount field, and to
123  *      protect the lruq and hnext fields.
124  * LOCK: afs_FlushVCache afs_xvcache W
125  * REFCNT: vcache ref count must be zero on entry except for osf1
126  * RACE: lock is dropped and reobtained, permitting race in caller
127  */
128
129 int
130 afs_FlushVCache(struct vcache *avc, int *slept)
131 {                               /*afs_FlushVCache */
132
133     afs_int32 i, code, j;
134     struct vcache **uvc, *wvc, **uvc2, *wvc2;
135
136     *slept = 0;
137     AFS_STATCNT(afs_FlushVCache);
138     afs_Trace2(afs_iclSetp, CM_TRACE_FLUSHV, ICL_TYPE_POINTER, avc,
139                ICL_TYPE_INT32, avc->states);
140 #ifdef  AFS_OSF_ENV
141     AFS_GUNLOCK();
142     VN_LOCK(AFSTOV(avc));
143     AFS_GLOCK();
144 #endif
145
146     code = osi_VM_FlushVCache(avc, slept);
147     if (code)
148         goto bad;
149
150     if (avc->states & CVFlushed) {
151         code = EBUSY;
152         goto bad;
153     }
154     if (avc->nextfree || !avc->vlruq.prev || !avc->vlruq.next) {        /* qv afs.h */
155         refpanic("LRU vs. Free inconsistency");
156     }
157     avc->states |= CVFlushed;
158     /* pull the entry out of the lruq and put it on the free list */
159     QRemove(&avc->vlruq);
160     avc->vlruq.prev = avc->vlruq.next = (struct afs_q *)0;
161
162     /* keep track of # of files that we bulk stat'd, but never used
163      * before they got recycled.
164      */
165     if (avc->states & CBulkStat)
166         afs_bulkStatsLost++;
167     vcachegen++;
168     /* remove entry from the hash chain */
169     i = VCHash(&avc->fid);
170     uvc = &afs_vhashT[i];
171     for (wvc = *uvc; wvc; uvc = &wvc->hnext, wvc = *uvc) {
172         if (avc == wvc) {
173             *uvc = avc->hnext;
174             avc->hnext = (struct vcache *)NULL;
175             break;
176         }
177     }
178
179     /* remove entry from the volume hash table */
180     j = VCHashV(&avc->fid);
181     uvc2 = &afs_vhashTV[j];
182     for (wvc2 = *uvc2; wvc2; uvc2 = &wvc2->vhnext, wvc2 = *uvc2) {
183         if (avc == wvc2) {
184             *uvc2 = avc->vhnext;
185             avc->vhnext = (struct vcache *)NULL;
186             break;
187         }
188     }
189     if (!wvc || !wvc2)
190         osi_Panic("flushvcache");       /* not in correct hash bucket */
191     if (avc->mvid)
192         osi_FreeSmallSpace(avc->mvid);
193     avc->mvid = (struct VenusFid *)0;
194     if (avc->linkData) {
195         afs_osi_Free(avc->linkData, strlen(avc->linkData) + 1);
196         avc->linkData = NULL;
197     }
198 #if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
199     /* OK, there are no internal vrefCounts, so there shouldn't
200      * be any more refs here. */
201     if (avc->v) {
202         avc->v->v_data = NULL;  /* remove from vnode */
203         avc->v = NULL;          /* also drop the ptr to vnode */
204     }
205 #endif
206     afs_FreeAllAxs(&(avc->Access));
207
208     /* we can't really give back callbacks on RO files, since the
209      * server only tracks them on a per-volume basis, and we don't
210      * know whether we still have some other files from the same
211      * volume. */
212     if ((avc->states & CRO) == 0 && avc->callback) {
213         afs_QueueVCB(avc);
214     }
215     ObtainWriteLock(&afs_xcbhash, 460);
216     afs_DequeueCallback(avc);   /* remove it from queued callbacks list */
217     avc->states &= ~(CStatd | CUnique);
218     ReleaseWriteLock(&afs_xcbhash);
219     if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1))
220         osi_dnlc_purgedp(avc);  /* if it (could be) a directory */
221     else
222         osi_dnlc_purgevp(avc);
223
224     /*
225      * Next, keep track of which vnodes we've deleted for create's
226      * optimistic synchronization algorithm
227      */
228     afs_allZaps++;
229     if (avc->fid.Fid.Vnode & 1)
230         afs_oddZaps++;
231     else
232         afs_evenZaps++;
233
234 #if     !defined(AFS_OSF_ENV)
235     /* put the entry in the free list */
236     avc->nextfree = freeVCList;
237     freeVCList = avc;
238     if (avc->vlruq.prev || avc->vlruq.next) {
239         refpanic("LRU vs. Free inconsistency");
240     }
241 #else
242     /* This should put it back on the vnode free list since usecount is 1 */
243     afs_vcount--;
244     vSetType(avc, VREG);
245     if (VREFCOUNT(avc) > 0) {
246         VN_UNLOCK(AFSTOV(avc));
247         AFS_RELE(AFSTOV(avc));
248     } else {
249         if (afs_norefpanic) {
250             printf("flush vc refcnt < 1");
251             afs_norefpanic++;
252             (void)vgone(avc, VX_NOSLEEP, NULL);
253             AFS_GLOCK();
254             VN_UNLOCK(AFSTOV(avc));
255         } else
256             osi_Panic("flush vc refcnt < 1");
257     }
258 #endif /* AFS_OSF_ENV */
259     avc->states |= CVFlushed;
260     return 0;
261
262   bad:
263 #ifdef  AFS_OSF_ENV
264     VN_UNLOCK(AFSTOV(avc));
265 #endif
266     return code;
267
268 }                               /*afs_FlushVCache */
269
270 #ifndef AFS_SGI_ENV
271 /*
272  * afs_InactiveVCache
273  *
274  * The core of the inactive vnode op for all but IRIX.
275  */
276 void
277 afs_InactiveVCache(struct vcache *avc, struct AFS_UCRED *acred)
278 {
279     AFS_STATCNT(afs_inactive);
280     if (avc->states & CDirty) {
281         /* we can't keep trying to push back dirty data forever.  Give up. */
282         afs_InvalidateAllSegments(avc); /* turns off dirty bit */
283     }
284     avc->states &= ~CMAPPED;    /* mainly used by SunOS 4.0.x */
285     avc->states &= ~CDirty;     /* Turn it off */
286     if (avc->states & CUnlinked) {
287         if (CheckLock(&afs_xvcache) || CheckLock(&afs_xdcache)) {
288             avc->states |= CUnlinkedDel;
289             return;
290         }
291         afs_remunlink(avc, 1);  /* ignore any return code */
292     }
293
294 }
295 #endif
296
297 /*
298  * afs_AllocCBR
299  *
300  * Description: allocate a callback return structure from the
301  * free list and return it.
302  *
303  * Env: The alloc and free routines are both called with the afs_xvcb lock
304  * held, so we don't have to worry about blocking in osi_Alloc.
305  */
306 static struct afs_cbr *afs_cbrSpace = 0;
307 struct afs_cbr *
308 afs_AllocCBR(void)
309 {
310     register struct afs_cbr *tsp;
311     int i;
312
313     while (!afs_cbrSpace) {
314         if (afs_stats_cmperf.CallBackAlloced >= 2) {
315             /* don't allocate more than 2 * AFS_NCBRS for now */
316             afs_FlushVCBs(0);
317             afs_stats_cmperf.CallBackFlushes++;
318         } else {
319             /* try allocating */
320             tsp =
321                 (struct afs_cbr *)afs_osi_Alloc(AFS_NCBRS *
322                                                 sizeof(struct afs_cbr));
323             for (i = 0; i < AFS_NCBRS - 1; i++) {
324                 tsp[i].next = &tsp[i + 1];
325             }
326             tsp[AFS_NCBRS - 1].next = 0;
327             afs_cbrSpace = tsp;
328             afs_stats_cmperf.CallBackAlloced++;
329         }
330     }
331     tsp = afs_cbrSpace;
332     afs_cbrSpace = tsp->next;
333     return tsp;
334 }
335
336 /*
337  * afs_FreeCBR
338  *
339  * Description: free a callback return structure, removing it from all lists.
340  *
341  * Parameters:
342  *      asp -- the address of the structure to free.
343  *
344  * Environment: the xvcb lock is held over these calls.
345  */
346 int
347 afs_FreeCBR(register struct afs_cbr *asp)
348 {
349     *(asp->pprev) = asp->next;
350     if (asp->next)
351         asp->next->pprev = asp->pprev;
352
353     *(asp->hash_pprev) = asp->hash_next;
354     if (asp->hash_next)
355         asp->hash_next->hash_pprev = asp->hash_pprev;
356
357     asp->next = afs_cbrSpace;
358     afs_cbrSpace = asp;
359     return 0;
360 }
361
362 /*
363  * afs_FlushVCBs
364  *
365  * Description: flush all queued callbacks to all servers.
366  *
367  * Parameters: none.
368  *
369  * Environment: holds xvcb lock over RPC to guard against race conditions
370  *      when a new callback is granted for the same file later on.
371  */
372 afs_int32
373 afs_FlushVCBs(afs_int32 lockit)
374 {
375     struct AFSFid *tfids;
376     struct AFSCallBack callBacks[1];
377     struct AFSCBFids fidArray;
378     struct AFSCBs cbArray;
379     afs_int32 code;
380     struct afs_cbr *tcbrp;
381     int tcount;
382     struct server *tsp;
383     int i;
384     struct vrequest treq;
385     struct conn *tc;
386     int safety1, safety2, safety3;
387     XSTATS_DECLS;
388     if ((code = afs_InitReq(&treq, afs_osi_credp)))
389         return code;
390     treq.flags |= O_NONBLOCK;
391     tfids = afs_osi_Alloc(sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
392
393     if (lockit)
394         MObtainWriteLock(&afs_xvcb, 273);
395     ObtainReadLock(&afs_xserver);
396     for (i = 0; i < NSERVERS; i++) {
397         for (safety1 = 0, tsp = afs_servers[i];
398              tsp && safety1 < afs_totalServers + 10;
399              tsp = tsp->next, safety1++) {
400             /* don't have any */
401             if (tsp->cbrs == (struct afs_cbr *)0)
402                 continue;
403
404             /* otherwise, grab a block of AFS_MAXCBRSCALL from the list
405              * and make an RPC, over and over again.
406              */
407             tcount = 0;         /* number found so far */
408             for (safety2 = 0; safety2 < afs_cacheStats; safety2++) {
409                 if (tcount >= AFS_MAXCBRSCALL || !tsp->cbrs) {
410                     /* if buffer is full, or we've queued all we're going
411                      * to from this server, we should flush out the
412                      * callbacks.
413                      */
414                     fidArray.AFSCBFids_len = tcount;
415                     fidArray.AFSCBFids_val = (struct AFSFid *)tfids;
416                     cbArray.AFSCBs_len = 1;
417                     cbArray.AFSCBs_val = callBacks;
418                     memset(&callBacks[0], 0, sizeof(callBacks[0]));
419                     callBacks[0].CallBackType = CB_EXCLUSIVE;
420                     for (safety3 = 0; safety3 < MAXHOSTS * 2; safety3++) {
421                         tc = afs_ConnByHost(tsp, tsp->cell->fsport,
422                                             tsp->cell->cellNum, &treq, 0,
423                                             SHARED_LOCK);
424                         if (tc) {
425                             XSTATS_START_TIME
426                                 (AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS);
427                             RX_AFS_GUNLOCK();
428                             code =
429                                 RXAFS_GiveUpCallBacks(tc->id, &fidArray,
430                                                       &cbArray);
431                             RX_AFS_GLOCK();
432                             XSTATS_END_TIME;
433                         } else
434                             code = -1;
435                         if (!afs_Analyze
436                             (tc, code, 0, &treq,
437                              AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS, SHARED_LOCK,
438                              tsp->cell)) {
439                             break;
440                         }
441                     }
442                     /* ignore return code, since callbacks may have
443                      * been returned anyway, we shouldn't leave them
444                      * around to be returned again.
445                      *
446                      * Next, see if we are done with this server, and if so,
447                      * break to deal with the next one.
448                      */
449                     if (!tsp->cbrs)
450                         break;
451                     tcount = 0;
452                 }
453                 /* if to flush full buffer */
454                 /* if we make it here, we have an entry at the head of cbrs,
455                  * which we should copy to the file ID array and then free.
456                  */
457                 tcbrp = tsp->cbrs;
458                 tfids[tcount++] = tcbrp->fid;
459
460                 /* Freeing the CBR will unlink it from the server's CBR list */
461                 afs_FreeCBR(tcbrp);
462             }                   /* while loop for this one server */
463             if (safety2 > afs_cacheStats) {
464                 afs_warn("possible internal error afs_flushVCBs (%d)\n",
465                          safety2);
466             }
467         }                       /* for loop for this hash chain */
468     }                           /* loop through all hash chains */
469     if (safety1 > afs_totalServers + 2) {
470         afs_warn
471             ("AFS internal error (afs_flushVCBs) (%d > %d), continuing...\n",
472              safety1, afs_totalServers + 2);
473         if (afs_paniconwarn)
474             osi_Panic("afs_flushVCBS safety1");
475     }
476
477     ReleaseReadLock(&afs_xserver);
478     if (lockit)
479         MReleaseWriteLock(&afs_xvcb);
480     afs_osi_Free(tfids, sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
481     return 0;
482 }
483
484 /*
485  * afs_QueueVCB
486  *
487  * Description:
488  *      Queue a callback on the given fid.
489  *
490  * Parameters:
491  *      avc: vcache entry
492  *
493  * Environment:
494  *      Locks the xvcb lock.
495  *      Called when the xvcache lock is already held.
496  */
497
498 static afs_int32
499 afs_QueueVCB(struct vcache *avc)
500 {
501     struct server *tsp;
502     struct afs_cbr *tcbp;
503
504     AFS_STATCNT(afs_QueueVCB);
505     /* The callback is really just a struct server ptr. */
506     tsp = (struct server *)(avc->callback);
507
508     /* we now have a pointer to the server, so we just allocate
509      * a queue entry and queue it.
510      */
511     MObtainWriteLock(&afs_xvcb, 274);
512     tcbp = afs_AllocCBR();
513     tcbp->fid = avc->fid.Fid;
514
515     tcbp->next = tsp->cbrs;
516     if (tsp->cbrs)
517         tsp->cbrs->pprev = &tcbp->next;
518
519     tsp->cbrs = tcbp;
520     tcbp->pprev = &tsp->cbrs;
521
522     afs_InsertHashCBR(tcbp);
523
524     /* now release locks and return */
525     MReleaseWriteLock(&afs_xvcb);
526     return 0;
527 }
528
529
530 /*
531  * afs_RemoveVCB
532  *
533  * Description:
534  *      Remove a queued callback for a given Fid.
535  *
536  * Parameters:
537  *      afid: The fid we want cleansed of queued callbacks.
538  *
539  * Environment:
540  *      Locks xvcb and xserver locks.
541  *      Typically called with xdcache, xvcache and/or individual vcache
542  *      entries locked.
543  */
544
545 void
546 afs_RemoveVCB(struct VenusFid *afid)
547 {
548     int slot;
549     struct afs_cbr *cbr, *ncbr;
550
551     AFS_STATCNT(afs_RemoveVCB);
552     MObtainWriteLock(&afs_xvcb, 275);
553
554     slot = afs_HashCBRFid(&afid->Fid);
555     ncbr = afs_cbrHashT[slot];
556
557     while (ncbr) {
558         cbr = ncbr;
559         ncbr = cbr->hash_next;
560
561         if (afid->Fid.Volume == cbr->fid.Volume &&
562             afid->Fid.Vnode == cbr->fid.Vnode &&
563             afid->Fid.Unique == cbr->fid.Unique) {
564             afs_FreeCBR(cbr);
565         }
566     }
567
568     MReleaseWriteLock(&afs_xvcb);
569 }
570
571 /*
572  * afs_NewVCache
573  *
574  * Description:
575  *      This routine is responsible for allocating a new cache entry
576  *      from the free list.  It formats the cache entry and inserts it
577  *      into the appropriate hash tables.  It must be called with
578  *      afs_xvcache write-locked so as to prevent several processes from
579  *      trying to create a new cache entry simultaneously.
580  *
581  * Parameters:
582  *      afid  : The file id of the file whose cache entry is being
583  *              created.
584  */
585 /* LOCK: afs_NewVCache  afs_xvcache W */
586 struct vcache *
587 afs_NewVCache(struct VenusFid *afid, struct server *serverp)
588 {
589     struct vcache *tvc;
590     afs_int32 i, j;
591     afs_int32 anumber = VCACHE_FREE;
592 #ifdef  AFS_AIX_ENV
593     struct gnode *gnodepnt;
594 #endif
595 #ifdef  AFS_OSF_ENV
596     struct vcache *nvc;
597 #endif /* AFS_OSF_ENV */
598     struct afs_q *tq, *uq;
599     int code, fv_slept;
600
601     AFS_STATCNT(afs_NewVCache);
602 #ifdef  AFS_OSF_ENV
603 #ifdef  AFS_OSF30_ENV
604     if (afs_vcount >= afs_maxvcount) {
605 #else
606     /*
607      * If we are using > 33 % of the total system vnodes for AFS vcache
608      * entries or we are using the maximum number of vcache entries,
609      * then free some.  (if our usage is > 33% we should free some, if
610      * our usage is > afs_maxvcount, set elsewhere to 0.5*nvnode,
611      * we _must_ free some -- no choice).
612      */
613     if (((3 * afs_vcount) > nvnode) || (afs_vcount >= afs_maxvcount)) {
614 #endif
615         struct afs_q *tq, *uq;
616         int i;
617         char *panicstr;
618
619         i = 0;
620         for (tq = VLRU.prev; tq != &VLRU && anumber > 0; tq = uq) {
621             tvc = QTOV(tq);
622             uq = QPrev(tq);
623             if (tvc->states & CVFlushed)
624                 refpanic("CVFlushed on VLRU");
625             else if (i++ > afs_maxvcount)
626                 refpanic("Exceeded pool of AFS vnodes(VLRU cycle?)");
627             else if (QNext(uq) != tq)
628                 refpanic("VLRU inconsistent");
629             else if (VREFCOUNT(tvc) < 1)
630                 refpanic("refcnt 0 on VLRU");
631
632             if (VREFCOUNT(tvc) == 1 && tvc->opens == 0
633                 && (tvc->states & CUnlinkedDel) == 0) {
634                 code = afs_FlushVCache(tvc, &fv_slept);
635                 if (code == 0) {
636                     anumber--;
637                 }
638                 if (fv_slept) {
639                     uq = VLRU.prev;
640                     i = 0;
641                     continue;   /* start over - may have raced. */
642                 }
643             }
644             if (tq == uq)
645                 break;
646         }
647         if (anumber == VCACHE_FREE) {
648             printf("NewVCache: warning none freed, using %d of %d\n",
649                    afs_vcount, afs_maxvcount);
650             if (afs_vcount >= afs_maxvcount) {
651                 osi_Panic("NewVCache - none freed");
652                 /* XXX instead of panicing, should do afs_maxvcount++
653                  * and magic up another one */
654             }
655         }
656     }
657
658     AFS_GUNLOCK();
659     if (getnewvnode(MOUNT_AFS, &Afs_vnodeops, &nvc)) {
660         /* What should we do ???? */
661         osi_Panic("afs_NewVCache: no more vnodes");
662     }
663     AFS_GLOCK();
664
665     tvc = nvc;
666     tvc->nextfree = NULL;
667     afs_vcount++;
668 #else /* AFS_OSF_ENV */
669     /* pull out a free cache entry */
670     if (!freeVCList) {
671         i = 0;
672         for (tq = VLRU.prev; (anumber > 0) && (tq != &VLRU); tq = uq) {
673             tvc = QTOV(tq);
674             uq = QPrev(tq);
675
676             if (tvc->states & CVFlushed) {
677                 refpanic("CVFlushed on VLRU");
678 #if 0
679             } else if (i++ > 2 * afs_cacheStats) {      /* even allowing for a few xallocs... */
680                 refpanic("Increase -stat parameter of afsd(VLRU cycle?)");
681 #endif
682             } else if (QNext(uq) != tq) {
683                 refpanic("VLRU inconsistent");
684             }
685 #if defined(AFS_LINUX22_ENV)
686             if (tvc != afs_globalVp && VREFCOUNT(tvc) && tvc->opens == 0) {
687                 struct dentry *dentry;
688                 struct list_head *cur, *head = &(AFSTOI(tvc))->i_dentry;
689                 AFS_FAST_HOLD(tvc);
690                 AFS_GUNLOCK();
691
692 restart:
693 #if defined(AFS_LINUX24_ENV)
694                 spin_lock(&dcache_lock);
695 #endif
696                 cur = head;
697                 while ((cur = cur->next) != head) {
698                     dentry = list_entry(cur, struct dentry, d_alias);
699
700                     if (d_unhashed(dentry))
701                         continue;
702
703                     dget_locked(dentry);
704
705 #if defined(AFS_LINUX24_ENV)
706                     spin_unlock(&dcache_lock);
707 #endif
708                     if (d_invalidate(dentry) == -EBUSY) {
709                         dput(dentry);
710                         /* perhaps lock and try to continue? (use cur as head?) */
711                         goto inuse;
712                     }
713                     dput(dentry);
714                     goto restart;
715                 }                   
716 #if defined(AFS_LINUX24_ENV)
717                 spin_unlock(&dcache_lock);
718 #endif
719             inuse:
720                 AFS_GLOCK();
721                 AFS_FAST_RELE(tvc);
722             }
723 #endif
724
725             if (((VREFCOUNT(tvc) == 0) 
726 #if defined(AFS_DARWIN_ENV) && !defined(UKERNEL) 
727                  || ((VREFCOUNT(tvc) == 1) && 
728                      (UBCINFOEXISTS(AFSTOV(tvc))))
729 #endif
730                  ) && tvc->opens == 0 && (tvc->states & CUnlinkedDel) == 0) {
731 #if defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
732                 /*
733                  * vgone() reclaims the vnode, which calls afs_FlushVCache(),
734                  * then it puts the vnode on the free list.
735                  * If we don't do this we end up with a cleaned vnode that's
736                  * not on the free list.
737                  * XXX assume FreeBSD is the same for now.
738                  */
739                 AFS_GUNLOCK();
740                 vgone(AFSTOV(tvc));
741                 AFS_GLOCK();
742                 code = fv_slept = 0;
743 #else
744                 code = afs_FlushVCache(tvc, &fv_slept);
745 #endif
746                 if (code == 0) {
747                     anumber--;
748                 }
749                 if (fv_slept) {
750                     uq = VLRU.prev;
751                     i = 0;
752                     continue;   /* start over - may have raced. */
753                 }
754             }
755             if (tq == uq)
756                 break;
757         }
758     }
759     if (!freeVCList) {
760         /* none free, making one is better than a panic */
761         afs_stats_cmperf.vcacheXAllocs++;       /* count in case we have a leak */
762         if (afs_cacheStats == afs_stats_cmperf.vcacheXAllocs) printf("would vlru cycle panic\n");
763         tvc = (struct vcache *)afs_osi_Alloc(sizeof(struct vcache));
764 #if defined(AFS_DARWIN_ENV) && !defined(UKERNEL)
765         tvc->v = NULL; /* important to clean this, or use memset 0 */
766 #endif
767 #ifdef  KERNEL_HAVE_PIN
768         pin((char *)tvc, sizeof(struct vcache));        /* XXX */
769 #endif
770 #if defined(AFS_SGI_ENV)
771         {
772             char name[METER_NAMSZ];
773             memset(tvc, 0, sizeof(struct vcache));
774             tvc->v.v_number = ++afsvnumbers;
775             tvc->vc_rwlockid = OSI_NO_LOCKID;
776             initnsema(&tvc->vc_rwlock, 1,
777                       makesname(name, "vrw", tvc->v.v_number));
778 #ifndef AFS_SGI53_ENV
779             initnsema(&tvc->v.v_sync, 0,
780                       makesname(name, "vsy", tvc->v.v_number));
781 #endif
782 #ifndef AFS_SGI62_ENV
783             initnlock(&tvc->v.v_lock,
784                       makesname(name, "vlk", tvc->v.v_number));
785 #endif
786         }
787 #endif /* AFS_SGI_ENV */
788     } else {
789         tvc = freeVCList;       /* take from free list */
790         freeVCList = tvc->nextfree;
791         tvc->nextfree = NULL;
792     }
793 #endif /* AFS_OSF_ENV */
794
795 #if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
796     if (tvc->v)
797         panic("afs_NewVCache(): free vcache with vnode attached");
798 #endif
799
800 #if !defined(AFS_SGI_ENV) && !defined(AFS_OSF_ENV)
801     memset((char *)tvc, 0, sizeof(struct vcache));
802 #else
803     tvc->uncred = 0;
804 #endif
805
806     RWLOCK_INIT(&tvc->lock, "vcache lock");
807 #if     defined(AFS_SUN5_ENV)
808     RWLOCK_INIT(&tvc->vlock, "vcache vlock");
809 #endif /* defined(AFS_SUN5_ENV) */
810
811 #ifdef AFS_OBSD_ENV
812     AFS_GUNLOCK();
813     afs_nbsd_getnewvnode(tvc);  /* includes one refcount */
814     AFS_GLOCK();
815     lockinit(&tvc->rwlock, PINOD, "vcache", 0, 0);
816 #endif
817 #ifdef AFS_DARWIN_ENV
818     AFS_GUNLOCK();
819     afs_darwin_getnewvnode(tvc);        /* includes one refcount */
820     AFS_GLOCK();
821     lockinit(&tvc->rwlock, PINOD, "vcache", 0, 0);
822 #endif
823 #ifdef AFS_FBSD_ENV
824     {
825         struct vnode *vp;
826
827         AFS_GUNLOCK();
828 #if defined(AFS_FBSD60_ENV)
829         if (getnewvnode(MOUNT_AFS, afs_globalVFS, &afs_vnodeops, &vp))
830 #elif defined(AFS_FBSD50_ENV)
831         if (getnewvnode(MOUNT_AFS, afs_globalVFS, afs_vnodeop_p, &vp))
832 #else
833         if (getnewvnode(VT_AFS, afs_globalVFS, afs_vnodeop_p, &vp))
834 #endif
835             panic("afs getnewvnode");   /* can't happen */
836         AFS_GLOCK();
837         if (tvc->v != NULL) {
838             /* I'd like to know if this ever happens...
839              * We don't drop global for the rest of this function,
840              * so if we do lose the race, the other thread should
841              * have found the same vnode and finished initializing
842              * the vcache entry.  Is it conceivable that this vcache
843              * entry could be recycled during this interval?  If so,
844              * then there probably needs to be some sort of additional
845              * mutual exclusion (an Embryonic flag would suffice).
846              * -GAW */
847             printf("afs_NewVCache: lost the race\n");
848             return (tvc);
849         }
850         tvc->v = vp;
851         tvc->v->v_data = tvc;
852         lockinit(&tvc->rwlock, PINOD, "vcache", 0, 0);
853     }
854 #endif
855     tvc->parentVnode = 0;
856     tvc->mvid = NULL;
857     tvc->linkData = NULL;
858     tvc->cbExpires = 0;
859     tvc->opens = 0;
860     tvc->execsOrWriters = 0;
861     tvc->flockCount = 0;
862     tvc->anyAccess = 0;
863     tvc->states = 0;
864     tvc->last_looker = 0;
865     tvc->fid = *afid;
866     tvc->asynchrony = -1;
867     tvc->vc_error = 0;
868 #ifdef AFS_TEXT_ENV
869     tvc->flushDV.low = tvc->flushDV.high = AFS_MAXDV;
870 #endif
871     hzero(tvc->mapDV);
872     tvc->truncPos = AFS_NOTRUNC;        /* don't truncate until we need to */
873     hzero(tvc->m.DataVersion);  /* in case we copy it into flushDV */
874 #if defined(AFS_LINUX22_ENV)
875     {
876         struct inode *ip = AFSTOI(tvc);
877 #if defined(AFS_LINUX24_ENV)
878         struct address_space *mapping = &ip->i_data;
879 #endif
880
881 #if defined(AFS_LINUX26_ENV)
882         inode_init_once(ip);
883 #else
884         sema_init(&ip->i_sem, 1);
885         INIT_LIST_HEAD(&ip->i_hash);
886         INIT_LIST_HEAD(&ip->i_dentry);
887 #if defined(AFS_LINUX24_ENV)
888         sema_init(&ip->i_zombie, 1);
889         init_waitqueue_head(&ip->i_wait);
890         spin_lock_init(&ip->i_data.i_shared_lock);
891 #ifdef STRUCT_ADDRESS_SPACE_HAS_PAGE_LOCK
892         spin_lock_init(&ip->i_data.page_lock);
893 #endif
894         INIT_LIST_HEAD(&ip->i_data.clean_pages);
895         INIT_LIST_HEAD(&ip->i_data.dirty_pages);
896         INIT_LIST_HEAD(&ip->i_data.locked_pages);
897         INIT_LIST_HEAD(&ip->i_dirty_buffers);
898 #ifdef STRUCT_INODE_HAS_I_DIRTY_DATA_BUFFERS
899         INIT_LIST_HEAD(&ip->i_dirty_data_buffers);
900 #endif
901 #ifdef STRUCT_INODE_HAS_I_DEVICES
902         INIT_LIST_HEAD(&ip->i_devices);
903 #endif
904 #ifdef STRUCT_INODE_HAS_I_TRUNCATE_SEM
905         init_rwsem(&ip->i_truncate_sem);
906 #endif
907 #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
908         init_rwsem(&ip->i_alloc_sem);
909 #endif
910
911 #else /* AFS_LINUX22_ENV */
912         sema_init(&ip->i_atomic_write, 1);
913         init_waitqueue(&ip->i_wait);
914 #endif
915 #endif
916
917 #if defined(AFS_LINUX24_ENV)
918         mapping->host = ip;
919         ip->i_mapping = mapping;
920 #ifdef STRUCT_ADDRESS_SPACE_HAS_GFP_MASK
921         ip->i_data.gfp_mask = GFP_HIGHUSER;
922 #endif
923 #if defined(AFS_LINUX26_ENV)
924         mapping_set_gfp_mask(mapping, GFP_HIGHUSER);
925         {
926             extern struct backing_dev_info afs_backing_dev_info;
927
928             mapping->backing_dev_info = &afs_backing_dev_info;
929         }
930 #endif
931 #endif
932
933 #if !defined(AFS_LINUX26_ENV)
934         if (afs_globalVFS)
935             ip->i_dev = afs_globalVFS->s_dev;
936 #else
937 #ifdef STRUCT_INODE_HAS_I_SECURITY
938         ip->i_security = NULL;
939         if (security_inode_alloc(ip))
940             panic("Cannot allocate inode security");
941 #endif
942 #endif
943         ip->i_sb = afs_globalVFS;
944         put_inode_on_dummy_list(ip);
945 #ifdef STRUCT_INODE_HAS_I_SB_LIST
946         list_add(&ip->i_sb_list, &ip->i_sb->s_inodes);
947 #endif
948 #if defined(STRUCT_INODE_HAS_INOTIFY_LOCK) || defined(STRUCT_INODE_HAS_INOTIFY_SEM)
949         INIT_LIST_HEAD(&ip->inotify_watches); 
950 #if defined(STRUCT_INODE_HAS_INOTIFY_SEM) 
951         sema_init(&ip->inotify_sem, 1); 
952 #else
953         spin_lock_init(&ip->inotify_lock); 
954 #endif 
955 #endif 
956     }
957 #endif
958
959 #ifdef  AFS_OSF_ENV
960     /* Hold it for the LRU (should make count 2) */
961     VN_HOLD(AFSTOV(tvc));
962 #else /* AFS_OSF_ENV */
963 #if !(defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV))
964     VREFCOUNT_SET(tvc, 1);      /* us */
965 #endif /* AFS_XBSD_ENV */
966 #endif /* AFS_OSF_ENV */
967 #ifdef  AFS_AIX32_ENV
968     LOCK_INIT(&tvc->pvmlock, "vcache pvmlock");
969     tvc->vmh = tvc->segid = NULL;
970     tvc->credp = NULL;
971 #endif
972 #ifdef AFS_BOZONLOCK_ENV
973 #if     defined(AFS_SUN5_ENV)
974     rw_init(&tvc->rwlock, "vcache rwlock", RW_DEFAULT, NULL);
975
976 #if     defined(AFS_SUN55_ENV)
977     /* This is required if the kaio (kernel aynchronous io)
978      ** module is installed. Inside the kernel, the function
979      ** check_vp( common/os/aio.c) checks to see if the kernel has
980      ** to provide asynchronous io for this vnode. This
981      ** function extracts the device number by following the
982      ** v_data field of the vnode. If we do not set this field
983      ** then the system panics. The  value of the v_data field
984      ** is not really important for AFS vnodes because the kernel
985      ** does not do asynchronous io for regular files. Hence,
986      ** for the time being, we fill up the v_data field with the
987      ** vnode pointer itself. */
988     tvc->v.v_data = (char *)tvc;
989 #endif /* AFS_SUN55_ENV */
990 #endif
991     afs_BozonInit(&tvc->pvnLock, tvc);
992 #endif
993
994     tvc->Access = NULL;
995     tvc->callback = serverp;    /* to minimize chance that clear
996                                  * request is lost */
997     /* initialize vnode data, note vrefCount is v.v_count */
998 #ifdef  AFS_AIX_ENV
999     /* Don't forget to free the gnode space */
1000     tvc->v.v_gnode = gnodepnt =
1001         (struct gnode *)osi_AllocSmallSpace(sizeof(struct gnode));
1002     memset((char *)gnodepnt, 0, sizeof(struct gnode));
1003 #endif
1004 #ifdef AFS_SGI64_ENV
1005     memset((void *)&(tvc->vc_bhv_desc), 0, sizeof(tvc->vc_bhv_desc));
1006     bhv_desc_init(&(tvc->vc_bhv_desc), tvc, tvc, &Afs_vnodeops);
1007 #ifdef AFS_SGI65_ENV
1008     vn_bhv_head_init(&(tvc->v.v_bh), "afsvp");
1009     vn_bhv_insert_initial(&(tvc->v.v_bh), &(tvc->vc_bhv_desc));
1010 #else
1011     bhv_head_init(&(tvc->v.v_bh));
1012     bhv_insert_initial(&(tvc->v.v_bh), &(tvc->vc_bhv_desc));
1013 #endif
1014 #ifdef AFS_SGI65_ENV
1015     tvc->v.v_mreg = tvc->v.v_mregb = (struct pregion *)tvc;
1016 #ifdef VNODE_TRACING
1017     tvc->v.v_trace = ktrace_alloc(VNODE_TRACE_SIZE, 0);
1018 #endif
1019     init_bitlock(&tvc->v.v_pcacheflag, VNODE_PCACHE_LOCKBIT, "afs_pcache",
1020                  tvc->v.v_number);
1021     init_mutex(&tvc->v.v_filocksem, MUTEX_DEFAULT, "afsvfl", (long)tvc);
1022     init_mutex(&tvc->v.v_buf_lock, MUTEX_DEFAULT, "afsvnbuf", (long)tvc);
1023 #endif
1024     vnode_pcache_init(&tvc->v);
1025 #if defined(DEBUG) && defined(VNODE_INIT_BITLOCK)
1026     /* Above define is never true execpt in SGI test kernels. */
1027     init_bitlock(&(tvc->v.v_flag, VLOCK, "vnode", tvc->v.v_number);
1028 #endif
1029 #ifdef INTR_KTHREADS
1030                  AFS_VN_INIT_BUF_LOCK(&(tvc->v));
1031 #endif
1032 #else
1033     SetAfsVnode(AFSTOV(tvc));
1034 #endif /* AFS_SGI64_ENV */
1035     /*
1036      * The proper value for mvstat (for root fids) is setup by the caller.
1037      */
1038     tvc->mvstat = 0;
1039     if (afid->Fid.Vnode == 1 && afid->Fid.Unique == 1)
1040         tvc->mvstat = 2;
1041     if (afs_globalVFS == 0)
1042         osi_Panic("afs globalvfs");
1043     vSetVfsp(tvc, afs_globalVFS);
1044     vSetType(tvc, VREG);
1045 #ifdef  AFS_AIX_ENV
1046     tvc->v.v_vfsnext = afs_globalVFS->vfs_vnodes;       /* link off vfs */
1047     tvc->v.v_vfsprev = NULL;
1048     afs_globalVFS->vfs_vnodes = &tvc->v;
1049     if (tvc->v.v_vfsnext != NULL)
1050         tvc->v.v_vfsnext->v_vfsprev = &tvc->v;
1051     tvc->v.v_next = gnodepnt->gn_vnode; /*Single vnode per gnode for us! */
1052     gnodepnt->gn_vnode = &tvc->v;
1053 #endif
1054 #if     defined(AFS_DUX40_ENV)
1055     insmntque(tvc, afs_globalVFS, &afs_ubcops);
1056 #else
1057 #ifdef  AFS_OSF_ENV
1058     /* Is this needed??? */
1059     insmntque(tvc, afs_globalVFS);
1060 #endif /* AFS_OSF_ENV */
1061 #endif /* AFS_DUX40_ENV */
1062 #if defined(AFS_SGI_ENV)
1063     VN_SET_DPAGES(&(tvc->v), (struct pfdat *)NULL);
1064     osi_Assert((tvc->v.v_flag & VINACT) == 0);
1065     tvc->v.v_flag = 0;
1066     osi_Assert(VN_GET_PGCNT(&(tvc->v)) == 0);
1067     osi_Assert(tvc->mapcnt == 0 && tvc->vc_locktrips == 0);
1068     osi_Assert(tvc->vc_rwlockid == OSI_NO_LOCKID);
1069     osi_Assert(tvc->v.v_filocks == NULL);
1070 #if !defined(AFS_SGI65_ENV)
1071     osi_Assert(tvc->v.v_filocksem == NULL);
1072 #endif
1073     osi_Assert(tvc->cred == NULL);
1074 #ifdef AFS_SGI64_ENV
1075     vnode_pcache_reinit(&tvc->v);
1076     tvc->v.v_rdev = NODEV;
1077 #endif
1078     vn_initlist((struct vnlist *)&tvc->v);
1079     tvc->lastr = 0;
1080 #endif /* AFS_SGI_ENV */
1081     tvc->dchint = NULL;
1082     osi_dnlc_purgedp(tvc);      /* this may be overkill */
1083     memset((char *)&(tvc->callsort), 0, sizeof(struct afs_q));
1084     tvc->slocks = NULL;
1085     i = VCHash(afid);
1086     j = VCHashV(afid);
1087
1088     tvc->hnext = afs_vhashT[i];
1089     tvc->vhnext = afs_vhashTV[j];
1090     afs_vhashT[i] = afs_vhashTV[j] = tvc;
1091
1092     if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
1093         refpanic("NewVCache VLRU inconsistent");
1094     }
1095     QAdd(&VLRU, &tvc->vlruq);   /* put in lruq */
1096     if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
1097         refpanic("NewVCache VLRU inconsistent2");
1098     }
1099     if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
1100         refpanic("NewVCache VLRU inconsistent3");
1101     }
1102     if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
1103         refpanic("NewVCache VLRU inconsistent4");
1104     }
1105     vcachegen++;
1106
1107     return tvc;
1108
1109 }                               /*afs_NewVCache */
1110
1111
1112 /*
1113  * afs_FlushActiveVcaches
1114  *
1115  * Description:
1116  *      ???
1117  *
1118  * Parameters:
1119  *      doflocks : Do we handle flocks?
1120  */
1121 /* LOCK: afs_FlushActiveVcaches afs_xvcache N */
1122 void
1123 afs_FlushActiveVcaches(register afs_int32 doflocks)
1124 {
1125     register struct vcache *tvc;
1126     register int i;
1127     register struct conn *tc;
1128     register afs_int32 code;
1129     register struct AFS_UCRED *cred = NULL;
1130     struct vrequest treq, ureq;
1131     struct AFSVolSync tsync;
1132     int didCore;
1133     XSTATS_DECLS;
1134     AFS_STATCNT(afs_FlushActiveVcaches);
1135     ObtainReadLock(&afs_xvcache);
1136     for (i = 0; i < VCSIZE; i++) {
1137         for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
1138             if (doflocks && tvc->flockCount != 0) {
1139                 /* if this entry has an flock, send a keep-alive call out */
1140                 osi_vnhold(tvc, 0);
1141                 ReleaseReadLock(&afs_xvcache);
1142                 ObtainWriteLock(&tvc->lock, 51);
1143                 do {
1144                     afs_InitReq(&treq, afs_osi_credp);
1145                     treq.flags |= O_NONBLOCK;
1146
1147                     tc = afs_Conn(&tvc->fid, &treq, SHARED_LOCK);
1148                     if (tc) {
1149                         XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_EXTENDLOCK);
1150                         RX_AFS_GUNLOCK();
1151                         code =
1152                             RXAFS_ExtendLock(tc->id,
1153                                              (struct AFSFid *)&tvc->fid.Fid,
1154                                              &tsync);
1155                         RX_AFS_GLOCK();
1156                         XSTATS_END_TIME;
1157                     } else
1158                         code = -1;
1159                 } while (afs_Analyze
1160                          (tc, code, &tvc->fid, &treq,
1161                           AFS_STATS_FS_RPCIDX_EXTENDLOCK, SHARED_LOCK, NULL));
1162
1163                 ReleaseWriteLock(&tvc->lock);
1164                 ObtainReadLock(&afs_xvcache);
1165                 AFS_FAST_RELE(tvc);
1166             }
1167             didCore = 0;
1168             if ((tvc->states & CCore) || (tvc->states & CUnlinkedDel)) {
1169                 /*
1170                  * Don't let it evaporate in case someone else is in
1171                  * this code.  Also, drop the afs_xvcache lock while
1172                  * getting vcache locks.
1173                  */
1174                 osi_vnhold(tvc, 0);
1175                 ReleaseReadLock(&afs_xvcache);
1176 #ifdef AFS_BOZONLOCK_ENV
1177                 afs_BozonLock(&tvc->pvnLock, tvc);
1178 #endif
1179 #if defined(AFS_SGI_ENV)
1180                 /*
1181                  * That's because if we come in via the CUnlinkedDel bit state path we'll be have 0 refcnt
1182                  */
1183                 osi_Assert(VREFCOUNT(tvc) > 0);
1184                 AFS_RWLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
1185 #endif
1186                 ObtainWriteLock(&tvc->lock, 52);
1187                 if (tvc->states & CCore) {
1188                     tvc->states &= ~CCore;
1189                     /* XXXX Find better place-holder for cred XXXX */
1190                     cred = (struct AFS_UCRED *)tvc->linkData;
1191                     tvc->linkData = NULL;       /* XXX */
1192                     afs_InitReq(&ureq, cred);
1193                     afs_Trace2(afs_iclSetp, CM_TRACE_ACTCCORE,
1194                                ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
1195                                tvc->execsOrWriters);
1196                     code = afs_StoreOnLastReference(tvc, &ureq);
1197                     ReleaseWriteLock(&tvc->lock);
1198 #ifdef AFS_BOZONLOCK_ENV
1199                     afs_BozonUnlock(&tvc->pvnLock, tvc);
1200 #endif
1201                     hzero(tvc->flushDV);
1202                     osi_FlushText(tvc);
1203                     didCore = 1;
1204                     if (code && code != VNOVNODE) {
1205                         afs_StoreWarn(code, tvc->fid.Fid.Volume,
1206                                       /* /dev/console */ 1);
1207                     }
1208                 } else if (tvc->states & CUnlinkedDel) {
1209                     /*
1210                      * Ignore errors
1211                      */
1212                     ReleaseWriteLock(&tvc->lock);
1213 #ifdef AFS_BOZONLOCK_ENV
1214                     afs_BozonUnlock(&tvc->pvnLock, tvc);
1215 #endif
1216 #if defined(AFS_SGI_ENV)
1217                     AFS_RWUNLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
1218 #endif
1219                     afs_remunlink(tvc, 0);
1220 #if defined(AFS_SGI_ENV)
1221                     AFS_RWLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
1222 #endif
1223                 } else {
1224                     /* lost (or won, perhaps) the race condition */
1225                     ReleaseWriteLock(&tvc->lock);
1226 #ifdef AFS_BOZONLOCK_ENV
1227                     afs_BozonUnlock(&tvc->pvnLock, tvc);
1228 #endif
1229                 }
1230 #if defined(AFS_SGI_ENV)
1231                 AFS_RWUNLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
1232 #endif
1233                 ObtainReadLock(&afs_xvcache);
1234                 AFS_FAST_RELE(tvc);
1235                 if (didCore) {
1236                     AFS_RELE(AFSTOV(tvc));
1237                     /* Matches write code setting CCore flag */
1238                     crfree(cred);
1239                 }
1240             }
1241         }
1242     }
1243     ReleaseReadLock(&afs_xvcache);
1244 }
1245
1246
1247 /*
1248  * afs_VerifyVCache
1249  *
1250  * Description:
1251  *      Make sure a cache entry is up-to-date status-wise.
1252  *
1253  * NOTE: everywhere that calls this can potentially be sped up
1254  *       by checking CStatd first, and avoiding doing the InitReq
1255  *       if this is up-to-date.
1256  *
1257  *  Anymore, the only places that call this KNOW already that the
1258  *  vcache is not up-to-date, so we don't screw around.
1259  *
1260  * Parameters:
1261  *      avc  : Ptr to vcache entry to verify.
1262  *      areq : ???
1263  */
1264
1265 int
1266 afs_VerifyVCache2(struct vcache *avc, struct vrequest *areq)
1267 {
1268     register struct vcache *tvc;
1269
1270     AFS_STATCNT(afs_VerifyVCache);
1271
1272 #if defined(AFS_OSF_ENV)
1273     ObtainReadLock(&avc->lock);
1274     if (afs_IsWired(avc)) {
1275         ReleaseReadLock(&avc->lock);
1276         return 0;
1277     }
1278     ReleaseReadLock(&avc->lock);
1279 #endif /* AFS_OSF_ENV */
1280     /* otherwise we must fetch the status info */
1281
1282     ObtainWriteLock(&avc->lock, 53);
1283     if (avc->states & CStatd) {
1284         ReleaseWriteLock(&avc->lock);
1285         return 0;
1286     }
1287     ObtainWriteLock(&afs_xcbhash, 461);
1288     avc->states &= ~(CStatd | CUnique);
1289     avc->callback = NULL;
1290     afs_DequeueCallback(avc);
1291     ReleaseWriteLock(&afs_xcbhash);
1292     ReleaseWriteLock(&avc->lock);
1293
1294     /* since we've been called back, or the callback has expired,
1295      * it's possible that the contents of this directory, or this
1296      * file's name have changed, thus invalidating the dnlc contents.
1297      */
1298     if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1))
1299         osi_dnlc_purgedp(avc);
1300     else
1301         osi_dnlc_purgevp(avc);
1302
1303     /* fetch the status info */
1304     tvc = afs_GetVCache(&avc->fid, areq, NULL, avc);
1305     if (!tvc)
1306         return ENOENT;
1307     /* Put it back; caller has already incremented vrefCount */
1308     afs_PutVCache(tvc);
1309     return 0;
1310
1311 }                               /*afs_VerifyVCache */
1312
1313
1314 /*
1315  * afs_SimpleVStat
1316  *
1317  * Description:
1318  *      Simple copy of stat info into cache.
1319  *
1320  * Parameters:
1321  *      avc   : Ptr to vcache entry involved.
1322  *      astat : Ptr to stat info to copy.
1323  *
1324  * Environment:
1325  *      Nothing interesting.
1326  *
1327  * Callers:  as of 1992-04-29, only called by WriteVCache
1328  */
1329 static void
1330 afs_SimpleVStat(register struct vcache *avc,
1331                 register struct AFSFetchStatus *astat, struct vrequest *areq)
1332 {
1333     afs_size_t length;
1334     AFS_STATCNT(afs_SimpleVStat);
1335
1336 #ifdef AFS_SGI_ENV
1337     if ((avc->execsOrWriters <= 0) && !afs_DirtyPages(avc)
1338         && !AFS_VN_MAPPED((vnode_t *) avc)) {
1339 #else
1340     if ((avc->execsOrWriters <= 0) && !afs_DirtyPages(avc)) {
1341 #endif
1342 #ifdef AFS_64BIT_CLIENT
1343         FillInt64(length, astat->Length_hi, astat->Length);
1344 #else /* AFS_64BIT_CLIENT */
1345         length = astat->Length;
1346 #endif /* AFS_64BIT_CLIENT */
1347 #if defined(AFS_SGI_ENV)
1348         osi_Assert((valusema(&avc->vc_rwlock) <= 0)
1349                    && (OSI_GET_LOCKID() == avc->vc_rwlockid));
1350         if (length < avc->m.Length) {
1351             vnode_t *vp = (vnode_t *) avc;
1352
1353             osi_Assert(WriteLocked(&avc->lock));
1354             ReleaseWriteLock(&avc->lock);
1355             AFS_GUNLOCK();
1356             PTOSSVP(vp, (off_t) length, (off_t) MAXLONG);
1357             AFS_GLOCK();
1358             ObtainWriteLock(&avc->lock, 67);
1359         }
1360 #endif
1361         /* if writing the file, don't fetch over this value */
1362         afs_Trace3(afs_iclSetp, CM_TRACE_SIMPLEVSTAT, ICL_TYPE_POINTER, avc,
1363                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length),
1364                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(length));
1365         avc->m.Length = length;
1366         avc->m.Date = astat->ClientModTime;
1367     }
1368     avc->m.Owner = astat->Owner;
1369     avc->m.Group = astat->Group;
1370     avc->m.Mode = astat->UnixModeBits;
1371     if (vType(avc) == VREG) {
1372         avc->m.Mode |= S_IFREG;
1373     } else if (vType(avc) == VDIR) {
1374         avc->m.Mode |= S_IFDIR;
1375     } else if (vType(avc) == VLNK) {
1376         avc->m.Mode |= S_IFLNK;
1377         if ((avc->m.Mode & 0111) == 0)
1378             avc->mvstat = 1;
1379     }
1380     if (avc->states & CForeign) {
1381         struct axscache *ac;
1382         avc->anyAccess = astat->AnonymousAccess;
1383 #ifdef badidea
1384         if ((astat->CallerAccess & ~astat->AnonymousAccess))
1385             /*   USED TO SAY :
1386              * Caller has at least one bit not covered by anonymous, and
1387              * thus may have interesting rights.
1388              *
1389              * HOWEVER, this is a really bad idea, because any access query
1390              * for bits which aren't covered by anonymous, on behalf of a user
1391              * who doesn't have any special rights, will result in an answer of
1392              * the form "I don't know, lets make a FetchStatus RPC and find out!"
1393              * It's an especially bad idea under Ultrix, since (due to the lack of
1394              * a proper access() call) it must perform several afs_access() calls
1395              * in order to create magic mode bits that vary according to who makes
1396              * the call.  In other words, _every_ stat() generates a test for
1397              * writeability...
1398              */
1399 #endif /* badidea */
1400             if (avc->Access && (ac = afs_FindAxs(avc->Access, areq->uid)))
1401                 ac->axess = astat->CallerAccess;
1402             else                /* not found, add a new one if possible */
1403                 afs_AddAxs(avc->Access, areq->uid, astat->CallerAccess);
1404     }
1405
1406
1407 }                               /*afs_SimpleVStat */
1408
1409
1410 /*
1411  * afs_WriteVCache
1412  *
1413  * Description:
1414  *      Store the status info *only* back to the server for a
1415  *      fid/vrequest.
1416  *
1417  * Parameters:
1418  *      avc     : Ptr to the vcache entry.
1419  *      astatus : Ptr to the status info to store.
1420  *      areq    : Ptr to the associated vrequest.
1421  *
1422  * Environment:
1423  *      Must be called with a shared lock held on the vnode.
1424  */
1425
1426 int
1427 afs_WriteVCache(register struct vcache *avc,
1428                 register struct AFSStoreStatus *astatus,
1429                 struct vrequest *areq)
1430 {
1431     afs_int32 code;
1432     struct conn *tc;
1433     struct AFSFetchStatus OutStatus;
1434     struct AFSVolSync tsync;
1435     XSTATS_DECLS;
1436     AFS_STATCNT(afs_WriteVCache);
1437     afs_Trace2(afs_iclSetp, CM_TRACE_WVCACHE, ICL_TYPE_POINTER, avc,
1438                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length));
1439
1440     do {
1441         tc = afs_Conn(&avc->fid, areq, SHARED_LOCK);
1442         if (tc) {
1443             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STORESTATUS);
1444             RX_AFS_GUNLOCK();
1445             code =
1446                 RXAFS_StoreStatus(tc->id, (struct AFSFid *)&avc->fid.Fid,
1447                                   astatus, &OutStatus, &tsync);
1448             RX_AFS_GLOCK();
1449             XSTATS_END_TIME;
1450         } else
1451             code = -1;
1452     } while (afs_Analyze
1453              (tc, code, &avc->fid, areq, AFS_STATS_FS_RPCIDX_STORESTATUS,
1454               SHARED_LOCK, NULL));
1455
1456     UpgradeSToWLock(&avc->lock, 20);
1457     if (code == 0) {
1458         /* success, do the changes locally */
1459         afs_SimpleVStat(avc, &OutStatus, areq);
1460         /*
1461          * Update the date, too.  SimpleVStat didn't do this, since
1462          * it thought we were doing this after fetching new status
1463          * over a file being written.
1464          */
1465         avc->m.Date = OutStatus.ClientModTime;
1466     } else {
1467         /* failure, set up to check with server next time */
1468         ObtainWriteLock(&afs_xcbhash, 462);
1469         afs_DequeueCallback(avc);
1470         avc->states &= ~(CStatd | CUnique);     /* turn off stat valid flag */
1471         ReleaseWriteLock(&afs_xcbhash);
1472         if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1))
1473             osi_dnlc_purgedp(avc);      /* if it (could be) a directory */
1474     }
1475     ConvertWToSLock(&avc->lock);
1476     return code;
1477
1478 }                               /*afs_WriteVCache */
1479
1480 /*
1481  * afs_ProcessFS
1482  *
1483  * Description:
1484  *      Copy astat block into vcache info
1485  *
1486  * Parameters:
1487  *      avc   : Ptr to vcache entry.
1488  *      astat : Ptr to stat block to copy in.
1489  *      areq  : Ptr to associated request.
1490  *
1491  * Environment:
1492  *      Must be called under a write lock
1493  *
1494  * Note: this code may get dataversion and length out of sync if the file has
1495  *       been modified.  This is less than ideal.  I haven't thought about
1496  *       it sufficiently to be certain that it is adequate.
1497  */
1498 void
1499 afs_ProcessFS(register struct vcache *avc,
1500               register struct AFSFetchStatus *astat, struct vrequest *areq)
1501 {
1502     afs_size_t length;
1503     AFS_STATCNT(afs_ProcessFS);
1504
1505 #ifdef AFS_64BIT_CLIENT
1506     FillInt64(length, astat->Length_hi, astat->Length);
1507 #else /* AFS_64BIT_CLIENT */
1508     length = astat->Length;
1509 #endif /* AFS_64BIT_CLIENT */
1510     /* WARNING: afs_DoBulkStat uses the Length field to store a sequence
1511      * number for each bulk status request. Under no circumstances
1512      * should afs_DoBulkStat store a sequence number if the new
1513      * length will be ignored when afs_ProcessFS is called with
1514      * new stats. If you change the following conditional then you
1515      * also need to change the conditional in afs_DoBulkStat.  */
1516 #ifdef AFS_SGI_ENV
1517     if ((avc->execsOrWriters <= 0) && !afs_DirtyPages(avc)
1518         && !AFS_VN_MAPPED((vnode_t *) avc)) {
1519 #else
1520     if ((avc->execsOrWriters <= 0) && !afs_DirtyPages(avc)) {
1521 #endif
1522         /* if we're writing or mapping this file, don't fetch over these
1523          *  values.
1524          */
1525         afs_Trace3(afs_iclSetp, CM_TRACE_PROCESSFS, ICL_TYPE_POINTER, avc,
1526                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length),
1527                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(length));
1528         avc->m.Length = length;
1529         avc->m.Date = astat->ClientModTime;
1530     }
1531     hset64(avc->m.DataVersion, astat->dataVersionHigh, astat->DataVersion);
1532     avc->m.Owner = astat->Owner;
1533     avc->m.Mode = astat->UnixModeBits;
1534     avc->m.Group = astat->Group;
1535     avc->m.LinkCount = astat->LinkCount;
1536     if (astat->FileType == File) {
1537         vSetType(avc, VREG);
1538         avc->m.Mode |= S_IFREG;
1539     } else if (astat->FileType == Directory) {
1540         vSetType(avc, VDIR);
1541         avc->m.Mode |= S_IFDIR;
1542     } else if (astat->FileType == SymbolicLink) {
1543         if (afs_fakestat_enable && (avc->m.Mode & 0111) == 0) {
1544             vSetType(avc, VDIR);
1545             avc->m.Mode |= S_IFDIR;
1546         } else {
1547             vSetType(avc, VLNK);
1548             avc->m.Mode |= S_IFLNK;
1549         }
1550         if ((avc->m.Mode & 0111) == 0) {
1551             avc->mvstat = 1;
1552         }
1553     }
1554     avc->anyAccess = astat->AnonymousAccess;
1555 #ifdef badidea
1556     if ((astat->CallerAccess & ~astat->AnonymousAccess))
1557         /*   USED TO SAY :
1558          * Caller has at least one bit not covered by anonymous, and
1559          * thus may have interesting rights.
1560          *
1561          * HOWEVER, this is a really bad idea, because any access query
1562          * for bits which aren't covered by anonymous, on behalf of a user
1563          * who doesn't have any special rights, will result in an answer of
1564          * the form "I don't know, lets make a FetchStatus RPC and find out!"
1565          * It's an especially bad idea under Ultrix, since (due to the lack of
1566          * a proper access() call) it must perform several afs_access() calls
1567          * in order to create magic mode bits that vary according to who makes
1568          * the call.  In other words, _every_ stat() generates a test for
1569          * writeability...
1570          */
1571 #endif /* badidea */
1572     {
1573         struct axscache *ac;
1574         if (avc->Access && (ac = afs_FindAxs(avc->Access, areq->uid)))
1575             ac->axess = astat->CallerAccess;
1576         else                    /* not found, add a new one if possible */
1577             afs_AddAxs(avc->Access, areq->uid, astat->CallerAccess);
1578     }
1579 #ifdef AFS_LINUX22_ENV
1580     vcache2inode(avc);          /* Set the inode attr cache */
1581 #endif
1582
1583 }                               /*afs_ProcessFS */
1584
1585
1586 int
1587 afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq,
1588                  char *name, struct VenusFid *nfid,
1589                  struct AFSFetchStatus *OutStatusp,
1590                  struct AFSCallBack *CallBackp, struct server **serverp,
1591                  struct AFSVolSync *tsyncp)
1592 {
1593     afs_int32 code;
1594     afs_uint32 start;
1595     register struct conn *tc;
1596     struct AFSFetchStatus OutDirStatus;
1597     XSTATS_DECLS;
1598     if (!name)
1599         name = "";              /* XXX */
1600     do {
1601         tc = afs_Conn(afid, areq, SHARED_LOCK);
1602         if (tc) {
1603             if (serverp)
1604                 *serverp = tc->srvr->server;
1605             start = osi_Time();
1606             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_XLOOKUP);
1607             RX_AFS_GUNLOCK();
1608             code =
1609                 RXAFS_Lookup(tc->id, (struct AFSFid *)&afid->Fid, name,
1610                              (struct AFSFid *)&nfid->Fid, OutStatusp,
1611                              &OutDirStatus, CallBackp, tsyncp);
1612             RX_AFS_GLOCK();
1613             XSTATS_END_TIME;
1614         } else
1615             code = -1;
1616     } while (afs_Analyze
1617              (tc, code, afid, areq, AFS_STATS_FS_RPCIDX_XLOOKUP, SHARED_LOCK,
1618               NULL));
1619
1620     return code;
1621 }
1622
1623
1624 /*
1625  * afs_GetVCache
1626  *
1627  * Description:
1628  *      Given a file id and a vrequest structure, fetch the status
1629  *      information associated with the file.
1630  *
1631  * Parameters:
1632  *      afid : File ID.
1633  *      areq : Ptr to associated vrequest structure, specifying the
1634  *              user whose authentication tokens will be used.
1635  *      avc  : caller may already have a vcache for this file, which is
1636  *             already held.
1637  *
1638  * Environment:
1639  *      The cache entry is returned with an increased vrefCount field.
1640  *      The entry must be discarded by calling afs_PutVCache when you
1641  *      are through using the pointer to the cache entry.
1642  *
1643  *      You should not hold any locks when calling this function, except
1644  *      locks on other vcache entries.  If you lock more than one vcache
1645  *      entry simultaneously, you should lock them in this order:
1646  *
1647  *          1. Lock all files first, then directories.
1648  *          2.  Within a particular type, lock entries in Fid.Vnode order.
1649  *
1650  *      This locking hierarchy is convenient because it allows locking
1651  *      of a parent dir cache entry, given a file (to check its access
1652  *      control list).  It also allows renames to be handled easily by
1653  *      locking directories in a constant order.
1654  * NB.  NewVCache -> FlushVCache presently (4/10/95) drops the xvcache lock.
1655  */
1656    /* might have a vcache structure already, which must
1657     * already be held by the caller */
1658
1659 struct vcache *
1660 afs_GetVCache(register struct VenusFid *afid, struct vrequest *areq,
1661               afs_int32 * cached, struct vcache *avc)
1662 {
1663
1664     afs_int32 code, newvcache = 0;
1665     register struct vcache *tvc;
1666     struct volume *tvp;
1667     afs_int32 retry;
1668
1669     AFS_STATCNT(afs_GetVCache);
1670
1671     if (cached)
1672         *cached = 0;            /* Init just in case */
1673
1674 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
1675   loop:
1676 #endif
1677
1678     ObtainSharedLock(&afs_xvcache, 5);
1679
1680     tvc = afs_FindVCache(afid, &retry, DO_STATS | DO_VLRU);
1681     if (tvc && retry) {
1682 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
1683         ReleaseSharedLock(&afs_xvcache);
1684         spunlock_psema(tvc->v.v_lock, retry, &tvc->v.v_sync, PINOD);
1685         goto loop;
1686 #endif
1687     }
1688
1689     if (tvc) {
1690         if (cached)
1691             *cached = 1;
1692         if (tvc->states & CStatd) {
1693             ReleaseSharedLock(&afs_xvcache);
1694             return tvc;
1695         }
1696     } else {
1697         UpgradeSToWLock(&afs_xvcache, 21);
1698
1699         /* no cache entry, better grab one */
1700         tvc = afs_NewVCache(afid, NULL);
1701         newvcache = 1;
1702
1703         ConvertWToSLock(&afs_xvcache);
1704         afs_stats_cmperf.vcacheMisses++;
1705     }
1706
1707     ReleaseSharedLock(&afs_xvcache);
1708
1709     ObtainWriteLock(&tvc->lock, 54);
1710
1711     if (tvc->states & CStatd) {
1712 #ifdef AFS_LINUX22_ENV
1713         vcache2inode(tvc);
1714 #endif
1715         ReleaseWriteLock(&tvc->lock);
1716         return tvc;
1717     }
1718 #if defined(AFS_OSF_ENV)
1719     if (afs_IsWired(tvc)) {
1720         ReleaseWriteLock(&tvc->lock);
1721         return tvc;
1722     }
1723 #endif /* AFS_OSF_ENV */
1724 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
1725     /*
1726      * XXX - I really don't like this.  Should try to understand better.
1727      * It seems that sometimes, when we get called, we already hold the
1728      * lock on the vnode (e.g., from afs_getattr via afs_VerifyVCache).
1729      * We can't drop the vnode lock, because that could result in a race.
1730      * Sometimes, though, we get here and don't hold the vnode lock.
1731      * I hate code paths that sometimes hold locks and sometimes don't.
1732      * In any event, the dodge we use here is to check whether the vnode
1733      * is locked, and if it isn't, then we gain and drop it around the call
1734      * to vinvalbuf; otherwise, we leave it alone.
1735      */
1736     {
1737         struct vnode *vp = AFSTOV(tvc);
1738         int iheldthelock;
1739
1740 #if defined(AFS_DARWIN_ENV)
1741         iheldthelock = VOP_ISLOCKED(vp);
1742         if (!iheldthelock)
1743             vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, current_proc());
1744         /* this is messy. we can call fsync which will try to reobtain this */
1745         if (VTOAFS(vp) == tvc) 
1746           ReleaseWriteLock(&tvc->lock);
1747         if (UBCINFOEXISTS(vp)) {
1748           vinvalbuf(vp, V_SAVE, &afs_osi_cred, current_proc(), PINOD, 0);
1749         }
1750         if (VTOAFS(vp) == tvc) 
1751           ObtainWriteLock(&tvc->lock, 954);
1752         if (!iheldthelock)
1753             VOP_UNLOCK(vp, LK_EXCLUSIVE, current_proc());
1754 #elif defined(AFS_FBSD60_ENV)
1755         iheldthelock = VOP_ISLOCKED(vp, curthread);
1756         if (!iheldthelock)
1757             vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread);
1758         vinvalbuf(vp, V_SAVE, curthread, PINOD, 0);
1759         if (!iheldthelock)
1760             VOP_UNLOCK(vp, LK_EXCLUSIVE, curthread);
1761 #elif defined(AFS_FBSD50_ENV)
1762         iheldthelock = VOP_ISLOCKED(vp, curthread);
1763         if (!iheldthelock)
1764             vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread);
1765         vinvalbuf(vp, V_SAVE, osi_curcred(), curthread, PINOD, 0);
1766         if (!iheldthelock)
1767             VOP_UNLOCK(vp, LK_EXCLUSIVE, curthread);
1768 #elif defined(AFS_FBSD40_ENV)
1769         iheldthelock = VOP_ISLOCKED(vp, curproc);
1770         if (!iheldthelock)
1771             vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curproc);
1772         vinvalbuf(vp, V_SAVE, osi_curcred(), curproc, PINOD, 0);
1773         if (!iheldthelock)
1774             VOP_UNLOCK(vp, LK_EXCLUSIVE, curproc);
1775 #elif defined(AFS_OBSD_ENV)
1776         iheldthelock = VOP_ISLOCKED(vp, curproc);
1777         if (!iheldthelock)
1778             VOP_LOCK(vp, LK_EXCLUSIVE | LK_RETRY, curproc);
1779         uvm_vnp_uncache(vp);
1780         if (!iheldthelock)
1781             VOP_UNLOCK(vp, 0, curproc);
1782 #endif
1783     }
1784 #endif
1785
1786     ObtainWriteLock(&afs_xcbhash, 464);
1787     tvc->states &= ~CUnique;
1788     tvc->callback = 0;
1789     afs_DequeueCallback(tvc);
1790     ReleaseWriteLock(&afs_xcbhash);
1791
1792     /* It is always appropriate to throw away all the access rights? */
1793     afs_FreeAllAxs(&(tvc->Access));
1794     tvp = afs_GetVolume(afid, areq, READ_LOCK); /* copy useful per-volume info */
1795     if (tvp) {
1796         if ((tvp->states & VForeign)) {
1797             if (newvcache)
1798                 tvc->states |= CForeign;
1799             if (newvcache && (tvp->rootVnode == afid->Fid.Vnode)
1800                 && (tvp->rootUnique == afid->Fid.Unique)) {
1801                 tvc->mvstat = 2;
1802             }
1803         }
1804         if (tvp->states & VRO)
1805             tvc->states |= CRO;
1806         if (tvp->states & VBackup)
1807             tvc->states |= CBackup;
1808         /* now copy ".." entry back out of volume structure, if necessary */
1809         if (tvc->mvstat == 2 && tvp->dotdot.Fid.Volume != 0) {
1810             if (!tvc->mvid)
1811                 tvc->mvid = (struct VenusFid *)
1812                     osi_AllocSmallSpace(sizeof(struct VenusFid));
1813             *tvc->mvid = tvp->dotdot;
1814         }
1815         afs_PutVolume(tvp, READ_LOCK);
1816     }
1817
1818     /* stat the file */
1819     afs_RemoveVCB(afid);
1820     {
1821         struct AFSFetchStatus OutStatus;
1822
1823         if (afs_DynrootNewVnode(tvc, &OutStatus)) {
1824             afs_ProcessFS(tvc, &OutStatus, areq);
1825             tvc->states |= CStatd | CUnique;
1826             code = 0;
1827         } else {
1828             code = afs_FetchStatus(tvc, afid, areq, &OutStatus);
1829         }
1830     }
1831
1832     if (code) {
1833         ReleaseWriteLock(&tvc->lock);
1834
1835         ObtainReadLock(&afs_xvcache);
1836         AFS_FAST_RELE(tvc);
1837         ReleaseReadLock(&afs_xvcache);
1838         return NULL;
1839     }
1840
1841     ReleaseWriteLock(&tvc->lock);
1842     return tvc;
1843
1844 }                               /*afs_GetVCache */
1845
1846
1847
1848 struct vcache *
1849 afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq,
1850                  afs_int32 * cached, struct vcache *adp, char *aname)
1851 {
1852     afs_int32 code, now, newvcache = 0;
1853     struct VenusFid nfid;
1854     register struct vcache *tvc;
1855     struct volume *tvp;
1856     struct AFSFetchStatus OutStatus;
1857     struct AFSCallBack CallBack;
1858     struct AFSVolSync tsync;
1859     struct server *serverp = 0;
1860     afs_int32 origCBs;
1861     afs_int32 retry;
1862
1863     AFS_STATCNT(afs_GetVCache);
1864     if (cached)
1865         *cached = 0;            /* Init just in case */
1866
1867 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
1868   loop1:
1869 #endif
1870
1871     ObtainReadLock(&afs_xvcache);
1872     tvc = afs_FindVCache(afid, &retry, DO_STATS /* no vlru */ );
1873
1874     if (tvc) {
1875         ReleaseReadLock(&afs_xvcache);
1876         if (retry) {
1877 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
1878             spunlock_psema(tvc->v.v_lock, retry, &tvc->v.v_sync, PINOD);
1879             goto loop1;
1880 #endif
1881         }
1882         ObtainReadLock(&tvc->lock);
1883
1884         if (tvc->states & CStatd) {
1885             if (cached) {
1886                 *cached = 1;
1887             }
1888             ReleaseReadLock(&tvc->lock);
1889             return tvc;
1890         }
1891         tvc->states &= ~CUnique;
1892
1893         ReleaseReadLock(&tvc->lock);
1894         ObtainReadLock(&afs_xvcache);
1895         AFS_FAST_RELE(tvc);
1896     }
1897     /* if (tvc) */
1898     ReleaseReadLock(&afs_xvcache);
1899
1900     /* lookup the file */
1901     nfid = *afid;
1902     now = osi_Time();
1903     origCBs = afs_allCBs;       /* if anything changes, we don't have a cb */
1904     code =
1905         afs_RemoteLookup(&adp->fid, areq, aname, &nfid, &OutStatus, &CallBack,
1906                          &serverp, &tsync);
1907
1908 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
1909   loop2:
1910 #endif
1911
1912     ObtainSharedLock(&afs_xvcache, 6);
1913     tvc = afs_FindVCache(&nfid, &retry, DO_VLRU /* no xstats now */ );
1914     if (tvc && retry) {
1915 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
1916         ReleaseSharedLock(&afs_xvcache);
1917         spunlock_psema(tvc->v.v_lock, retry, &tvc->v.v_sync, PINOD);
1918         goto loop2;
1919 #endif
1920     }
1921
1922     if (!tvc) {
1923         /* no cache entry, better grab one */
1924         UpgradeSToWLock(&afs_xvcache, 22);
1925         tvc = afs_NewVCache(&nfid, serverp);
1926         newvcache = 1;
1927         ConvertWToSLock(&afs_xvcache);
1928     }
1929
1930     ReleaseSharedLock(&afs_xvcache);
1931     ObtainWriteLock(&tvc->lock, 55);
1932
1933     /* It is always appropriate to throw away all the access rights? */
1934     afs_FreeAllAxs(&(tvc->Access));
1935     tvp = afs_GetVolume(afid, areq, READ_LOCK); /* copy useful per-vol info */
1936     if (tvp) {
1937         if ((tvp->states & VForeign)) {
1938             if (newvcache)
1939                 tvc->states |= CForeign;
1940             if (newvcache && (tvp->rootVnode == afid->Fid.Vnode)
1941                 && (tvp->rootUnique == afid->Fid.Unique))
1942                 tvc->mvstat = 2;
1943         }
1944         if (tvp->states & VRO)
1945             tvc->states |= CRO;
1946         if (tvp->states & VBackup)
1947             tvc->states |= CBackup;
1948         /* now copy ".." entry back out of volume structure, if necessary */
1949         if (tvc->mvstat == 2 && tvp->dotdot.Fid.Volume != 0) {
1950             if (!tvc->mvid)
1951                 tvc->mvid = (struct VenusFid *)
1952                     osi_AllocSmallSpace(sizeof(struct VenusFid));
1953             *tvc->mvid = tvp->dotdot;
1954         }
1955     }
1956
1957     if (code) {
1958         ObtainWriteLock(&afs_xcbhash, 465);
1959         afs_DequeueCallback(tvc);
1960         tvc->states &= ~(CStatd | CUnique);
1961         ReleaseWriteLock(&afs_xcbhash);
1962         if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
1963             osi_dnlc_purgedp(tvc);      /* if it (could be) a directory */
1964         if (tvp)
1965             afs_PutVolume(tvp, READ_LOCK);
1966         ReleaseWriteLock(&tvc->lock);
1967         ObtainReadLock(&afs_xvcache);
1968         AFS_FAST_RELE(tvc);
1969         ReleaseReadLock(&afs_xvcache);
1970         return NULL;
1971     }
1972
1973     ObtainWriteLock(&afs_xcbhash, 466);
1974     if (origCBs == afs_allCBs) {
1975         if (CallBack.ExpirationTime) {
1976             tvc->callback = serverp;
1977             tvc->cbExpires = CallBack.ExpirationTime + now;
1978             tvc->states |= CStatd | CUnique;
1979             tvc->states &= ~CBulkFetching;
1980             afs_QueueCallback(tvc, CBHash(CallBack.ExpirationTime), tvp);
1981         } else if (tvc->states & CRO) {
1982             /* adapt gives us an hour. */
1983             tvc->cbExpires = 3600 + osi_Time();
1984              /*XXX*/ tvc->states |= CStatd | CUnique;
1985             tvc->states &= ~CBulkFetching;
1986             afs_QueueCallback(tvc, CBHash(3600), tvp);
1987         } else {
1988             tvc->callback = NULL;
1989             afs_DequeueCallback(tvc);
1990             tvc->states &= ~(CStatd | CUnique);
1991             if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
1992                 osi_dnlc_purgedp(tvc);  /* if it (could be) a directory */
1993         }
1994     } else {
1995         afs_DequeueCallback(tvc);
1996         tvc->states &= ~CStatd;
1997         tvc->states &= ~CUnique;
1998         tvc->callback = NULL;
1999         if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
2000             osi_dnlc_purgedp(tvc);      /* if it (could be) a directory */
2001     }
2002     ReleaseWriteLock(&afs_xcbhash);
2003     if (tvp)
2004         afs_PutVolume(tvp, READ_LOCK);
2005     afs_ProcessFS(tvc, &OutStatus, areq);
2006
2007     ReleaseWriteLock(&tvc->lock);
2008     return tvc;
2009
2010 }
2011
2012 struct vcache *
2013 afs_GetRootVCache(struct VenusFid *afid, struct vrequest *areq,
2014                   afs_int32 * cached, struct volume *tvolp)
2015 {
2016     afs_int32 code = 0, i, newvcache = 0, haveStatus = 0;
2017     afs_int32 getNewFid = 0;
2018     afs_uint32 start;
2019     struct VenusFid nfid;
2020     register struct vcache *tvc;
2021     struct server *serverp = 0;
2022     struct AFSFetchStatus OutStatus;
2023     struct AFSCallBack CallBack;
2024     struct AFSVolSync tsync;
2025     int origCBs = 0;
2026
2027     start = osi_Time();
2028
2029   newmtpt:
2030     if (!tvolp->rootVnode || getNewFid) {
2031         struct VenusFid tfid;
2032
2033         tfid = *afid;
2034         tfid.Fid.Vnode = 0;     /* Means get rootfid of volume */
2035         origCBs = afs_allCBs;   /* ignore InitCallBackState */
2036         code =
2037             afs_RemoteLookup(&tfid, areq, NULL, &nfid, &OutStatus, &CallBack,
2038                              &serverp, &tsync);
2039         if (code) {
2040             return NULL;
2041         }
2042 /*      ReleaseReadLock(&tvolp->lock);           */
2043         ObtainWriteLock(&tvolp->lock, 56);
2044         tvolp->rootVnode = afid->Fid.Vnode = nfid.Fid.Vnode;
2045         tvolp->rootUnique = afid->Fid.Unique = nfid.Fid.Unique;
2046         ReleaseWriteLock(&tvolp->lock);
2047 /*      ObtainReadLock(&tvolp->lock);*/
2048         haveStatus = 1;
2049     } else {
2050         afid->Fid.Vnode = tvolp->rootVnode;
2051         afid->Fid.Unique = tvolp->rootUnique;
2052     }
2053
2054     ObtainSharedLock(&afs_xvcache, 7);
2055     i = VCHash(afid);
2056     for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
2057         if (!FidCmp(&(tvc->fid), afid)) {
2058 #ifdef  AFS_OSF_ENV
2059             /* Grab this vnode, possibly reactivating from the free list */
2060             /* for the present (95.05.25) everything on the hash table is
2061              * definitively NOT in the free list -- at least until afs_reclaim
2062              * can be safely implemented */
2063             int vg;
2064             AFS_GUNLOCK();
2065             vg = vget(AFSTOV(tvc));     /* this bumps ref count */
2066             AFS_GLOCK();
2067             if (vg)
2068                 continue;
2069 #endif /* AFS_OSF_ENV */
2070             break;
2071         }
2072     }
2073
2074     if (!haveStatus && (!tvc || !(tvc->states & CStatd))) {
2075         /* Mount point no longer stat'd or unknown. FID may have changed. */
2076 #ifdef AFS_OSF_ENV
2077         if (tvc)
2078             AFS_RELE(AFSTOV(tvc));
2079 #endif
2080         tvc = NULL;
2081         getNewFid = 1;
2082         ReleaseSharedLock(&afs_xvcache);
2083         goto newmtpt;
2084     }
2085
2086     if (!tvc) {
2087         UpgradeSToWLock(&afs_xvcache, 23);
2088         /* no cache entry, better grab one */
2089         tvc = afs_NewVCache(afid, NULL);
2090         newvcache = 1;
2091         afs_stats_cmperf.vcacheMisses++;
2092     } else {
2093         if (cached)
2094             *cached = 1;
2095         afs_stats_cmperf.vcacheHits++;
2096 #ifdef  AFS_OSF_ENV
2097         /* we already bumped the ref count in the for loop above */
2098 #else /* AFS_OSF_ENV */
2099         osi_vnhold(tvc, 0);
2100 #endif
2101         UpgradeSToWLock(&afs_xvcache, 24);
2102         if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
2103             refpanic("GRVC VLRU inconsistent0");
2104         }
2105         if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
2106             refpanic("GRVC VLRU inconsistent1");
2107         }
2108         if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
2109             refpanic("GRVC VLRU inconsistent2");
2110         }
2111         QRemove(&tvc->vlruq);   /* move to lruq head */
2112         QAdd(&VLRU, &tvc->vlruq);
2113         if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
2114             refpanic("GRVC VLRU inconsistent3");
2115         }
2116         if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
2117             refpanic("GRVC VLRU inconsistent4");
2118         }
2119         if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
2120             refpanic("GRVC VLRU inconsistent5");
2121         }
2122         vcachegen++;
2123     }
2124
2125     ReleaseWriteLock(&afs_xvcache);
2126
2127     if (tvc->states & CStatd) {
2128         return tvc;
2129     } else {
2130
2131         ObtainReadLock(&tvc->lock);
2132         tvc->states &= ~CUnique;
2133         tvc->callback = NULL;   /* redundant, perhaps */
2134         ReleaseReadLock(&tvc->lock);
2135     }
2136
2137     ObtainWriteLock(&tvc->lock, 57);
2138
2139     /* It is always appropriate to throw away all the access rights? */
2140     afs_FreeAllAxs(&(tvc->Access));
2141
2142     if (newvcache)
2143         tvc->states |= CForeign;
2144     if (tvolp->states & VRO)
2145         tvc->states |= CRO;
2146     if (tvolp->states & VBackup)
2147         tvc->states |= CBackup;
2148     /* now copy ".." entry back out of volume structure, if necessary */
2149     if (newvcache && (tvolp->rootVnode == afid->Fid.Vnode)
2150         && (tvolp->rootUnique == afid->Fid.Unique)) {
2151         tvc->mvstat = 2;
2152     }
2153     if (tvc->mvstat == 2 && tvolp->dotdot.Fid.Volume != 0) {
2154         if (!tvc->mvid)
2155             tvc->mvid = (struct VenusFid *)
2156                 osi_AllocSmallSpace(sizeof(struct VenusFid));
2157         *tvc->mvid = tvolp->dotdot;
2158     }
2159
2160     /* stat the file */
2161     afs_RemoveVCB(afid);
2162
2163     if (!haveStatus) {
2164         struct VenusFid tfid;
2165
2166         tfid = *afid;
2167         tfid.Fid.Vnode = 0;     /* Means get rootfid of volume */
2168         origCBs = afs_allCBs;   /* ignore InitCallBackState */
2169         code =
2170             afs_RemoteLookup(&tfid, areq, NULL, &nfid, &OutStatus, &CallBack,
2171                              &serverp, &tsync);
2172     }
2173
2174     if (code) {
2175         ObtainWriteLock(&afs_xcbhash, 467);
2176         afs_DequeueCallback(tvc);
2177         tvc->callback = NULL;
2178         tvc->states &= ~(CStatd | CUnique);
2179         ReleaseWriteLock(&afs_xcbhash);
2180         if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
2181             osi_dnlc_purgedp(tvc);      /* if it (could be) a directory */
2182         ReleaseWriteLock(&tvc->lock);
2183         ObtainReadLock(&afs_xvcache);
2184         AFS_FAST_RELE(tvc);
2185         ReleaseReadLock(&afs_xvcache);
2186         return NULL;
2187     }
2188
2189     ObtainWriteLock(&afs_xcbhash, 468);
2190     if (origCBs == afs_allCBs) {
2191         tvc->states |= CTruth;
2192         tvc->callback = serverp;
2193         if (CallBack.ExpirationTime != 0) {
2194             tvc->cbExpires = CallBack.ExpirationTime + start;
2195             tvc->states |= CStatd;
2196             tvc->states &= ~CBulkFetching;
2197             afs_QueueCallback(tvc, CBHash(CallBack.ExpirationTime), tvolp);
2198         } else if (tvc->states & CRO) {
2199             /* adapt gives us an hour. */
2200             tvc->cbExpires = 3600 + osi_Time();
2201              /*XXX*/ tvc->states |= CStatd;
2202             tvc->states &= ~CBulkFetching;
2203             afs_QueueCallback(tvc, CBHash(3600), tvolp);
2204         }
2205     } else {
2206         afs_DequeueCallback(tvc);
2207         tvc->callback = NULL;
2208         tvc->states &= ~(CStatd | CUnique);
2209         if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
2210             osi_dnlc_purgedp(tvc);      /* if it (could be) a directory */
2211     }
2212     ReleaseWriteLock(&afs_xcbhash);
2213     afs_ProcessFS(tvc, &OutStatus, areq);
2214
2215     ReleaseWriteLock(&tvc->lock);
2216     return tvc;
2217 }
2218
2219
2220
2221 /*
2222  * must be called with avc write-locked
2223  * don't absolutely have to invalidate the hint unless the dv has
2224  * changed, but be sure to get it right else there will be consistency bugs.
2225  */
2226 afs_int32
2227 afs_FetchStatus(struct vcache * avc, struct VenusFid * afid,
2228                 struct vrequest * areq, struct AFSFetchStatus * Outsp)
2229 {
2230     int code;
2231     afs_uint32 start = 0;
2232     register struct conn *tc;
2233     struct AFSCallBack CallBack;
2234     struct AFSVolSync tsync;
2235     struct volume *volp;
2236     XSTATS_DECLS;
2237     do {
2238         tc = afs_Conn(afid, areq, SHARED_LOCK);
2239         avc->dchint = NULL;     /* invalidate hints */
2240         if (tc) {
2241             avc->callback = tc->srvr->server;
2242             start = osi_Time();
2243             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHSTATUS);
2244             RX_AFS_GUNLOCK();
2245             code =
2246                 RXAFS_FetchStatus(tc->id, (struct AFSFid *)&afid->Fid, Outsp,
2247                                   &CallBack, &tsync);
2248             RX_AFS_GLOCK();
2249
2250             XSTATS_END_TIME;
2251
2252         } else
2253             code = -1;
2254     } while (afs_Analyze
2255              (tc, code, afid, areq, AFS_STATS_FS_RPCIDX_FETCHSTATUS,
2256               SHARED_LOCK, NULL));
2257
2258     if (!code) {
2259         afs_ProcessFS(avc, Outsp, areq);
2260         volp = afs_GetVolume(afid, areq, READ_LOCK);
2261         ObtainWriteLock(&afs_xcbhash, 469);
2262         avc->states |= CTruth;
2263         if (avc->callback /* check for race */ ) {
2264             if (CallBack.ExpirationTime != 0) {
2265                 avc->cbExpires = CallBack.ExpirationTime + start;
2266                 avc->states |= CStatd;
2267                 avc->states &= ~CBulkFetching;
2268                 afs_QueueCallback(avc, CBHash(CallBack.ExpirationTime), volp);
2269             } else if (avc->states & CRO) {     /* ordinary callback on a read-only volume -- AFS 3.2 style */
2270                 avc->cbExpires = 3600 + start;
2271                 avc->states |= CStatd;
2272                 avc->states &= ~CBulkFetching;
2273                 afs_QueueCallback(avc, CBHash(3600), volp);
2274             } else {
2275                 afs_DequeueCallback(avc);
2276                 avc->callback = NULL;
2277                 avc->states &= ~(CStatd | CUnique);
2278                 if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1))
2279                     osi_dnlc_purgedp(avc);      /* if it (could be) a directory */
2280             }
2281         } else {
2282             afs_DequeueCallback(avc);
2283             avc->callback = NULL;
2284             avc->states &= ~(CStatd | CUnique);
2285             if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1))
2286                 osi_dnlc_purgedp(avc);  /* if it (could be) a directory */
2287         }
2288         ReleaseWriteLock(&afs_xcbhash);
2289         if (volp)
2290             afs_PutVolume(volp, READ_LOCK);
2291     } else {
2292         /* used to undo the local callback, but that's too extreme.
2293          * There are plenty of good reasons that fetchstatus might return
2294          * an error, such as EPERM.  If we have the vnode cached, statd,
2295          * with callback, might as well keep track of the fact that we
2296          * don't have access...
2297          */
2298         if (code == EPERM || code == EACCES) {
2299             struct axscache *ac;
2300             if (avc->Access && (ac = afs_FindAxs(avc->Access, areq->uid)))
2301                 ac->axess = 0;
2302             else                /* not found, add a new one if possible */
2303                 afs_AddAxs(avc->Access, areq->uid, 0);
2304         }
2305     }
2306     return code;
2307 }
2308
2309 #if 0
2310 /*
2311  * afs_StuffVcache
2312  *
2313  * Description:
2314  *      Stuff some information into the vcache for the given file.
2315  *
2316  * Parameters:
2317  *      afid      : File in question.
2318  *      OutStatus : Fetch status on the file.
2319  *      CallBack  : Callback info.
2320  *      tc        : RPC connection involved.
2321  *      areq      : vrequest involved.
2322  *
2323  * Environment:
2324  *      Nothing interesting.
2325  */
2326 void
2327 afs_StuffVcache(register struct VenusFid *afid,
2328                 struct AFSFetchStatus *OutStatus,
2329                 struct AFSCallBack *CallBack, register struct conn *tc,
2330                 struct vrequest *areq)
2331 {
2332     register afs_int32 code, i, newvcache = 0;
2333     register struct vcache *tvc;
2334     struct AFSVolSync tsync;
2335     struct volume *tvp;
2336     struct axscache *ac;
2337     afs_int32 retry;
2338
2339     AFS_STATCNT(afs_StuffVcache);
2340 #ifdef IFS_VCACHECOUNT
2341     ifs_gvcachecall++;
2342 #endif
2343
2344   loop:
2345     ObtainSharedLock(&afs_xvcache, 8);
2346
2347     tvc = afs_FindVCache(afid, &retry, DO_VLRU /* no stats */ );
2348     if (tvc && retry) {
2349 #if     defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
2350         ReleaseSharedLock(&afs_xvcache);
2351         spunlock_psema(tvc->v.v_lock, retry, &tvc->v.v_sync, PINOD);
2352         goto loop;
2353 #endif
2354     }
2355
2356     if (!tvc) {
2357         /* no cache entry, better grab one */
2358         UpgradeSToWLock(&afs_xvcache, 25);
2359         tvc = afs_NewVCache(afid, NULL);
2360         newvcache = 1;
2361         ConvertWToSLock(&afs_xvcache);
2362     }
2363
2364     ReleaseSharedLock(&afs_xvcache);
2365     ObtainWriteLock(&tvc->lock, 58);
2366
2367     tvc->states &= ~CStatd;
2368     if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
2369         osi_dnlc_purgedp(tvc);  /* if it (could be) a directory */
2370
2371     /* Is it always appropriate to throw away all the access rights? */
2372     afs_FreeAllAxs(&(tvc->Access));
2373
2374     /*Copy useful per-volume info */
2375     tvp = afs_GetVolume(afid, areq, READ_LOCK);
2376     if (tvp) {
2377         if (newvcache && (tvp->states & VForeign))
2378             tvc->states |= CForeign;
2379         if (tvp->states & VRO)
2380             tvc->states |= CRO;
2381         if (tvp->states & VBackup)
2382             tvc->states |= CBackup;
2383         /*
2384          * Now, copy ".." entry back out of volume structure, if
2385          * necessary
2386          */
2387         if (tvc->mvstat == 2 && tvp->dotdot.Fid.Volume != 0) {
2388             if (!tvc->mvid)
2389                 tvc->mvid = (struct VenusFid *)
2390                     osi_AllocSmallSpace(sizeof(struct VenusFid));
2391             *tvc->mvid = tvp->dotdot;
2392         }
2393     }
2394     /* store the stat on the file */
2395     afs_RemoveVCB(afid);
2396     afs_ProcessFS(tvc, OutStatus, areq);
2397     tvc->callback = tc->srvr->server;
2398
2399     /* we use osi_Time twice below.  Ideally, we would use the time at which
2400      * the FetchStatus call began, instead, but we don't have it here.  So we
2401      * make do with "now".  In the CRO case, it doesn't really matter. In
2402      * the other case, we hope that the difference between "now" and when the
2403      * call actually began execution on the server won't be larger than the
2404      * padding which the server keeps.  Subtract 1 second anyway, to be on
2405      * the safe side.  Can't subtract more because we don't know how big
2406      * ExpirationTime is.  Possible consistency problems may arise if the call
2407      * timeout period becomes longer than the server's expiration padding.  */
2408     ObtainWriteLock(&afs_xcbhash, 470);
2409     if (CallBack->ExpirationTime != 0) {
2410         tvc->cbExpires = CallBack->ExpirationTime + osi_Time() - 1;
2411         tvc->states |= CStatd;
2412         tvc->states &= ~CBulkFetching;
2413         afs_QueueCallback(tvc, CBHash(CallBack->ExpirationTime), tvp);
2414     } else if (tvc->states & CRO) {
2415         /* old-fashioned AFS 3.2 style */
2416         tvc->cbExpires = 3600 + osi_Time();
2417          /*XXX*/ tvc->states |= CStatd;
2418         tvc->states &= ~CBulkFetching;
2419         afs_QueueCallback(tvc, CBHash(3600), tvp);
2420     } else {
2421         afs_DequeueCallback(tvc);
2422         tvc->callback = NULL;
2423         tvc->states &= ~(CStatd | CUnique);
2424         if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1))
2425             osi_dnlc_purgedp(tvc);      /* if it (could be) a directory */
2426     }
2427     ReleaseWriteLock(&afs_xcbhash);
2428     if (tvp)
2429         afs_PutVolume(tvp, READ_LOCK);
2430
2431     /* look in per-pag cache */
2432     if (tvc->Access && (ac = afs_FindAxs(tvc->Access, areq->uid)))
2433         ac->axess = OutStatus->CallerAccess;    /* substitute pags */
2434     else                        /* not found, add a new one if possible */
2435         afs_AddAxs(tvc->Access, areq->uid, OutStatus->CallerAccess);
2436
2437     ReleaseWriteLock(&tvc->lock);
2438     afs_Trace4(afs_iclSetp, CM_TRACE_STUFFVCACHE, ICL_TYPE_POINTER, tvc,
2439                ICL_TYPE_POINTER, tvc->callback, ICL_TYPE_INT32,
2440                tvc->cbExpires, ICL_TYPE_INT32, tvc->cbExpires - osi_Time());
2441     /*
2442      * Release ref count... hope this guy stays around...
2443      */
2444     afs_PutVCache(tvc);
2445 }                               /*afs_StuffVcache */
2446 #endif
2447
2448 /*
2449  * afs_PutVCache
2450  *
2451  * Description:
2452  *      Decrements the reference count on a cache entry.
2453  *
2454  * Parameters:
2455  *      avc : Pointer to the cache entry to decrement.
2456  *
2457  * Environment:
2458  *      Nothing interesting.
2459  */
2460 void
2461 afs_PutVCache(register struct vcache *avc)
2462 {
2463     AFS_STATCNT(afs_PutVCache);
2464     /*
2465      * Can we use a read lock here?
2466      */
2467     ObtainReadLock(&afs_xvcache);
2468     AFS_FAST_RELE(avc);
2469     ReleaseReadLock(&afs_xvcache);
2470 }                               /*afs_PutVCache */
2471
2472 /*
2473  * afs_FindVCache
2474  *
2475  * Description:
2476  *      Find a vcache entry given a fid.
2477  *
2478  * Parameters:
2479  *      afid : Pointer to the fid whose cache entry we desire.
2480  *      retry: (SGI-specific) tell the caller to drop the lock on xvcache,
2481  *             unlock the vnode, and try again.
2482  *      flags: bit 1 to specify whether to compute hit statistics.  Not
2483  *             set if FindVCache is called as part of internal bookkeeping.
2484  *
2485  * Environment:
2486  *      Must be called with the afs_xvcache lock at least held at
2487  *      the read level.  In order to do the VLRU adjustment, the xvcache lock
2488  *      must be shared-- we upgrade it here.
2489  */
2490
2491 struct vcache *
2492 afs_FindVCache(struct VenusFid *afid, afs_int32 * retry, afs_int32 flag)
2493 {
2494
2495     register struct vcache *tvc;
2496     afs_int32 i;
2497
2498     AFS_STATCNT(afs_FindVCache);
2499
2500     i = VCHash(afid);
2501     for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
2502         if (FidMatches(afid, tvc)) {
2503 #ifdef  AFS_OSF_ENV
2504             /* Grab this vnode, possibly reactivating from the free list */
2505             int vg;
2506             AFS_GUNLOCK();
2507             vg = vget(AFSTOV(tvc));
2508             AFS_GLOCK();
2509             if (vg)
2510                 continue;
2511 #endif /* AFS_OSF_ENV */
2512             break;
2513         }
2514     }
2515
2516     /* should I have a read lock on the vnode here? */
2517     if (tvc) {
2518         if (retry)
2519             *retry = 0;
2520 #if !defined(AFS_OSF_ENV)
2521         osi_vnhold(tvc, retry); /* already held, above */
2522         if (retry && *retry)
2523             return 0;
2524 #endif
2525 #ifdef AFS_DARWIN_ENV
2526         tvc->states |= CUBCinit;
2527         AFS_GUNLOCK();
2528         if (UBCINFOMISSING(AFSTOV(tvc)) ||
2529             UBCINFORECLAIMED(AFSTOV(tvc))) {
2530           ubc_info_init(AFSTOV(tvc));
2531         }
2532         AFS_GLOCK();
2533         tvc->states &= ~CUBCinit;
2534 #endif
2535         /*
2536          * only move to front of vlru if we have proper vcache locking)
2537          */
2538         if (flag & DO_VLRU) {
2539             if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
2540                 refpanic("FindVC VLRU inconsistent1");
2541             }
2542             if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
2543                 refpanic("FindVC VLRU inconsistent1");
2544             }
2545             if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
2546                 refpanic("FindVC VLRU inconsistent2");
2547             }
2548             UpgradeSToWLock(&afs_xvcache, 26);
2549             QRemove(&tvc->vlruq);
2550             QAdd(&VLRU, &tvc->vlruq);
2551             ConvertWToSLock(&afs_xvcache);
2552             if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
2553                 refpanic("FindVC VLRU inconsistent1");
2554             }
2555             if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
2556                 refpanic("FindVC VLRU inconsistent2");
2557             }
2558             if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
2559                 refpanic("FindVC VLRU inconsistent3");
2560             }
2561         }
2562         vcachegen++;
2563     }
2564
2565     if (flag & DO_STATS) {
2566         if (tvc)
2567             afs_stats_cmperf.vcacheHits++;
2568         else
2569             afs_stats_cmperf.vcacheMisses++;
2570         if (afs_IsPrimaryCellNum(afid->Cell))
2571             afs_stats_cmperf.vlocalAccesses++;
2572         else
2573             afs_stats_cmperf.vremoteAccesses++;
2574     }
2575 #ifdef AFS_LINUX22_ENV
2576     if (tvc && (tvc->states & CStatd))
2577         vcache2inode(tvc);      /* mainly to reset i_nlink */
2578 #endif
2579     return tvc;
2580 }                               /*afs_FindVCache */
2581
2582 /*
2583  * afs_NFSFindVCache
2584  *
2585  * Description:
2586  *      Find a vcache entry given a fid. Does a wildcard match on what we
2587  *      have for the fid. If more than one entry, don't return anything.
2588  *
2589  * Parameters:
2590  *      avcp : Fill in pointer if we found one and only one.
2591  *      afid : Pointer to the fid whose cache entry we desire.
2592  *      retry: (SGI-specific) tell the caller to drop the lock on xvcache,
2593  *             unlock the vnode, and try again.
2594  *      flags: bit 1 to specify whether to compute hit statistics.  Not
2595  *             set if FindVCache is called as part of internal bookkeeping.
2596  *
2597  * Environment:
2598  *      Must be called with the afs_xvcache lock at least held at
2599  *      the read level.  In order to do the VLRU adjustment, the xvcache lock
2600  *      must be shared-- we upgrade it here.
2601  *
2602  * Return value:
2603  *      number of matches found.
2604  */
2605
2606 int afs_duplicate_nfs_fids = 0;
2607
2608 afs_int32
2609 afs_NFSFindVCache(struct vcache **avcp, struct VenusFid *afid)
2610 {
2611     register struct vcache *tvc;
2612     afs_int32 i;
2613     afs_int32 count = 0;
2614     struct vcache *found_tvc = NULL;
2615
2616     AFS_STATCNT(afs_FindVCache);
2617
2618 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
2619   loop:
2620 #endif
2621
2622     ObtainSharedLock(&afs_xvcache, 331);
2623
2624     i = VCHash(afid);
2625     for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
2626         /* Match only on what we have.... */
2627         if (((tvc->fid.Fid.Vnode & 0xffff) == afid->Fid.Vnode)
2628             && (tvc->fid.Fid.Volume == afid->Fid.Volume)
2629             && ((tvc->fid.Fid.Unique & 0xffffff) == afid->Fid.Unique)
2630             && (tvc->fid.Cell == afid->Cell)) {
2631 #ifdef  AFS_OSF_ENV
2632             /* Grab this vnode, possibly reactivating from the free list */
2633             int vg;
2634             AFS_GUNLOCK();
2635             vg = vget(AFSTOV(tvc));
2636             AFS_GLOCK();
2637             if (vg) {
2638                 /* This vnode no longer exists. */
2639                 continue;
2640             }
2641 #endif /* AFS_OSF_ENV */
2642             count++;
2643             if (found_tvc) {
2644                 /* Duplicates */
2645 #ifdef AFS_OSF_ENV
2646                 /* Drop our reference counts. */
2647                 vrele(AFSTOV(tvc));
2648                 vrele(AFSTOV(found_tvc));
2649 #endif
2650                 afs_duplicate_nfs_fids++;
2651                 ReleaseSharedLock(&afs_xvcache);
2652                 return count;
2653             }
2654             found_tvc = tvc;
2655         }
2656     }
2657
2658     tvc = found_tvc;
2659     /* should I have a read lock on the vnode here? */
2660     if (tvc) {
2661 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV)
2662         afs_int32 retry = 0;
2663         osi_vnhold(tvc, &retry);
2664         if (retry) {
2665             count = 0;
2666             found_tvc = (struct vcache *)0;
2667             ReleaseSharedLock(&afs_xvcache);
2668             spunlock_psema(tvc->v.v_lock, retry, &tvc->v.v_sync, PINOD);
2669             goto loop;
2670         }
2671 #else
2672 #if !defined(AFS_OSF_ENV)
2673         osi_vnhold(tvc, (int *)0);      /* already held, above */
2674 #endif
2675 #endif
2676         /*
2677          * We obtained the xvcache lock above.
2678          */
2679         if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
2680             refpanic("FindVC VLRU inconsistent1");
2681         }
2682         if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
2683             refpanic("FindVC VLRU inconsistent1");
2684         }
2685         if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
2686             refpanic("FindVC VLRU inconsistent2");
2687         }
2688         UpgradeSToWLock(&afs_xvcache, 568);
2689         QRemove(&tvc->vlruq);
2690         QAdd(&VLRU, &tvc->vlruq);
2691         ConvertWToSLock(&afs_xvcache);
2692         if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
2693             refpanic("FindVC VLRU inconsistent1");
2694         }
2695         if (tvc->vlruq.next->prev != &(tvc->vlruq)) {
2696             refpanic("FindVC VLRU inconsistent2");
2697         }
2698         if (tvc->vlruq.prev->next != &(tvc->vlruq)) {
2699             refpanic("FindVC VLRU inconsistent3");
2700         }
2701     }
2702     vcachegen++;
2703
2704     if (tvc)
2705         afs_stats_cmperf.vcacheHits++;
2706     else
2707         afs_stats_cmperf.vcacheMisses++;
2708     if (afs_IsPrimaryCellNum(afid->Cell))
2709         afs_stats_cmperf.vlocalAccesses++;
2710     else
2711         afs_stats_cmperf.vremoteAccesses++;
2712
2713     *avcp = tvc;                /* May be null */
2714
2715     ReleaseSharedLock(&afs_xvcache);
2716     return (tvc ? 1 : 0);
2717
2718 }                               /*afs_NFSFindVCache */
2719
2720
2721
2722
2723 /*
2724  * afs_vcacheInit
2725  *
2726  * Initialize vcache related variables
2727  */
2728 void
2729 afs_vcacheInit(int astatSize)
2730 {
2731     register struct vcache *tvp;
2732     int i;
2733 #if     defined(AFS_OSF_ENV)
2734     if (!afs_maxvcount) {
2735 #if     defined(AFS_OSF30_ENV)
2736         afs_maxvcount = max_vnodes / 2; /* limit ourselves to half the total */
2737 #else
2738         afs_maxvcount = nvnode / 2;     /* limit ourselves to half the total */
2739 #endif
2740         if (astatSize < afs_maxvcount) {
2741             afs_maxvcount = astatSize;
2742         }
2743     }
2744 #else /* AFS_OSF_ENV */
2745     freeVCList = NULL;
2746 #endif
2747
2748     RWLOCK_INIT(&afs_xvcache, "afs_xvcache");
2749     LOCK_INIT(&afs_xvcb, "afs_xvcb");
2750
2751 #if     !defined(AFS_OSF_ENV)
2752 #ifdef AFS_LINUX26_ENV
2753     printf("old style would have needed %d contiguous bytes\n", astatSize *
2754            sizeof(struct vcache));
2755     Initial_freeVCList = freeVCList = tvp = (struct vcache *)
2756         afs_osi_Alloc(sizeof(struct vcache));
2757     for (i = 0; i < astatSize; i++) {
2758         tvp->nextfree = (struct vcache *) afs_osi_Alloc(sizeof(struct vcache));
2759         tvp = tvp->nextfree;
2760     }
2761     tvp->nextfree = NULL;
2762 #else
2763     /* Allocate and thread the struct vcache entries */
2764     tvp = (struct vcache *)afs_osi_Alloc(astatSize * sizeof(struct vcache));
2765     memset((char *)tvp, 0, sizeof(struct vcache) * astatSize);
2766
2767     Initial_freeVCList = tvp;
2768     freeVCList = &(tvp[0]);
2769     for (i = 0; i < astatSize - 1; i++) {
2770         tvp[i].nextfree = &(tvp[i + 1]);
2771     }
2772     tvp[astatSize - 1].nextfree = NULL;
2773 #ifdef  KERNEL_HAVE_PIN
2774     pin((char *)tvp, astatSize * sizeof(struct vcache));        /* XXX */
2775 #endif
2776 #endif
2777 #endif
2778
2779 #if defined(AFS_SGI_ENV)
2780     for (i = 0; i < astatSize; i++) {
2781         char name[METER_NAMSZ];
2782         struct vcache *tvc = &tvp[i];
2783
2784         tvc->v.v_number = ++afsvnumbers;
2785         tvc->vc_rwlockid = OSI_NO_LOCKID;
2786         initnsema(&tvc->vc_rwlock, 1,
2787                   makesname(name, "vrw", tvc->v.v_number));
2788 #ifndef AFS_SGI53_ENV
2789         initnsema(&tvc->v.v_sync, 0, makesname(name, "vsy", tvc->v.v_number));
2790 #endif
2791 #ifndef AFS_SGI62_ENV
2792         initnlock(&tvc->v.v_lock, makesname(name, "vlk", tvc->v.v_number));
2793 #endif /* AFS_SGI62_ENV */
2794     }
2795 #endif
2796
2797     QInit(&VLRU);
2798
2799
2800 }
2801
2802 /*
2803  * shutdown_vcache
2804  *
2805  */
2806 void
2807 shutdown_vcache(void)
2808 {
2809     int i;
2810     struct afs_cbr *tsp, *nsp;
2811     /*
2812      * XXX We may potentially miss some of the vcaches because if when there're no
2813      * free vcache entries and all the vcache entries are active ones then we allocate
2814      * an additional one - admittedly we almost never had that occur.
2815      */
2816
2817     {
2818         register struct afs_q *tq, *uq;
2819         register struct vcache *tvc;
2820         for (tq = VLRU.prev; tq != &VLRU; tq = uq) {
2821             tvc = QTOV(tq);
2822             uq = QPrev(tq);
2823             if (tvc->mvid) {
2824                 osi_FreeSmallSpace(tvc->mvid);
2825                 tvc->mvid = (struct VenusFid *)0;
2826             }
2827 #ifdef  AFS_AIX_ENV
2828             aix_gnode_rele(AFSTOV(tvc));
2829 #endif
2830             if (tvc->linkData) {
2831                 afs_osi_Free(tvc->linkData, strlen(tvc->linkData) + 1);
2832                 tvc->linkData = 0;
2833             }
2834         }
2835         /*
2836          * Also free the remaining ones in the Cache
2837          */
2838         for (i = 0; i < VCSIZE; i++) {
2839             for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
2840                 if (tvc->mvid) {
2841                     osi_FreeSmallSpace(tvc->mvid);
2842                     tvc->mvid = (struct VenusFid *)0;
2843                 }
2844 #ifdef  AFS_AIX_ENV
2845                 if (tvc->v.v_gnode)
2846                     afs_osi_Free(tvc->v.v_gnode, sizeof(struct gnode));
2847 #ifdef  AFS_AIX32_ENV
2848                 if (tvc->segid) {
2849                     AFS_GUNLOCK();
2850                     vms_delete(tvc->segid);
2851                     AFS_GLOCK();
2852                     tvc->segid = tvc->vmh = NULL;
2853                     if (VREFCOUNT(tvc))
2854                         osi_Panic("flushVcache: vm race");
2855                 }
2856                 if (tvc->credp) {
2857                     crfree(tvc->credp);
2858                     tvc->credp = NULL;
2859                 }
2860 #endif
2861 #endif
2862 #if     defined(AFS_SUN5_ENV)
2863                 if (tvc->credp) {
2864                     crfree(tvc->credp);
2865                     tvc->credp = NULL;
2866                 }
2867 #endif
2868                 if (tvc->linkData) {
2869                     afs_osi_Free(tvc->linkData, strlen(tvc->linkData) + 1);
2870                     tvc->linkData = 0;
2871                 }
2872
2873                 afs_FreeAllAxs(&(tvc->Access));
2874             }
2875             afs_vhashT[i] = afs_vhashTV[i] = 0;
2876         }
2877     }
2878     /*
2879      * Free any leftover callback queue
2880      */
2881     for (tsp = afs_cbrSpace; tsp; tsp = nsp) {
2882         nsp = tsp->next;
2883         afs_osi_Free((char *)tsp, AFS_NCBRS * sizeof(struct afs_cbr));
2884     }
2885     afs_cbrSpace = 0;
2886
2887 #ifdef AFS_LINUX26_ENV
2888     {
2889         struct vcache *tvp = Initial_freeVCList;
2890         while (tvp) {
2891             struct vcache *next = tvp->nextfree;
2892             
2893             afs_osi_Free(tvp, sizeof(struct vcache));
2894             tvp = next;
2895         }
2896     }
2897 #else
2898 #ifdef  KERNEL_HAVE_PIN
2899     unpin(Initial_freeVCList, afs_cacheStats * sizeof(struct vcache));
2900 #endif
2901 #if     !defined(AFS_OSF_ENV)
2902     afs_osi_Free(Initial_freeVCList, afs_cacheStats * sizeof(struct vcache));
2903 #endif
2904 #endif
2905
2906 #if     !defined(AFS_OSF_ENV)
2907     freeVCList = Initial_freeVCList = 0;
2908 #endif
2909     RWLOCK_INIT(&afs_xvcache, "afs_xvcache");
2910     LOCK_INIT(&afs_xvcb, "afs_xvcb");
2911     QInit(&VLRU);
2912
2913 }