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