b8a5693c948ec25096f6067e336566f0400eb26b
[openafs.git] / src / afs / VNOPS / afs_vnop_lookup.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_lookup
13  * EvalMountPoint
14  * afs_DoBulkStat
15  *
16  * Locals:
17  * afs_strcat
18  * AFS_EQ_ATSYS (macro)
19  * afs_index
20  */
21
22 #include <afsconfig.h>
23 #include "../afs/param.h"
24
25 RCSID("$Header$");
26
27 #include "../afs/sysincludes.h" /* Standard vendor system headers */
28 #include "../afs/afsincludes.h" /* Afs-based standard headers */
29 #include "../afs/afs_stats.h" /* statistics */
30 #include "../afs/afs_cbqueue.h"
31 #include "../afs/nfsclient.h"
32 #include "../afs/exporter.h"
33 #include "../afs/afs_osidnlc.h"
34
35
36 /**
37  * A few definitions. This is until we have a proper header file        
38  * which has prototypes for all functions
39  */
40
41 extern struct DirEntry * afs_dir_GetBlob();
42
43 extern afs_rwlock_t afs_xvcache;
44 extern afs_rwlock_t afs_xcbhash;
45 extern struct afs_exporter *afs_nfsexporter;
46 extern char *afs_sysname;
47 extern char *afs_sysnamelist[];
48 extern int afs_sysnamecount;
49 extern struct afs_q VLRU;                       /*vcache LRU*/
50 #ifdef AFS_LINUX22_ENV
51 extern struct inode_operations afs_symlink_iops, afs_dir_iops;
52 #endif
53
54
55 afs_int32 afs_bulkStatsDone;
56 static int bulkStatCounter = 0; /* counter for bulk stat seq. numbers */
57
58
59 /* this would be faster if it did comparison as int32word, but would be 
60  * dependant on byte-order and alignment, and I haven't figured out
61  * what "@sys" is in binary... */
62 #define AFS_EQ_ATSYS(name) (((name)[0]=='@')&&((name)[1]=='s')&&((name)[2]=='y')&&((name)[3]=='s')&&(!(name)[4]))
63
64 char *
65 afs_strcat(s1, s2)
66         register char *s1, *s2;
67 {
68         register char *os1;
69
70         AFS_STATCNT(strcat);
71         os1 = s1;
72         while (*s1++)
73                 ;
74         --s1;
75         while (*s1++ = *s2++)
76                 ;
77         return (os1);
78 }
79
80
81 char *afs_index(a, c)
82     register char *a, c; {
83     register char tc;
84     AFS_STATCNT(afs_index);
85     while (tc = *a) {
86         if (tc == c) return a;
87         else a++;
88     }
89     return (char *) 0;
90 }
91
92 /* call under write lock, evaluate mvid field from a mt pt.
93  * avc is the vnode of the mount point object.
94  * advc is the vnode of the containing directory
95  * avolpp is where we return a pointer to the volume named by the mount pt, if success
96  * areq is the identity of the caller.
97  *
98  * NOTE: this function returns a held volume structure in *volpp if it returns 0!
99  */
100 EvalMountPoint(avc, advc, avolpp, areq)
101     register struct vcache *avc;
102     struct volume **avolpp;
103     struct vcache *advc;            /* the containing dir */
104     register struct vrequest *areq;
105 {
106     afs_int32  code;
107     struct volume *tvp = 0;
108     struct VenusFid tfid;
109     struct cell *tcell;
110     char   *cpos, *volnamep;
111     char   type, buf[128];
112     afs_int32  prefetchRO;          /* 1=>No  2=>Yes */
113     afs_int32  mtptCell, assocCell, hac=0;
114     afs_int32  samecell, roname, len;
115
116     AFS_STATCNT(EvalMountPoint);
117 #ifdef notdef
118     if (avc->mvid && (avc->states & CMValid)) return 0; /* done while racing */
119 #endif
120     *avolpp = (struct volume *)0;
121     code = afs_HandleLink(avc, areq);
122     if (code) return code;
123
124     /* Determine which cell and volume the mointpoint goes to */
125     type = avc->linkData[0];                   /* '#'=>Regular '%'=>RW */
126     cpos = afs_index(&avc->linkData[1], ':');  /* if cell name present */
127     if (cpos) {
128        volnamep = cpos+1;
129        *cpos = 0;
130        tcell = afs_GetCellByName(&avc->linkData[1], READ_LOCK);
131        *cpos =  ':';
132     } else {
133        volnamep = &avc->linkData[1];
134        tcell = afs_GetCell(avc->fid.Cell, READ_LOCK);
135     }
136     if (!tcell) return ENOENT;
137
138     mtptCell = tcell->cell;               /* The cell for the mountpoint */
139     if (tcell->lcellp) {
140        hac = 1;                           /* has associated cell */
141        assocCell = tcell->lcellp->cell;   /* The associated cell */
142     }
143     afs_PutCell(tcell, READ_LOCK);          
144
145     /* Is volume name a "<n>.backup" or "<n>.readonly" name */
146     len = strlen(volnamep);
147     roname = ((len > 9) && (strcmp(&volnamep[len - 9],".readonly") == 0)) ||
148              ((len > 7) && (strcmp(&volnamep[len - 7],".backup")   == 0));
149
150     /* When we cross mountpoint, do we stay in the same cell */
151     samecell = (avc->fid.Cell == mtptCell) || (hac && (avc->fid.Cell == assocCell));
152
153     /* Decide whether to prefetch the RO. Also means we want the RO.
154      * If this is a regular mountpoint with a RW volume name and
155      * we cross a cell boundary -or- start from a RO volume, then we will
156      * want to prefetch the RO volume when we get the RW below.
157      */
158     if ( (type == '#') && !roname && (!samecell || (avc->states & CRO)) ) {
159        prefetchRO = 2; /* Yes, prefetch the RO */
160     } else {
161        prefetchRO = 1; /* No prefetch of the RO */
162     }
163
164     /* Get the volume struct. Unless this volume name has ".readonly" or
165      * ".backup" in it, this will get the volume struct for the RW volume.
166      * The RO volume will be prefetched if requested (but not returned).
167      */
168     tvp = afs_GetVolumeByName(volnamep, mtptCell, prefetchRO, areq, WRITE_LOCK);
169
170     /* If no volume was found in this cell, try the associated linked cell */
171     if (!tvp && hac && areq->volumeError) {
172        tvp = afs_GetVolumeByName(volnamep, assocCell, prefetchRO, areq, WRITE_LOCK);
173     }
174
175     /* Still not found. If we are looking for the RO, then perhaps the RW 
176      * doesn't exist? Try adding ".readonly" to volname and look for that.
177      * Don't know why we do this. Would have still found it in above call - jpm.
178      */
179     if (!tvp && (prefetchRO == 2)) {
180        strcpy(buf, volnamep);
181        afs_strcat(buf, ".readonly");
182
183        tvp = afs_GetVolumeByName(buf, mtptCell, 1, areq, WRITE_LOCK);
184
185        /* Try the associated linked cell if failed */
186        if (!tvp && hac && areq->volumeError) {
187           tvp = afs_GetVolumeByName(buf, assocCell, 1, areq, WRITE_LOCK);
188        }
189     }
190   
191     if (!tvp) return ENODEV;       /* Couldn't find the volume */
192
193     /* Don't cross mountpoint from a BK to a BK volume */
194     if ((avc->states & CBackup) && (tvp->states & VBackup)) {
195         afs_PutVolume(tvp, WRITE_LOCK);
196         return ELOOP;
197     }
198
199     /* If we want (prefetched) the RO and it exists, then drop the
200      * RW volume and get the RO. Othewise, go with the RW.
201      */
202     if ((prefetchRO == 2) && tvp->roVol) {
203        tfid.Fid.Volume = tvp->roVol;                 /* remember RO volume */
204        tfid.Cell       = tvp->cell;
205        afs_PutVolume(tvp, WRITE_LOCK);               /* release old volume */
206        tvp = afs_GetVolume(&tfid, areq, WRITE_LOCK); /* get the new one */
207        if (!tvp) return ENODEV;                      /* oops, can't do it */
208     }
209
210     if (avc->mvid == 0)
211         avc->mvid = (struct VenusFid *) osi_AllocSmallSpace(sizeof(struct VenusFid));
212     avc->mvid->Cell = tvp->cell;
213     avc->mvid->Fid.Volume = tvp->volume;
214     avc->mvid->Fid.Vnode = 1;
215     avc->mvid->Fid.Unique = 1;
216     avc->states |= CMValid;
217
218     /* Used to: if the mount point is stored within a backup volume,
219      * then we should only update the parent pointer information if
220      * there's none already set, so as to avoid updating a volume's ..
221      * info with something in an OldFiles directory.
222      *
223      * Next two lines used to be under this if:
224      *
225      * if (!(avc->states & CBackup) || tvp->dotdot.Fid.Volume == 0)
226      *
227      * Now: update mount point back pointer on every call, so that we handle
228      * multiple mount points better.  This way, when du tries to go back
229      * via chddir(".."), it will end up exactly where it started, yet
230      * cd'ing via a new path to a volume will reset the ".." pointer
231      * to the new path.
232      */
233     tvp->mtpoint = avc->fid;    /* setup back pointer to mtpoint */
234     tvp->dotdot  = advc->fid;
235
236     *avolpp = tvp;
237     return 0;
238 }
239     
240 afs_ENameOK(aname)
241     register char *aname; {
242     register char tc;
243     register int tlen;
244
245     AFS_STATCNT(ENameOK);
246     tlen = strlen(aname);
247     if (tlen >= 4 && strcmp(aname+tlen-4, "@sys") == 0) return 0;
248     return 1;
249 }
250
251 afs_getsysname(areq, adp, bufp)
252     register struct vrequest *areq;
253     register struct vcache *adp;
254     register char *bufp;
255 {
256     static char sysname[MAXSYSNAME];
257     register struct unixuser *au;
258     register afs_int32 error;
259
260     if (!afs_nfsexporter) {
261       strcpy(bufp, afs_sysname);
262       return 0;
263     }
264     AFS_STATCNT(getsysname);
265     au = afs_GetUser(areq->uid, adp->fid.Cell, 0);
266     afs_PutUser(au, 0); 
267     if (au->exporter) {
268       error = EXP_SYSNAME(au->exporter, (char *)0, bufp);
269       if (error) 
270         strcpy(bufp, "@sys");
271       return -1;
272     } else {
273       strcpy(bufp, afs_sysname);
274       return 0;
275     }
276 }
277
278 Check_AtSys(avc, aname, state, areq)
279     register struct vcache *avc;
280     char *aname;
281     struct sysname_info *state;
282     struct vrequest *areq;
283 {
284     if (AFS_EQ_ATSYS(aname)) {
285       state->offset = 0;
286       state->name = (char *) osi_AllocLargeSpace(AFS_SMALLOCSIZ);
287       state->allocked = 1;
288       state->index = afs_getsysname(areq, avc, state->name);
289     } else {
290       state->offset = -1;
291       state->allocked = 0;
292       state->index = 0;
293       state->name = aname;
294     }
295 }
296
297 Next_AtSys(avc, areq, state)
298      register struct vcache *avc;
299      struct vrequest *areq;
300      struct sysname_info *state;
301 {
302   if (state->index == -1)
303     return 0;   /* No list */
304
305   /* Check for the initial state of aname != "@sys" in Check_AtSys*/
306   if (state->offset == -1 && state->allocked == 0) {
307     register char *tname;
308     /* Check for .*@sys */
309       for (tname=state->name; *tname; tname++)
310         /*Move to the end of the string*/;
311       if ((tname > state->name + 4) && (AFS_EQ_ATSYS(tname-4))) {
312         state->offset = (tname - 4) - state->name;
313         tname = (char *) osi_AllocLargeSpace(AFS_LRALLOCSIZ);
314         strncpy(tname, state->name, state->offset);
315         state->name = tname;
316         state->allocked = 1;
317         state->index = afs_getsysname(areq, avc, state->name+state->offset);
318         return 1;
319       } else
320         return 0; /* .*@sys doesn't match either */
321   } else if (++(state->index) >= afs_sysnamecount
322              || !afs_sysnamelist[state->index])
323     return 0;   /* end of list */
324   strcpy(state->name+state->offset, afs_sysnamelist[state->index]);
325   return 1;
326 }
327
328 #if (defined(AFS_SGI62_ENV) || defined(AFS_SUN57_64BIT_ENV))
329 extern int BlobScan(ino64_t *afile, afs_int32 ablob);
330 #else
331 #if defined AFS_LINUX_64BIT_KERNEL
332 extern int BlobScan(long *afile, afs_int32 ablob);
333 #else
334 extern int BlobScan(afs_int32 *afile, afs_int32 ablob);
335 #endif
336 #endif
337
338
339 /* called with an unlocked directory and directory cookie.  Areqp
340  * describes who is making the call.
341  * Scans the next N (about 30, typically) directory entries, and does
342  * a bulk stat call to stat them all.
343  *
344  * Must be very careful when merging in RPC responses, since we dont
345  * want to overwrite newer info that was added by a file system mutating
346  * call that ran concurrently with our bulk stat call.
347  *
348  * We do that, as described below, by not merging in our info (always
349  * safe to skip the merge) if the status info is valid in the vcache entry.
350  *
351  * If adapt ever implements the bulk stat RPC, then this code will need to
352  * ensure that vcaches created for failed RPC's to older servers have the
353  * CForeign bit set.
354  */
355 struct vcache * BStvc = (struct vcache *) 0;
356 void afs_DoBulkStat(adp, dirCookie, areqp)
357   struct vcache *adp;
358   long dirCookie;
359   struct vrequest *areqp;
360 {
361     int nentries;               /* # of entries to prefetch */
362     int nskip;                  /* # of slots in the LRU queue to skip */
363     struct vcache *lruvcp;      /* vcache ptr of our goal pos in LRU queue */
364     struct dcache *dcp;         /* chunk containing the dir block */
365     char *statMemp;             /* status memory block */
366     char *cbfMemp;              /* callback and fid memory block */
367     long temp;                  /* temp for holding chunk length, &c. */
368     struct AFSFid *fidsp;       /* file IDs were collecting */
369     struct AFSCallBack *cbsp;   /* call back pointers */
370     struct AFSCallBack *tcbp;   /* temp callback ptr */
371     struct AFSFetchStatus *statsp;      /* file status info */
372     struct AFSVolSync volSync;  /* vol sync return info */
373     struct vcache *tvcp;        /* temp vcp */
374     struct afs_q *tq;           /* temp queue variable */
375     AFSCBFids fidParm;          /* file ID parm for bulk stat */
376     AFSBulkStats statParm;      /* stat info parm for bulk stat */
377     int fidIndex;               /* which file were stating */
378     struct conn *tcp;           /* conn for call */
379     AFSCBs cbParm;              /* callback parm for bulk stat */
380     struct server *hostp = 0;   /* host we got callback from */
381     long origEvenCBs;           /* original # of callbacks for even-fid files */
382     long origOddCBs;            /* original # of callbacks for odd-fid files */
383     long origEvenZaps;          /* original # of recycles for even-fid files */
384     long origOddZaps;           /* original # of recycles for odd-fid files */
385     long startTime;             /* time we started the call,
386                                  * for callback expiration base
387                                  */
388     int statSeqNo;              /* Valued of file size to detect races */
389     int code;                   /* error code */
390     long newIndex;              /* new index in the dir */
391     struct DirEntry *dirEntryp; /* dir entry we are examining */
392     int i;
393     struct VenusFid afid;       /* file ID we are using now */
394     struct VenusFid tfid;       /* another temp. file ID */
395     afs_int32 retry;                  /* handle low-level SGI MP race conditions */
396     long volStates;             /* flags from vol structure */
397     struct volume *volp=0;      /* volume ptr */
398     struct VenusFid dotdot;
399     int flagIndex;              /* First file with bulk fetch flag set */
400     XSTATS_DECLS
401
402     /* first compute some basic parameters.  We dont want to prefetch more
403      * than a fraction of the cache in any given call, and we want to preserve
404      * a portion of the LRU queue in any event, so as to avoid thrashing
405      * the entire stat cache (we will at least leave some of it alone).
406      * presently dont stat more than 1/8 the cache in any one call.      */
407     nentries = afs_cacheStats / 8;
408
409     /* dont bother prefetching more than one calls worth of info */
410     if (nentries > AFSCBMAX) nentries = AFSCBMAX;
411
412     /* heuristic to make sure that things fit in 4K.  This means that
413      * we shouldnt make it any bigger than 47 entries.  I am typically
414      * going to keep it a little lower, since we don't want to load
415      * too much of the stat cache.
416      */
417     if (nentries > 30) nentries = 30;
418
419     /* now, to reduce the stack size, well allocate two 4K blocks,
420      * one for fids and callbacks, and one for stat info.  Well set
421      * up our pointers to the memory from there, too.
422      */
423     statMemp = osi_AllocLargeSpace(nentries * sizeof(AFSFetchStatus));
424     statsp = (struct AFSFetchStatus *) statMemp;
425     cbfMemp = osi_AllocLargeSpace(nentries *
426         (sizeof(AFSCallBack) + sizeof(AFSFid)));
427     fidsp = (AFSFid *) cbfMemp;
428     cbsp = (AFSCallBack *) (cbfMemp + nentries * sizeof(AFSFid));
429
430     /* next, we must iterate over the directory, starting from the specified
431      * cookie offset (dirCookie), and counting out nentries file entries.
432      * We skip files that already have stat cache entries, since we
433      * dont want to bulk stat files that are already in the cache.
434      */
435 tagain:
436     code = afs_VerifyVCache(adp, areqp);
437     if (code) goto done;
438
439     dcp = afs_GetDCache(adp, 0, areqp, &temp, &temp, 1);
440     if (!dcp) {
441         code = ENOENT;
442         goto done;
443     }
444
445     /* lock the directory cache entry */
446     ObtainReadLock(&adp->lock);
447
448     /*
449      * Make sure that the data in the cache is current. There are two
450      * cases we need to worry about:
451      * 1. The cache data is being fetched by another process.
452      * 2. The cache data is no longer valid
453      */
454     while ((adp->states & CStatd)
455            && (dcp->flags & DFFetching)
456            && hsame(adp->m.DataVersion, dcp->f.versionNo)) {
457         dcp->flags |= DFWaiting;
458         ReleaseReadLock(&adp->lock);
459         afs_osi_Sleep(&dcp->validPos);
460         ObtainReadLock(&adp->lock);
461     }
462     if (!(adp->states & CStatd)
463         || !hsame(adp->m.DataVersion, dcp->f.versionNo)) {
464         ReleaseReadLock(&adp->lock);
465         afs_PutDCache(dcp);
466         goto tagain;
467     }
468
469     /* Generate a sequence number so we can tell whether we should
470      * store the attributes when processing the response. This number is
471      * stored in the file size when we set the CBulkFetching bit. If the
472      * CBulkFetching is still set and this value hasn't changed, then
473      * we know we were the last to set CBulkFetching bit for this file,
474      * and it is safe to set the status information for this file.
475      */
476     statSeqNo = bulkStatCounter++;
477
478     /* now we have dir data in the cache, so scan the dir page */
479     fidIndex = 0;
480     flagIndex = 0;
481     while (1) { /* Should probably have some constant bound */
482         /* look for first safe entry to examine in the directory.  BlobScan
483          * looks for a the 1st allocated dir after the dirCookie slot.
484          */
485         newIndex = BlobScan(&dcp->f.inode, (dirCookie>>5));
486         if (newIndex == 0) break;
487
488         /* remember the updated directory cookie */
489         dirCookie = newIndex << 5;
490
491         /* get a ptr to the dir entry */
492         dirEntryp =(struct DirEntry *)afs_dir_GetBlob(&dcp->f.inode, newIndex);
493         if (!dirEntryp) break;
494
495         /* dont copy more than we have room for */
496         if (fidIndex >= nentries) {
497           DRelease((char *) dirEntryp, 0);
498           break;
499         }
500
501         /* now, if the dir entry looks good, copy it out to our list.  Vnode
502          * 0 means deleted, although it should also be free were it deleted.
503          */
504         if (dirEntryp->fid.vnode != 0) {
505             /* dont copy entries we have in our cache.  This check will
506              * also make us skip "." and probably "..", unless it has
507              * disappeared from the cache since we did our namei call.
508              */
509             tfid.Cell = adp->fid.Cell;
510             tfid.Fid.Volume = adp->fid.Fid.Volume;
511             tfid.Fid.Vnode = ntohl(dirEntryp->fid.vnode);
512             tfid.Fid.Unique = ntohl(dirEntryp->fid.vunique);
513             do {
514               retry = 0;
515               ObtainWriteLock(&afs_xvcache, 130);
516               tvcp = afs_FindVCache(&tfid, 0, 0, &retry, 0 /* no stats | LRU */);
517               if (tvcp && retry) {
518                 ReleaseWriteLock(&afs_xvcache);
519                 afs_PutVCache(tvcp);
520               }
521             } while (tvcp && retry);
522             if (!tvcp) {          /* otherwise, create manually */
523               tvcp = afs_NewVCache(&tfid, hostp, 0, 0);
524               ObtainWriteLock(&tvcp->lock, 505);
525               ReleaseWriteLock(&afs_xvcache);
526               afs_RemoveVCB(&tfid);
527               ReleaseWriteLock(&tvcp->lock);
528             } else {
529               ReleaseWriteLock(&afs_xvcache);
530             }
531             if (!tvcp)
532               goto done; /* can't happen at present, more's the pity */
533
534             /* WARNING: afs_DoBulkStat uses the Length field to store a
535              * sequence number for each bulk status request. Under no
536              * circumstances should afs_DoBulkStat store a sequence number
537              * if the new length will be ignored when afs_ProcessFS is
538              * called with new stats. */
539 #ifdef AFS_SGI_ENV
540             if (!(tvcp->states & (CStatd|CBulkFetching))
541                 && (tvcp->execsOrWriters <= 0)
542                 && !afs_DirtyPages(tvcp)
543                 && !AFS_VN_MAPPED((vnode_t*)tvcp))
544 #else
545             if (!(tvcp->states & (CStatd|CBulkFetching))
546                 && (tvcp->execsOrWriters <= 0) 
547                 && !afs_DirtyPages(tvcp))
548 #endif
549
550             {
551                 /* this entry doesnt exist in the cache, and is not
552                  * already being fetched by someone else, so add it to the
553                  * list of file IDs to obtain.
554                  *
555                  * We detect a callback breaking race condition by checking the
556                  * CBulkFetching state bit and the value in the file size.
557                  * It is safe to set the status only if the CBulkFetching
558                  * flag is still set and the value in the file size does
559                  * not change.
560                  *
561                  * Don't fetch status for dirty files. We need to
562                  * preserve the value of the file size. We could
563                  * flush the pages, but it wouldn't be worthwhile.
564                  */
565                 bcopy((char *) &tfid.Fid, (char *)(fidsp+fidIndex),
566                       sizeof(*fidsp));
567                 tvcp->states |= CBulkFetching;
568                 tvcp->m.Length = statSeqNo;
569                 fidIndex++;
570             }
571             afs_PutVCache(tvcp);
572         }       /* if dir vnode has non-zero entry */
573
574         /* move to the next dir entry by adding in the # of entries
575          * used by this dir entry.
576          */
577         temp = afs_dir_NameBlobs(dirEntryp->name) << 5;
578         DRelease((char *) dirEntryp, 0);
579         if (temp <= 0) break;
580         dirCookie += temp;
581     }   /* while loop over all dir entries */
582
583     /* now release the dir lock and prepare to make the bulk RPC */
584     ReleaseReadLock(&adp->lock);
585
586     /* release the chunk */
587     afs_PutDCache(dcp);
588
589     /* dont make a null call */
590     if (fidIndex == 0) goto done;
591
592     do {
593         /* setup the RPC parm structures */
594         fidParm.AFSCBFids_len = fidIndex;
595         fidParm.AFSCBFids_val = fidsp;
596         statParm.AFSBulkStats_len = fidIndex;
597         statParm.AFSBulkStats_val = statsp;
598         cbParm.AFSCBs_len = fidIndex;
599         cbParm.AFSCBs_val = cbsp;
600
601         /* start the timer; callback expirations are relative to this */
602         startTime = osi_Time();
603
604         tcp = afs_Conn(&adp->fid, areqp, SHARED_LOCK);
605         if (tcp) {
606             hostp = tcp->srvr->server;
607             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_BULKSTATUS);
608 #ifdef RX_ENABLE_LOCKS
609             AFS_GUNLOCK();
610 #endif /* RX_ENABLE_LOCKS */
611             code = RXAFS_BulkStatus(tcp->id, &fidParm, &statParm, &cbParm,
612                                     &volSync);
613 #ifdef RX_ENABLE_LOCKS
614             AFS_GLOCK();
615 #endif /* RX_ENABLE_LOCKS */
616             XSTATS_END_TIME;
617         }
618         else code = -1;
619     } while (afs_Analyze(tcp, code, &adp->fid, areqp, 
620                          AFS_STATS_FS_RPCIDX_BULKSTATUS, SHARED_LOCK, (struct cell *)0));
621
622     /* now, if we didnt get the info, bail out. */
623     if (code) goto done;
624
625     /* we need vol flags to create the entries properly */
626     dotdot.Fid.Volume = 0;
627     volp = afs_GetVolume(&adp->fid, areqp, READ_LOCK);
628     if (volp) {
629         volStates = volp->states;
630         if (volp->dotdot.Fid.Volume != 0)
631             dotdot = volp->dotdot;
632     }
633     else volStates = 0;
634
635     /* find the place to merge the info into  We do this by skipping
636      * nskip entries in the LRU queue.  The more we skip, the more
637      * we preserve, since the head of the VLRU queue is the most recently
638      * referenced file.
639      */
640   reskip:
641     nskip = afs_cacheStats / 2;         /* preserved fraction of the cache */
642     ObtainReadLock(&afs_xvcache);
643     if (QEmpty(&VLRU)) {
644       /* actually a serious error, probably should panic. Probably will 
645        * panic soon, oh well. */
646       ReleaseReadLock(&afs_xvcache);
647       afs_warnuser("afs_DoBulkStat: VLRU empty!");
648       goto done;
649     }
650     if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
651        refpanic ("Bulkstat VLRU inconsistent");
652     }
653     for(tq = VLRU.next; tq != &VLRU; tq = QNext(tq)) {
654         if (--nskip <= 0) break;
655         else if (QNext(QPrev(tq)) != tq) {
656            BStvc = QTOV(tq);
657            refpanic ("BulkStat VLRU inconsistent");
658         }
659     }
660     if (tq != &VLRU) lruvcp = QTOV(tq);
661     else lruvcp = QTOV(VLRU.next);
662
663     /* now we have to hold this entry, so that it does not get moved
664      * into the free list while we're running.  It could still get
665      * moved within the lru queue, but hopefully that will be rare; it
666      * doesn't hurt nearly as much.
667      */
668     retry = 0;
669     osi_vnhold(lruvcp, &retry);
670     ReleaseReadLock(&afs_xvcache);           /* could be read lock */
671     if (retry)
672       goto reskip;
673
674     /* otherwise, merge in the info.  We have to be quite careful here,
675      * since we need to ensure that we don't merge old info over newer
676      * stuff in a stat cache entry.  We're very conservative here: we don't
677      * do the merge at all unless we ourselves create the stat cache
678      * entry.  That's pretty safe, and should work pretty well, since we
679      * typically expect to do the stat cache creation ourselves.
680      *
681      * We also have to take into account racing token revocations.
682      */
683     for(i=0; i<fidIndex; i++) {
684         afid.Cell = adp->fid.Cell;
685         afid.Fid.Volume = adp->fid.Fid.Volume;
686         afid.Fid.Vnode = fidsp[i].Vnode;
687         afid.Fid.Unique = fidsp[i].Unique;
688         do {
689            retry = 0;
690            ObtainReadLock(&afs_xvcache);
691            tvcp = afs_FindVCache(&afid, 1, 0, &retry, 0/* !stats&!lru*/);
692            ReleaseReadLock(&afs_xvcache);
693         } while (tvcp && retry);
694
695         /* The entry may no longer exist */
696         if (tvcp == NULL) {
697             continue;
698         }
699
700         /* now we have the entry held, but we need to fill it in */
701         ObtainWriteLock(&tvcp->lock,131);
702
703         /* if CBulkFetching is not set, or if the file size no longer
704          * matches the value we placed there when we set the CBulkFetching
705          * flag, then someone else has done something with this node,
706          * and we may not have the latest status information for this
707          * file.  Leave the entry alone.
708          */
709         if (!(tvcp->states & CBulkFetching) || (tvcp->m.Length != statSeqNo)) {
710             flagIndex++;
711             ReleaseWriteLock(&tvcp->lock);
712             afs_PutVCache(tvcp);
713             continue;
714         }
715
716         /* now copy ".." entry back out of volume structure, if necessary */
717         if (tvcp->mvstat == 2  && (dotdot.Fid.Volume != 0)) {
718             if (!tvcp->mvid)
719                 tvcp->mvid = (struct VenusFid *) osi_AllocSmallSpace(sizeof(struct VenusFid));
720             *tvcp->mvid = dotdot;
721         }
722
723         ObtainWriteLock(&afs_xvcache,132);
724         if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
725            refpanic ("Bulkstat VLRU inconsistent2");
726         }
727         if ((QNext(QPrev(&tvcp->vlruq)) != &tvcp->vlruq) 
728             || (QPrev(QNext(&tvcp->vlruq)) != &tvcp->vlruq))
729            refpanic ("Bulkstat VLRU inconsistent4");
730         if ((QNext(QPrev(&lruvcp->vlruq)) != &lruvcp->vlruq) 
731             || (QPrev(QNext(&lruvcp->vlruq)) != &lruvcp->vlruq)) 
732            refpanic ("Bulkstat VLRU inconsistent5");
733
734         if (tvcp != lruvcp) {  /* if they are == don't move it, don't corrupt vlru */
735            QRemove(&tvcp->vlruq);
736            QAdd(&lruvcp->vlruq, &tvcp->vlruq);
737         }
738
739         if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) {
740            refpanic ("Bulkstat VLRU inconsistent3");
741         }
742         if ((QNext(QPrev(&tvcp->vlruq)) != &tvcp->vlruq) 
743             || (QPrev(QNext(&tvcp->vlruq)) != &tvcp->vlruq))
744            refpanic ("Bulkstat VLRU inconsistent5");
745         if ((QNext(QPrev(&lruvcp->vlruq)) != &lruvcp->vlruq) 
746             || (QPrev(QNext(&lruvcp->vlruq)) != &lruvcp->vlruq))
747            refpanic ("Bulkstat VLRU inconsistent6");
748         ReleaseWriteLock(&afs_xvcache);
749
750         ObtainWriteLock(&afs_xcbhash, 494);
751
752         /* We need to check the flags again. We may have missed
753          * something while we were waiting for a lock.
754          */
755         if (!(tvcp->states & CBulkFetching) || (tvcp->m.Length != statSeqNo)) {
756             flagIndex++;
757             ReleaseWriteLock(&tvcp->lock);
758             ReleaseWriteLock(&afs_xcbhash);
759             afs_PutVCache(tvcp);
760             continue;
761         }
762
763         /* now merge in the resulting status back into the vnode.
764          * We only do this if the entry looks clear.
765          */
766         afs_ProcessFS(tvcp, &statsp[i], areqp);
767 #ifdef AFS_LINUX22_ENV
768         /* overwrite the ops if it's a directory or symlink. */
769         if (vType(tvcp) == VDIR)
770             tvcp->v.v_op = &afs_dir_iops;
771         else if (vType(tvcp) == VLNK)
772             tvcp->v.v_op = &afs_symlink_iops;
773 #endif
774
775         /* do some accounting for bulk stats: mark this entry as
776          * loaded, so we can tell if we use it before it gets
777          * recycled.
778          */
779         tvcp->states |= CBulkStat;
780         tvcp->states &= ~CBulkFetching;
781         flagIndex++;
782         afs_bulkStatsDone++;
783
784         /* merge in vol info */
785         if (volStates & VRO) tvcp->states |= CRO;
786         if (volStates & VBackup) tvcp->states |= CBackup;
787         if (volStates & VForeign) tvcp->states |= CForeign;
788
789         /* merge in the callback info */
790         tvcp->states |= CTruth;
791
792         /* get ptr to the callback we are interested in */
793         tcbp = cbsp + i;
794
795         if (tcbp->ExpirationTime != 0) {
796             tvcp->cbExpires = tcbp->ExpirationTime+startTime;
797             tvcp->callback = hostp;
798             tvcp->states |= CStatd;
799             afs_QueueCallback(tvcp, CBHash(tcbp->ExpirationTime), volp);
800         }
801         else if (tvcp->states & CRO) {
802             /* ordinary callback on a read-only volume -- AFS 3.2 style */
803             tvcp->cbExpires = 3600+startTime;
804             tvcp->callback = hostp;
805             tvcp->states |= CStatd;
806             afs_QueueCallback(tvcp, CBHash(3600), volp);
807         }
808         else {
809             tvcp->callback = 0;
810             tvcp->states &= ~(CStatd|CUnique);  
811             afs_DequeueCallback(tvcp);
812             if ((tvcp->states & CForeign) || (vType(tvcp) == VDIR)) 
813               osi_dnlc_purgedp (tvcp);  /* if it (could be) a directory */
814         }
815         ReleaseWriteLock(&afs_xcbhash);
816
817         ReleaseWriteLock(&tvcp->lock);
818         /* finally, we're done with the entry */
819         afs_PutVCache(tvcp);
820     }   /* for all files we got back */
821
822     /* finally return the pointer into the LRU queue */
823     afs_PutVCache(lruvcp);
824
825   done:
826     /* Be sure to turn off the CBulkFetching flags */
827     for(i=flagIndex; i<fidIndex; i++) {
828         afid.Cell = adp->fid.Cell;
829         afid.Fid.Volume = adp->fid.Fid.Volume;
830         afid.Fid.Vnode = fidsp[i].Vnode;
831         afid.Fid.Unique = fidsp[i].Unique;
832         do {
833            retry = 0;
834            ObtainReadLock(&afs_xvcache);
835            tvcp = afs_FindVCache(&afid, 1, 0, &retry, 0/* !stats&!lru*/);
836            ReleaseReadLock(&afs_xvcache);
837         } while (tvcp && retry);
838         if (tvcp != NULL
839             && (tvcp->states & CBulkFetching)
840             && (tvcp->m.Length == statSeqNo)) {
841           tvcp->states &= ~CBulkFetching;
842         }
843         if (tvcp != NULL) {
844           afs_PutVCache(tvcp);
845         }
846     }
847     if ( volp )
848         afs_PutVolume(volp, READ_LOCK);
849     
850     osi_FreeLargeSpace(statMemp);
851     osi_FreeLargeSpace(cbfMemp);
852 }
853
854 /* was: (AFS_DEC_ENV) || defined(AFS_OSF30_ENV) || defined(AFS_NCR_ENV) */
855 int AFSDOBULK = 1;
856
857 #ifdef  AFS_OSF_ENV
858 afs_lookup(adp, ndp)
859     struct vcache *adp;
860     struct nameidata *ndp; {
861     char aname[MAXNAMLEN+1];    /* XXX */
862     struct vcache **avcp = (struct vcache **)&(ndp->ni_vp);
863     struct ucred *acred = ndp->ni_cred;
864     int wantparent = ndp->ni_nameiop & WANTPARENT;
865     int opflag = ndp->ni_nameiop & OPFLAG;
866 #else   /* AFS_OSF_ENV */
867 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
868 afs_lookup(OSI_VC_ARG(adp), aname, avcp, pnp, flags, rdir, acred)
869     struct pathname *pnp;
870     int flags;
871     struct vnode *rdir;
872 #else
873 #if defined(UKERNEL)
874 afs_lookup(adp, aname, avcp, acred, flags)
875     int flags;
876 #else    
877 afs_lookup(adp, aname, avcp, acred)
878 #endif /* UKERNEL */
879 #endif /* SUN5 || SGI */
880     OSI_VC_DECL(adp);
881     struct vcache **avcp;
882     char *aname;
883     struct AFS_UCRED *acred; {
884 #endif
885     struct vrequest treq;
886     char *tname = (char *)0;
887     register struct vcache *tvc=0;
888     register afs_int32 code;
889     int pass = 0, hit = 0;
890     long dirCookie;
891     extern afs_int32 afs_mariner;                       /*Writing activity to log?*/
892     OSI_VC_CONVERT(adp)
893     afs_hyper_t versionNo;
894     int no_read_access = 0;
895     struct sysname_info sysState;   /* used only for @sys checking */
896
897     AFS_STATCNT(afs_lookup);
898 #ifdef  AFS_OSF_ENV
899     ndp->ni_dvp = (struct vnode *)adp;
900     bcopy(ndp->ni_ptr, aname, ndp->ni_namelen);
901     aname[ndp->ni_namelen] = '\0';
902 #endif  /* AFS_OSF_ENV */
903
904     *avcp = (struct vcache *) 0;   /* Since some callers don't initialize it */
905
906     if (code = afs_InitReq(&treq, acred)) { 
907       goto done;
908     }
909
910     /* come back to here if we encounter a non-existent object in a read-only
911        volume's directory */
912
913   redo:
914     *avcp = (struct vcache *) 0;   /* Since some callers don't initialize it */
915
916     if (!(adp->states & CStatd)) {
917         if (code = afs_VerifyVCache2(adp, &treq))
918           goto done;
919     }
920     else code = 0;
921
922     /* watch for ".." in a volume root */
923     if (adp->mvstat == 2 && aname[0] == '.' && aname[1] == '.' && !aname[2]) {
924         /* looking up ".." in root via special hacks */
925         if (adp->mvid == (struct VenusFid *) 0 || adp->mvid->Fid.Volume == 0) {
926 #ifdef  AFS_OSF_ENV
927             extern struct vcache *afs_globalVp;
928             if (adp == afs_globalVp) {
929                 struct vnode *rvp = (struct vnode *)adp;
930 /*
931                 ndp->ni_vp = rvp->v_vfsp->vfs_vnodecovered;
932                 ndp->ni_dvp = ndp->ni_vp;
933                 VN_HOLD(*avcp);
934 */
935                 code = ENODEV;
936                 goto done;
937             }
938 #endif
939             code = ENODEV;
940             goto done;
941         }
942         /* otherwise we have the fid here, so we use it */
943         tvc = afs_GetVCache(adp->mvid, &treq, (afs_int32 *)0,
944                             (struct vcache*)0, 0);
945         afs_Trace3(afs_iclSetp, CM_TRACE_GETVCDOTDOT,
946                    ICL_TYPE_FID, adp->mvid, ICL_TYPE_POINTER, tvc, 
947                    ICL_TYPE_INT32,  code);
948         *avcp = tvc;
949         code = (tvc ? 0 : ENOENT);
950         hit = 1;
951         if (tvc && !tvc->vrefCount) {
952             osi_Panic("TT1");
953         }
954         if (code) {
955             /*printf("LOOKUP GETVCDOTDOT -> %d\n", code);*/
956         }
957         goto done;
958     }
959
960     /* now check the access */
961     if (treq.uid != adp->last_looker) {  
962        if (!afs_AccessOK(adp, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS)) {
963          *avcp = (struct vcache *)0;
964          code = EACCES;
965          goto done;
966        }
967        else adp->last_looker = treq.uid;
968     } 
969
970     /* Check for read access as well.  We need read access in order to
971        stat files, but not to stat subdirectories. */
972     if (!afs_AccessOK(adp, PRSFS_READ, &treq, CHECK_MODE_BITS))
973         no_read_access = 1;
974
975     /* special case lookup of ".".  Can we check for it sooner in this code,
976      * for instance, way up before "redo:" ??
977      * I'm not fiddling with the LRUQ here, either, perhaps I should, or else 
978      * invent a lightweight version of GetVCache.
979      */
980     if (aname[0] == '.' && !aname[1]) { /* special case */
981         ObtainReadLock(&afs_xvcache);   
982         osi_vnhold(adp, 0);
983         ReleaseReadLock(&afs_xvcache);  
984       code = 0;
985       *avcp = tvc = adp;
986       hit = 1;
987         if (adp && !adp->vrefCount) {
988             osi_Panic("TT2");
989         }
990       goto done;
991     }
992
993     Check_AtSys(adp, aname, &sysState, &treq);
994     tname = sysState.name;
995
996     /* 1st Check_AtSys and lookup by tname is required here, for now,
997        because the dnlc is *not* told to remove entries for the parent
998        dir of file/dir op that afs_LocalHero likes, but dnlc is informed
999        if the cached entry for the parent dir is invalidated for a
1000        non-local change.
1001        Otherwise, we'd be able to do a dnlc lookup on an entry ending
1002        w/@sys and know the dnlc was consistent with reality. */
1003     tvc = osi_dnlc_lookup (adp, tname, WRITE_LOCK);
1004     *avcp = tvc;  /* maybe wasn't initialized, but it is now */
1005     if (tvc) {
1006         if (no_read_access && vType(tvc) != VDIR) {
1007             /* need read access on dir to stat non-directory */
1008             afs_PutVCache(tvc, WRITE_LOCK);
1009             *avcp = (struct vcache *)0;
1010             code = EACCES;
1011             goto done;
1012         }
1013 #ifdef AFS_LINUX22_ENV
1014         if (tvc->mvstat == 2) { /* we don't trust the dnlc for root vcaches */
1015             AFS_RELE(tvc);
1016             *avcp = 0;
1017         }
1018         else {  
1019             code = 0;
1020             hit = 1;
1021             goto done;
1022         }
1023 #else /* non - LINUX */
1024         code = 0;
1025         hit = 1;
1026         goto done;
1027 #endif /* linux22 */
1028     }
1029
1030     {
1031     register struct dcache *tdc;
1032     afs_int32 dirOffset, dirLen;
1033     ino_t theDir;
1034     struct VenusFid tfid;
1035
1036     /* now we have to lookup the next fid */
1037     tdc = afs_GetDCache(adp, 0, &treq, &dirOffset, &dirLen, 1);
1038     if (!tdc) {
1039       *avcp = (struct vcache *)0;  /* redundant, but harmless */
1040       code = EIO;
1041       goto done;
1042     }
1043
1044     /* now we will just call dir package with appropriate inode.
1045       Dirs are always fetched in their entirety for now */
1046     ObtainReadLock(&adp->lock);
1047
1048     /*
1049      * Make sure that the data in the cache is current. There are two
1050      * cases we need to worry about:
1051      * 1. The cache data is being fetched by another process.
1052      * 2. The cache data is no longer valid
1053      */
1054     while ((adp->states & CStatd)
1055            && (tdc->flags & DFFetching)
1056            && hsame(adp->m.DataVersion, tdc->f.versionNo)) {
1057         tdc->flags |= DFWaiting;
1058         ReleaseReadLock(&adp->lock);
1059         afs_osi_Sleep(&tdc->validPos);
1060         ObtainReadLock(&adp->lock);
1061     }
1062     if (!(adp->states & CStatd)
1063         || !hsame(adp->m.DataVersion, tdc->f.versionNo)) {
1064         ReleaseReadLock(&adp->lock);
1065         afs_PutDCache(tdc);
1066         goto redo;
1067     }
1068
1069     /* Save the version number for when we call osi_dnlc_enter */
1070     hset(versionNo, tdc->f.versionNo);
1071
1072     /*
1073      * check for, and handle "@sys" if it's there.  We should be able
1074      * to avoid the alloc and the strcpy with a little work, but it's
1075      * not pressing.  If there aren't any remote users (ie, via the 
1076      * NFS translator), we have a slightly easier job.
1077      * the faster way to do this is to check for *aname == '@' and if 
1078      * it's there, check for @sys, otherwise, assume there's no @sys 
1079      * then, if the lookup fails, check for .*@sys...
1080      */
1081     /* above now implemented by Check_AtSys and Next_AtSys */
1082
1083     /* lookup the name in the appropriate dir, and return a cache entry
1084        on the resulting fid */
1085     theDir = tdc->f.inode;
1086     code = afs_dir_LookupOffset(&theDir, sysState.name, &tfid.Fid, &dirCookie);
1087
1088     /* If the first lookup doesn't succeed, maybe it's got @sys in the name */
1089     while (code == ENOENT && Next_AtSys(adp, &treq, &sysState)) {
1090       code = afs_dir_LookupOffset(&theDir, sysState.name, &tfid.Fid, &dirCookie);
1091     }
1092     tname = sysState.name;
1093
1094     ReleaseReadLock(&adp->lock);
1095     afs_PutDCache(tdc);
1096
1097     /* new fid has same cell and volume */
1098     tfid.Cell = adp->fid.Cell;
1099     tfid.Fid.Volume = adp->fid.Fid.Volume;
1100     afs_Trace4(afs_iclSetp, CM_TRACE_LOOKUP, ICL_TYPE_POINTER, adp, 
1101                ICL_TYPE_STRING, tname,
1102                ICL_TYPE_FID, &tfid, ICL_TYPE_INT32, code);
1103
1104     if (code) {
1105         if (code != ENOENT) {
1106             printf("LOOKUP dirLookupOff -> %d\n", code);
1107         }
1108         goto done;
1109     }  
1110
1111     /* prefetch some entries, if the dir is currently open.  The variable
1112      * dirCookie tells us where to start prefetching from.
1113      */
1114     if (AFSDOBULK && adp->opens > 0 && !(adp->states & CForeign)) {
1115         afs_int32 retry;
1116         /* if the entry is not in the cache, or is in the cache,
1117          * but hasn't been statd, then do a bulk stat operation.
1118          */
1119         do {
1120            retry = 0;
1121            ObtainReadLock(&afs_xvcache);        
1122            tvc = afs_FindVCache(&tfid, 1, 0, &retry, 0/* !stats,!lru */);
1123            ReleaseReadLock(&afs_xvcache);       
1124         } while (tvc && retry);
1125
1126         if (!tvc || !(tvc->states & CStatd)) {
1127             afs_DoBulkStat(adp, dirCookie, &treq);
1128         }
1129
1130         /* if the vcache isn't usable, release it */
1131         if (tvc && !(tvc->states & CStatd)) {
1132             afs_PutVCache(tvc);
1133             tvc = (struct vcache *) 0;
1134         }
1135     }
1136     else tvc = (struct vcache *) 0;
1137     
1138     /* now get the status info, if we don't already have it */
1139     /* This is kind of weird, but we might wind up accidentally calling
1140      * RXAFS_Lookup because we happened upon a file which legitimately
1141      * has a 0 uniquifier. That is the result of allowing unique to wrap
1142      * to 0. This was fixed in AFS 3.4. For CForeigh, Unique == 0 means that
1143      * the file has not yet been looked up.
1144      */
1145     if (!tvc) {
1146        afs_int32 cached = 0;
1147        if (!tfid.Fid.Unique && (adp->states & CForeign)) {
1148             tvc = afs_LookupVCache(&tfid, &treq, &cached, WRITE_LOCK, 
1149                                    adp, tname);
1150        } 
1151        if (!tvc) {  /* lookup failed or wasn't called */
1152             tvc = afs_GetVCache(&tfid, &treq, &cached, (struct vcache*)0,
1153                                 WRITE_LOCK);
1154        }
1155     } /* if !tvc */
1156     } /* sub-block just to reduce stack usage */
1157
1158     if (tvc) {
1159        if (adp->states & CForeign)
1160            tvc->states |= CForeign;
1161         tvc->parentVnode = adp->fid.Fid.Vnode;
1162         tvc->parentUnique = adp->fid.Fid.Unique;
1163         tvc->states &= ~CBulkStat;
1164
1165 #if defined(UKERNEL) && defined(AFS_WEB_ENHANCEMENTS)
1166         if (!(flags & AFS_LOOKUP_NOEVAL))
1167           /* don't eval mount points */
1168 #endif /* UKERNEL && AFS_WEB_ENHANCEMENTS */
1169         if (tvc->mvstat == 1) {
1170           /* a mt point, possibly unevaluated */
1171           struct volume *tvolp;
1172
1173             ObtainWriteLock(&tvc->lock,133);
1174             code = EvalMountPoint(tvc, adp, &tvolp, &treq);
1175             ReleaseWriteLock(&tvc->lock);
1176
1177             if (code) {
1178                 if (tvolp) afs_PutVolume(tvolp, WRITE_LOCK);
1179                 goto done;
1180             }
1181
1182             /* next, we want to continue using the target of the mt point */
1183             if (tvc->mvid && (tvc->states & CMValid)) {
1184               struct vcache *uvc;
1185                 /* now lookup target, to set .. pointer */
1186                 afs_Trace2(afs_iclSetp, CM_TRACE_LOOKUP1,
1187                            ICL_TYPE_POINTER, tvc, ICL_TYPE_FID, &tvc->fid);
1188                 uvc = tvc;      /* remember for later */
1189
1190                 if (tvolp && (tvolp->states & VForeign)) {
1191                     /* XXXX tvolp has ref cnt on but not locked! XXX */
1192                     tvc = afs_GetRootVCache(tvc->mvid, &treq, (afs_int32 *)0, tvolp, WRITE_LOCK);
1193                 } else {
1194                     tvc = afs_GetVCache(tvc->mvid, &treq, (afs_int32 *)0,
1195                                         (struct vcache*)0, WRITE_LOCK);
1196                 }
1197                 afs_PutVCache(uvc, WRITE_LOCK); /* we're done with it */
1198
1199                 if (!tvc) {
1200                     code = ENOENT;
1201                     if (tvolp) {
1202                         afs_PutVolume(tvolp, WRITE_LOCK);
1203                     }
1204                     goto done;
1205                 }
1206
1207                 /* now, if we came via a new mt pt (say because of a new
1208                  * release of a R/O volume), we must reevaluate the ..
1209                  * ptr to point back to the appropriate place */
1210                 if (tvolp) {
1211                     ObtainWriteLock(&tvc->lock,134);
1212                     if (tvc->mvid == (struct VenusFid *) 0) {
1213                         tvc->mvid = (struct VenusFid *) osi_AllocSmallSpace(sizeof(struct VenusFid));
1214                     }
1215                     /* setup backpointer */
1216                     *tvc->mvid = tvolp->dotdot;
1217                     ReleaseWriteLock(&tvc->lock);
1218                     afs_PutVolume(tvolp, WRITE_LOCK);
1219                 }
1220             }
1221             else {
1222                 afs_PutVCache(tvc, WRITE_LOCK);
1223                 code = ENOENT;
1224                 if (tvolp) afs_PutVolume(tvolp, WRITE_LOCK);
1225                 goto done;
1226             }
1227         }
1228         *avcp = tvc;
1229         if (tvc && !tvc->vrefCount) {
1230             osi_Panic("TT3");
1231         }
1232         code = 0;
1233     }
1234     else {
1235         /* if we get here, we found something in a directory that couldn't
1236            be located (a Multics "connection failure").  If the volume is
1237            read-only, we try flushing this entry from the cache and trying
1238            again. */
1239         if (pass == 0) {
1240             struct volume *tv;
1241             tv = afs_GetVolume(&adp->fid, &treq, READ_LOCK);
1242             if (tv) {
1243                 if (tv->states & VRO) {
1244                     pass = 1;                   /* try this *once* */
1245                     ObtainWriteLock(&afs_xcbhash, 495);
1246                     afs_DequeueCallback(adp);
1247                     /* re-stat to get later version */
1248                     adp->states &= ~CStatd;
1249                     ReleaseWriteLock(&afs_xcbhash);
1250                     osi_dnlc_purgedp(adp);
1251                     afs_PutVolume(tv, READ_LOCK);
1252                     goto redo;
1253                 }
1254                 afs_PutVolume(tv, READ_LOCK);
1255             }
1256         }
1257         code = ENOENT;
1258     }
1259
1260 done:
1261     /* put the network buffer back, if need be */
1262     if (tname != aname && tname) osi_FreeLargeSpace(tname);
1263     if (code == 0) {
1264 #ifdef  AFS_OSF_ENV
1265         /* Handle RENAME; only need to check rename "."  */
1266         if (opflag == RENAME && wantparent && *ndp->ni_next == 0) {
1267             if (!FidCmp(&(tvc->fid), &(adp->fid))) { 
1268                 afs_PutVCache(*avcp, WRITE_LOCK);
1269                 *avcp = NULL;
1270                 return afs_CheckCode(EISDIR, &treq, 18);
1271             }
1272         }
1273 #endif  /* AFS_OSF_ENV */
1274
1275         if (afs_mariner)
1276           afs_AddMarinerName(aname, tvc); 
1277
1278 #if defined(UKERNEL) && defined(AFS_WEB_ENHANCEMENTS)
1279         if (!(flags & AFS_LOOKUP_NOEVAL))
1280         /* Here we don't enter the name into the DNLC because we want the
1281         evaluated mount dir to be there (the vcache for the mounted volume)
1282         rather than the vc of the mount point itself.  we can still find the
1283         mount point's vc in the vcache by its fid. */
1284 #endif /* UKERNEL && AFS_WEB_ENHANCEMENTS */
1285         if (!hit) {
1286           osi_dnlc_enter (adp, aname, tvc, &versionNo);
1287         }
1288         else {
1289 #ifdef AFS_LINUX20_ENV
1290             /* So Linux inode cache is up to date. */
1291             code = afs_VerifyVCache(tvc, &treq);
1292 #else
1293             return 0;  /* can't have been any errors if hit and !code */
1294 #endif
1295         }
1296     }
1297     code = afs_CheckCode(code, &treq, 19);
1298     if (code) {
1299        /* If there is an error, make sure *avcp is null.
1300         * Alphas panic otherwise - defect 10719.
1301         */
1302        *avcp = (struct vcache *)0;
1303     }
1304
1305     return code;
1306 }