libafs: put volume disk cache i/o in afs_UFSGetVolSlot
[openafs.git] / src / afs / afs_volume.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_vtoi (local)
13  * afs_UFSGetVolSlot
14  * afs_MemGetVolSlot
15  * afs_CheckVolumeNames
16  * afs_FindVolume
17  */
18 #include <afsconfig.h>
19 #include "afs/param.h"
20
21
22 #include "afs/stds.h"
23 #include "afs/sysincludes.h"    /* Standard vendor system headers */
24
25 #if !defined(UKERNEL)
26 #if !defined(AFS_LINUX20_ENV)
27 #include <net/if.h>
28 #endif
29 #include <netinet/in.h>
30
31 #ifdef AFS_SGI62_ENV
32 #include "h/hashing.h"
33 #endif
34 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
35 #include <netinet/in_var.h>
36 #endif /* ! AFS_HPUX110_ENV */
37 #endif /* !defined(UKERNEL) */
38
39 #include "afsincludes.h"        /* Afs-based standard headers */
40 #include "afs/afs_stats.h"      /* afs statistics */
41 #include "afs/afs_dynroot.h"
42
43 #if     defined(AFS_SUN5_ENV)
44 #include <inet/led.h>
45 #include <inet/common.h>
46 #include <netinet/ip6.h>
47 #include <inet/ip.h>
48 #endif
49
50 /* In case we don't have the vl error table yet. */
51 #ifndef ERROR_TABLE_BASE_VL
52 #define ERROR_TABLE_BASE_VL     (363520L)
53 #define VL_NOENT                (363524L)
54 #endif /* vlserver error base define */
55
56 /* Exported variables */
57 afs_dcache_id_t volumeInode;    /* Inode for VolumeItems file */
58 afs_rwlock_t afs_xvolume;       /** allocation lock for volumes */
59 struct volume *afs_freeVolList;
60 struct volume *afs_volumes[NVOLS];
61 afs_int32 afs_volCounter = 1;   /** for allocating volume indices */
62 afs_int32 fvTable[NFENTRIES];
63
64 /* Forward declarations */
65 static struct volume *afs_NewVolumeByName(char *aname, afs_int32 acell,
66                                           int agood, struct vrequest *areq,
67                                           afs_int32 locktype);
68 static struct volume *afs_NewDynrootVolume(struct VenusFid *fid);
69 static int inVolList(struct VenusFid *fid, afs_int32 nvols, afs_int32 * vID,
70                      afs_int32 * cID);
71
72
73
74 /**
75  * Convert a volume name to a number;
76  * @param aname Volume name.
77  * @return return 0 if can't parse as a number.
78  */
79 static int
80 afs_vtoi(char *aname)
81 {
82     afs_int32 temp;
83     int tc;
84     temp = 0;
85     AFS_STATCNT(afs_vtoi);
86     while ((tc = *aname++)) {
87         if (tc > '9' || tc < '0')
88             return 0;           /* invalid name */
89         temp *= 10;
90         temp += tc - '0';
91     }
92     return temp;
93
94 }                               /*afs_vtoi */
95
96
97 /**
98  * All of the vol cache routines must be called with the afs_xvolume
99  * lock held in exclusive mode, since they use static variables.
100  * In addition, we don't want two people adding the same volume
101  * at the same time.
102  */
103
104 static struct fvolume staticFVolume;
105 afs_int32 afs_FVIndex = -1;
106
107 /*!
108  * Initialize a newly gotten volume slot.
109  *
110  * \param tv volume slot to be initialized
111  * \param tf volume item data; null if none
112  * \param volid volume id for this volume slot
113  * \param cell cell for this volume slot
114  * \return none
115  */
116 static void
117 afs_InitVolSlot(struct volume *tv, struct fvolume *tf, afs_int32 volid,
118                 struct cell *tcell)
119 {
120     AFS_STATCNT(afs_InitVolSlot);
121     memset(tv, 0, sizeof(struct volume));
122     tv->cell = tcell->cellNum;
123     AFS_RWLOCK_INIT(&tv->lock, "volume lock");
124     tv->volume = volid;
125     if (tf) {
126         tv->vtix = afs_FVIndex;
127         tv->mtpoint = tf->mtpoint;
128         tv->dotdot = tf->dotdot;
129         tv->rootVnode = tf->rootVnode;
130         tv->rootUnique = tf->rootUnique;
131     } else {
132         tv->vtix = -1;
133         tv->rootVnode = tv->rootUnique = 0;
134         afs_GetDynrootMountFid(&tv->dotdot);
135         afs_GetDynrootMountFid(&tv->mtpoint);
136         tv->mtpoint.Fid.Vnode =
137             VNUM_FROM_TYPEID(VN_TYPE_MOUNT, tcell->cellIndex << 2);
138         tv->mtpoint.Fid.Unique = volid;
139     }
140 }
141
142 /**
143  * UFS specific version of afs_GetVolSlot
144  * @return
145  */
146 struct volume *
147 afs_UFSGetVolSlot(afs_int32 volid, struct cell *tcell)
148 {
149     struct volume *tv = NULL, **lv;
150     struct osi_file *tfile;
151     afs_int32 i = -1, code;
152     afs_int32 bestTime;
153     struct volume *bestVp, *oldLp = NULL, **bestLp = NULL;
154     char *oldname = NULL;
155     afs_int32 oldvtix = -2; /* Initialize to a value that doesn't occur */
156     struct fvolume *tf = NULL;
157     int j = 0;
158
159     AFS_STATCNT(afs_UFSGetVolSlot);
160     if (!afs_freeVolList) {
161         /* get free slot */
162         bestTime = 0x7fffffff;
163         bestVp = 0;
164         bestLp = 0;
165         for (i = 0; i < NVOLS; i++) {
166             lv = &afs_volumes[i];
167             for (tv = *lv; tv; lv = &tv->next, tv = *lv) {
168                 if (tv->refCount == 0) {        /* is this one available? */
169                     if (tv->accessTime < bestTime) {    /* best one available? */
170                         bestTime = tv->accessTime;
171                         bestLp = lv;
172                         bestVp = tv;
173                     }
174                 }
175             }
176         }
177         if (!bestVp) {
178             afs_warn("afs_UFSGetVolSlot: no vol slots available\n");
179             goto error;
180         }
181         tv = bestVp;
182
183         oldLp = *bestLp;
184         *bestLp = tv->next;
185
186         oldname = tv->name;
187         tv->name = NULL;
188
189         oldvtix = tv->vtix;
190         /* now write out volume structure to file */
191         if (tv->vtix < 0) {
192             tv->vtix = afs_volCounter++;
193             /* now put on hash chain */
194             i = FVHash(tv->cell, tv->volume);
195             staticFVolume.next = fvTable[i];
196             fvTable[i] = tv->vtix;
197         } else {
198             /*
199              * Haul the guy in from disk so we don't overwrite hash table
200              * next chain
201              */
202             if (afs_FVIndex != tv->vtix) {
203                 tfile = osi_UFSOpen(&volumeInode);
204                 code =
205                     afs_osi_Read(tfile, sizeof(struct fvolume) * tv->vtix,
206                                  &staticFVolume, sizeof(struct fvolume));
207                 osi_UFSClose(tfile);
208                 if (code != sizeof(struct fvolume)) {
209                     afs_warn("afs_UFSGetVolSlot: error %d reading volumeinfo\n",
210                              (int)code);
211                     goto error;
212                 }
213                 afs_FVIndex = tv->vtix;
214             }
215         }
216         afs_FVIndex = tv->vtix;
217         staticFVolume.volume = tv->volume;
218         staticFVolume.cell = tv->cell;
219         staticFVolume.mtpoint = tv->mtpoint;
220         staticFVolume.dotdot = tv->dotdot;
221         staticFVolume.rootVnode = tv->rootVnode;
222         staticFVolume.rootUnique = tv->rootUnique;
223         tfile = osi_UFSOpen(&volumeInode);
224         code =
225             afs_osi_Write(tfile, sizeof(struct fvolume) * afs_FVIndex,
226                           &staticFVolume, sizeof(struct fvolume));
227         osi_UFSClose(tfile);
228         if (code != sizeof(struct fvolume)) {
229             afs_warn("afs_UFSGetVolSlot: error %d writing volumeinfo\n",
230                      (int)code);
231             goto error;
232         }
233         if (oldname) {
234             afs_osi_Free(oldname, strlen(oldname) + 1);
235             oldname = NULL;
236         }
237     } else {
238         tv = afs_freeVolList;
239         afs_freeVolList = tv->next;
240     }
241
242     /* read volume item data from disk for the gotten slot */
243     for (j = fvTable[FVHash(tcell->cellNum, volid)]; j != 0; j = tf->next) {
244         if (afs_FVIndex != j) {
245             tfile = osi_UFSOpen(&volumeInode);
246             code =
247                 afs_osi_Read(tfile, sizeof(struct fvolume) * j,
248                              &staticFVolume, sizeof(struct fvolume));
249             osi_UFSClose(tfile);
250             if (code != sizeof(struct fvolume)) {
251                 afs_warn("afs_SetupVolume: error %d reading volumeinfo\n",
252                          (int)code);
253                 /* put tv back on the free list; the data in it is not valid */
254                 tv->next = afs_freeVolList;
255                 afs_freeVolList = tv;
256                 /* staticFVolume contents are not valid */
257                 afs_FVIndex = -1;
258                 return NULL;
259             }
260             afs_FVIndex = j;
261         }
262         if (j != 0) {           /* volume items record 0 is not used */
263             tf = &staticFVolume;
264             if (tf->cell == tcell->cellNum && tf->volume == volid) {
265                 break;
266             }
267         }
268     }
269
270     afs_InitVolSlot(tv, tf, volid, tcell);
271     return tv;
272
273  error:
274     if (tv) {
275         if (oldvtix == -2) {
276             afs_warn("afs_UFSGetVolSlot: oldvtix is uninitialized\n");
277             return NULL;
278         }
279         if (oldname) {
280             tv->name = oldname;
281             oldname = NULL;
282         }
283         if (oldvtix < 0) {
284             afs_volCounter--;
285             fvTable[i] = staticFVolume.next;
286         }
287         if (bestLp) {
288             *bestLp = oldLp;
289         }
290         tv->vtix = oldvtix;
291         /* we messed with staticFVolume, so make sure someone else
292          * doesn't think it's fine to use */
293         afs_FVIndex = -1;
294     }
295     return NULL;
296 }                               /*afs_UFSGetVolSlot */
297
298
299 /**
300  *   Get an available volume list slot. If the list does not exist,
301  * create one containing a single element.
302  * @return
303  */
304 struct volume *
305 afs_MemGetVolSlot(afs_int32 volid, struct cell *tcell)
306 {
307     struct volume *tv;
308
309     AFS_STATCNT(afs_MemGetVolSlot);
310     if (!afs_freeVolList) {
311         struct volume *newVp;
312
313         newVp = afs_osi_Alloc(sizeof(struct volume));
314         osi_Assert(newVp != NULL);
315
316         newVp->next = NULL;
317         afs_freeVolList = newVp;
318     }
319     tv = afs_freeVolList;
320     afs_freeVolList = tv->next;
321
322     afs_InitVolSlot(tv, NULL, volid, tcell);
323     return tv;
324
325 }                               /*afs_MemGetVolSlot */
326
327 /*!
328  * Reset volume information for all volume structs that
329  * point to a speicific server, skipping a given volume if provided.
330  *
331  * @param[in] srvp
332  *      The server to reset volume info about
333  * @param[in] tv
334  *      The volume to skip resetting info about
335  */
336 void
337 afs_ResetVolumes(struct server *srvp, struct volume *tv)
338 {
339     int j, k;
340     struct volume *vp;
341
342     /* Find any volumes residing on this server and flush their state */
343     for (j = 0; j < NVOLS; j++) {
344         for (vp = afs_volumes[j]; vp; vp = vp->next) {
345             for (k = 0; k < AFS_MAXHOSTS; k++) {
346                 if (!srvp || (vp->serverHost[k] == srvp)) {
347                     if (tv && tv != vp) {
348                         vp->serverHost[k] = 0;
349                         afs_ResetVolumeInfo(vp);
350                     }
351                     break;
352                 }
353             }
354         }
355     }
356 }
357
358 /**
359  *   Reset volume name to volume id mapping cache.
360  * @param flags
361  */
362 void
363 afs_CheckVolumeNames(int flags)
364 {
365     afs_int32 i, j;
366     struct volume *tv;
367     unsigned int now;
368     struct vcache *tvc;
369     afs_int32 *volumeID, *cellID, vsize, nvols;
370 #ifdef AFS_DARWIN80_ENV
371     vnode_t tvp;
372 #endif
373     AFS_STATCNT(afs_CheckVolumeNames);
374
375     nvols = 0;
376     volumeID = cellID = NULL;
377     vsize = 0;
378     ObtainReadLock(&afs_xvolume);
379     if (flags & AFS_VOLCHECK_EXPIRED) {
380         /*
381          * allocate space to hold the volumeIDs and cellIDs, only if
382          * we will be invalidating the mountpoints later on
383          */
384         for (i = 0; i < NVOLS; i++)
385             for (tv = afs_volumes[i]; tv; tv = tv->next)
386                 ++vsize;
387
388         volumeID = afs_osi_Alloc(2 * vsize * sizeof(*volumeID));
389         cellID = (volumeID) ? volumeID + vsize : 0;
390     }
391
392     now = osi_Time();
393     for (i = 0; i < NVOLS; i++) {
394         for (tv = afs_volumes[i]; tv; tv = tv->next) {
395             if (flags & AFS_VOLCHECK_EXPIRED) {
396                 if (((tv->expireTime < (now + 10)) && (tv->states & VRO))
397                     || (flags & AFS_VOLCHECK_FORCE)) {
398                     afs_ResetVolumeInfo(tv);    /* also resets status */
399                     if (volumeID) {
400                         volumeID[nvols] = tv->volume;
401                         cellID[nvols] = tv->cell;
402                     }
403                     ++nvols;
404                     continue;
405                 }
406             }
407             /* ??? */
408             if (flags & (AFS_VOLCHECK_BUSY | AFS_VOLCHECK_FORCE)) {
409                 for (j = 0; j < AFS_MAXHOSTS; j++)
410                     tv->status[j] = not_busy;
411             }
412
413         }
414     }
415     ReleaseReadLock(&afs_xvolume);
416
417
418     /* next ensure all mt points are re-evaluated */
419     if (nvols || (flags & (AFS_VOLCHECK_FORCE | AFS_VOLCHECK_MTPTS))) {
420 loop:
421         ObtainReadLock(&afs_xvcache);
422         for (i = 0; i < VCSIZE; i++) {
423             for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
424
425                 /* if the volume of "mvid" of the vcache entry is among the
426                  * ones we found earlier, then we re-evaluate it.  Also, if the
427                  * force bit is set or we explicitly asked to reevaluate the
428                  * mt-pts, we clean the cmvalid bit */
429
430                 if ((flags & (AFS_VOLCHECK_FORCE | AFS_VOLCHECK_MTPTS))
431                     || (tvc->mvid
432                         && inVolList(tvc->mvid, nvols, volumeID, cellID)))
433                     tvc->f.states &= ~CMValid;
434
435                 /* If the volume that this file belongs to was reset earlier,
436                  * then we should remove its callback.
437                  * Again, if forced, always do it.
438                  */
439                 if ((tvc->f.states & CRO)
440                     && (inVolList(&tvc->f.fid, nvols, volumeID, cellID)
441                         || (flags & AFS_VOLCHECK_FORCE))) {
442
443                     if (tvc->f.states & CVInit) {
444                         ReleaseReadLock(&afs_xvcache);
445                         afs_osi_Sleep(&tvc->f.states);
446                         goto loop;
447                     }
448 #ifdef AFS_DARWIN80_ENV
449                     if (tvc->f.states & CDeadVnode) {
450                         ReleaseReadLock(&afs_xvcache);
451                         afs_osi_Sleep(&tvc->f.states);
452                         goto loop;
453                     }
454                     tvp = AFSTOV(tvc);
455                     if (vnode_get(tvp))
456                         continue;
457                     if (vnode_ref(tvp)) {
458                         AFS_GUNLOCK();
459                         /* AFSTOV(tvc) may be NULL */
460                         vnode_put(tvp);
461                         AFS_GLOCK();
462                         continue;
463                     }
464 #else
465                     AFS_FAST_HOLD(tvc);
466 #endif
467                     ReleaseReadLock(&afs_xvcache);
468
469                     ObtainWriteLock(&afs_xcbhash, 485);
470                     /* LOCKXXX: We aren't holding tvc write lock? */
471                     afs_DequeueCallback(tvc);
472                     tvc->f.states &= ~CStatd;
473                     ReleaseWriteLock(&afs_xcbhash);
474                     if (tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR))
475                         osi_dnlc_purgedp(tvc);
476
477 #ifdef AFS_DARWIN80_ENV
478                     vnode_put(AFSTOV(tvc));
479                     /* our tvc ptr is still good until now */
480                     AFS_FAST_RELE(tvc);
481                     ObtainReadLock(&afs_xvcache);
482 #else
483                     ObtainReadLock(&afs_xvcache);
484
485                     /* our tvc ptr is still good until now */
486                     AFS_FAST_RELE(tvc);
487 #endif
488                 }
489             }
490         }
491         osi_dnlc_purge();       /* definitely overkill, but it's safer this way. */
492         ReleaseReadLock(&afs_xvcache);
493     }
494
495     if (volumeID)
496         afs_osi_Free(volumeID, 2 * vsize * sizeof(*volumeID));
497
498 }                               /*afs_CheckVolumeNames */
499
500
501 /**
502  * Check if volume is in the specified list.
503  * @param fid File FID.
504  * @param nvols Nomber of volumes???
505  * @param vID Array of volume IDs.
506  * @param cID Array of cache IDs.
507  * @return 1 - true, 0 - false.
508  */
509 static int
510 inVolList(struct VenusFid *fid, afs_int32 nvols, afs_int32 * vID,
511           afs_int32 * cID)
512 {
513     afs_int32 i;
514
515     /* if no arrays present, be conservative and return true */
516     if (nvols && (!vID || !cID))
517         return 1;
518
519     for (i = 0; i < nvols; ++i) {
520         if (fid->Fid.Volume == vID[i] && fid->Cell == cID[i])
521             return 1;
522     }
523     return 0;
524 }
525
526
527 /* afs_PutVolume is now a macro in afs.h */
528
529
530 /**
531  *    Return volume struct if we have it cached and it's up-to-date.
532  *  Environment: Must be called with afs_xvolume unlocked.
533  *  @param afid Volume FID.
534  *  @param locktype
535  *  @return Volume or NULL if no result.
536  */
537 struct volume *
538 afs_FindVolume(struct VenusFid *afid, afs_int32 locktype)
539 {
540     struct volume *tv;
541     afs_int32 i;
542
543     if (afid == NULL)
544         return NULL;
545
546     i = VHash(afid->Fid.Volume);
547     ObtainWriteLock(&afs_xvolume, 106);
548     for (tv = afs_volumes[i]; tv; tv = tv->next) {
549         if (tv->volume == afid->Fid.Volume && tv->cell == afid->Cell
550             && (tv->states & VRecheck) == 0) {
551             tv->refCount++;
552             break;
553         }
554     }
555     ReleaseWriteLock(&afs_xvolume);
556     return tv;                  /* NULL if we didn't find it */
557 }                               /*afs_FindVolume */
558
559
560
561 /**
562  *   Note that areq may be null, in which case we don't bother to set any
563  * request status information.
564  * @param afid Volume FID.
565  * @param areq Request type.
566  * @param locktype Lock to be used.
567  * @return Volume or NULL if no result.
568  */
569 struct volume *
570 afs_GetVolume(struct VenusFid *afid, struct vrequest *areq,
571               afs_int32 locktype)
572 {
573     struct volume *tv;
574     char *bp, tbuf[CVBS];
575     AFS_STATCNT(afs_GetVolume);
576
577     tv = afs_FindVolume(afid, locktype);
578     if (!tv) {
579         /* Do a dynroot check and add dynroot volume if found. */
580         if (afs_IsDynrootAnyFid(afid)) {
581             tv = afs_NewDynrootVolume(afid);
582         } else {
583             bp = afs_cv2string(&tbuf[CVBS], afid->Fid.Volume);
584             tv = afs_NewVolumeByName(bp, afid->Cell, 0, areq, locktype);
585         }
586     }
587     return tv;
588 }                               /*afs_GetVolume */
589
590
591
592 /**
593  *
594  * @param volid Volume ID. If it's 0, get it from the name.
595  * @param aname Volume name.
596  * @param ve Volume entry.
597  * @param tcell The cell containing this volume.
598  * @param agood
599  * @param type Type of volume.
600  * @param areq Request.
601  * @return Volume or NULL if failure.
602  */
603 static struct volume *
604 afs_SetupVolume(afs_int32 volid, char *aname, void *ve, struct cell *tcell,
605                 afs_int32 agood, afs_int32 type, struct vrequest *areq)
606 {
607     struct volume *tv;
608     struct vldbentry *ove = (struct vldbentry *)ve;
609     struct nvldbentry *nve = (struct nvldbentry *)ve;
610     struct uvldbentry *uve = (struct uvldbentry *)ve;
611
612     int whichType;              /* which type of volume to look for */
613     int i;
614
615     if (!volid) {
616         int len;
617         /* special hint from file server to use vlserver */
618         len = strlen(aname);
619         if (len >= 8 && strcmp(aname + len - 7, ".backup") == 0)
620             whichType = BACKVOL;
621         else if (len >= 10 && strcmp(aname + len - 9, ".readonly") == 0)
622             whichType = ROVOL;
623         else
624             whichType = RWVOL;
625
626         /* figure out which one we're really interested in (a set is returned) */
627         volid = afs_vtoi(aname);
628         if (volid == 0) {
629             if (type == 2) {
630                 volid = uve->volumeId[whichType];
631             } else if (type == 1) {
632                 volid = nve->volumeId[whichType];
633             } else {
634                 volid = ove->volumeId[whichType];
635             }
636         } /* end of if (volid == 0) */
637     } /* end of if (!volid) */
638
639
640     ObtainWriteLock(&afs_xvolume, 108);
641     i = VHash(volid);
642     for (tv = afs_volumes[i]; tv; tv = tv->next) {
643         if (tv->volume == volid && tv->cell == tcell->cellNum) {
644             break;
645         }
646     }
647     if (!tv) {
648         tv = afs_GetVolSlot(volid, tcell);
649         if (!tv) {
650             ReleaseWriteLock(&afs_xvolume);
651             return NULL;
652         }
653         tv->next = afs_volumes[i];      /* thread into list */
654         afs_volumes[i] = tv;
655     }
656     tv->refCount++;
657     tv->states &= ~VRecheck;    /* just checked it */
658     tv->accessTime = osi_Time();
659     ReleaseWriteLock(&afs_xvolume);
660     if (type == 2) {
661         LockAndInstallUVolumeEntry(tv, uve, tcell->cellNum, tcell, areq);
662     } else if (type == 1)
663         LockAndInstallNVolumeEntry(tv, nve, tcell->cellNum);
664     else
665         LockAndInstallVolumeEntry(tv, ove, tcell->cellNum);
666     if (agood) {
667         if (!tv->name) {
668             tv->name = afs_osi_Alloc(strlen(aname) + 1);
669             osi_Assert(tv->name != NULL);
670             strcpy(tv->name, aname);
671         }
672     }
673     for (i = 0; i < NMAXNSERVERS; i++) {
674         tv->status[i] = not_busy;
675     }
676     ReleaseWriteLock(&tv->lock);
677     return tv;
678 }
679
680
681 /**
682  * Seek volume by it's name and attributes.
683  * If volume not found, try to add one.
684  * @param aname Volume name.
685  * @param acell Cell
686  * @param agood
687  * @param areq
688  * @param locktype Type of lock to be used.
689  * @return
690  */
691 struct volume *
692 afs_GetVolumeByName(char *aname, afs_int32 acell, int agood,
693                     struct vrequest *areq, afs_int32 locktype)
694 {
695     afs_int32 i;
696     struct volume *tv;
697
698     AFS_STATCNT(afs_GetVolumeByName);
699     ObtainWriteLock(&afs_xvolume, 112);
700     for (i = 0; i < NVOLS; i++) {
701         for (tv = afs_volumes[i]; tv; tv = tv->next) {
702             if (tv->name && !strcmp(aname, tv->name) && tv->cell == acell
703                 && (tv->states & VRecheck) == 0) {
704                 tv->refCount++;
705                 ReleaseWriteLock(&afs_xvolume);
706                 return tv;
707             }
708         }
709     }
710
711     ReleaseWriteLock(&afs_xvolume);
712
713     if (AFS_IS_DISCONNECTED)
714         return NULL;
715
716     tv = afs_NewVolumeByName(aname, acell, agood, areq, locktype);
717     return (tv);
718 }
719
720 /**
721  *   Init a new dynroot volume.
722  * @param Volume FID.
723  * @return Volume or NULL if not found.
724  */
725 static struct volume *
726 afs_NewDynrootVolume(struct VenusFid *fid)
727 {
728     struct cell *tcell;
729     struct volume *tv;
730     struct vldbentry *tve;
731     char *bp, tbuf[CVBS];
732
733     tcell = afs_GetCell(fid->Cell, READ_LOCK);
734     if (!tcell)
735         return NULL;
736     tve = afs_osi_Alloc(sizeof(*tve));
737     osi_Assert(tve != NULL);
738     if (!(tcell->states & CHasVolRef))
739         tcell->states |= CHasVolRef;
740
741     bp = afs_cv2string(&tbuf[CVBS], fid->Fid.Volume);
742     memset(tve, 0, sizeof(*tve));
743     strcpy(tve->name, "local-dynroot");
744     tve->volumeId[ROVOL] = fid->Fid.Volume;
745     tve->flags = VLF_ROEXISTS;
746
747     tv = afs_SetupVolume(0, bp, tve, tcell, 0, 0, 0);
748     afs_PutCell(tcell, READ_LOCK);
749     afs_osi_Free(tve, sizeof(*tve));
750     return tv;
751 }
752
753 int lastnvcode;
754
755 /**
756  * @param aname Volume name.
757  * @param acell Cell id.
758  * @param agood
759  * @param areq Request type.
760  * @param locktype Type of lock to be used.
761  * @return Volume or NULL if failure.
762  */
763 static struct volume *
764 afs_NewVolumeByName(char *aname, afs_int32 acell, int agood,
765                     struct vrequest *areq, afs_int32 locktype)
766 {
767     afs_int32 code, type = 0;
768     struct volume *tv, *tv1;
769     struct vldbentry *tve;
770     struct nvldbentry *ntve;
771     struct uvldbentry *utve;
772     struct cell *tcell;
773     char *tbuffer, *ve;
774     struct afs_conn *tconn;
775     struct vrequest treq;
776     struct rx_connection *rxconn;
777
778     if (strlen(aname) > VL_MAXNAMELEN)  /* Invalid volume name */
779         return NULL;
780
781     tcell = afs_GetCell(acell, READ_LOCK);
782     if (!tcell) {
783         return NULL;
784     }
785
786     /* allow null request if we don't care about ENODEV/ETIMEDOUT distinction */
787     if (!areq)
788         areq = &treq;
789
790
791     afs_Trace2(afs_iclSetp, CM_TRACE_GETVOL, ICL_TYPE_STRING, aname,
792                ICL_TYPE_POINTER, aname);
793     tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
794     tve = (struct vldbentry *)(tbuffer + 1024);
795     ntve = (struct nvldbentry *)tve;
796     utve = (struct uvldbentry *)tve;
797     afs_InitReq(&treq, afs_osi_credp);  /* *must* be unauth for vldb */
798     do {
799         tconn =
800             afs_ConnByMHosts(tcell->cellHosts, tcell->vlport, tcell->cellNum,
801                              &treq, SHARED_LOCK, 0, &rxconn);
802         if (tconn) {
803             if (tconn->parent->srvr->server->flags & SNO_LHOSTS) {
804                 type = 0;
805                 RX_AFS_GUNLOCK();
806                 code = VL_GetEntryByNameO(rxconn, aname, tve);
807                 RX_AFS_GLOCK();
808             } else if (tconn->parent->srvr->server->flags & SYES_LHOSTS) {
809                 type = 1;
810                 RX_AFS_GUNLOCK();
811                 code = VL_GetEntryByNameN(rxconn, aname, ntve);
812                 RX_AFS_GLOCK();
813             } else {
814                 type = 2;
815                 RX_AFS_GUNLOCK();
816                 code = VL_GetEntryByNameU(rxconn, aname, utve);
817                 RX_AFS_GLOCK();
818                 if (!(tconn->parent->srvr->server->flags & SVLSRV_UUID)) {
819                     if (code == RXGEN_OPCODE) {
820                         type = 1;
821                         RX_AFS_GUNLOCK();
822                         code = VL_GetEntryByNameN(rxconn, aname, ntve);
823                         RX_AFS_GLOCK();
824                         if (code == RXGEN_OPCODE) {
825                             type = 0;
826                             tconn->parent->srvr->server->flags |= SNO_LHOSTS;
827                             RX_AFS_GUNLOCK();
828                             code = VL_GetEntryByNameO(rxconn, aname, tve);
829                             RX_AFS_GLOCK();
830                         } else if (!code)
831                             tconn->parent->srvr->server->flags |= SYES_LHOSTS;
832                     } else if (!code)
833                         tconn->parent->srvr->server->flags |= SVLSRV_UUID;
834                 }
835                 lastnvcode = code;
836             }
837         } else
838             code = -1;
839     } while (afs_Analyze(tconn, rxconn, code, NULL, &treq, -1,  /* no op code for this */
840                          SHARED_LOCK, tcell));
841
842     if (code) {
843         /* If the client has yet to contact this cell and contact failed due
844          * to network errors, mark the VLDB servers as back up.
845          * That the client tried and failed can be determined from the
846          * fact that there was a downtime incident, but CHasVolRef is not set.
847          */
848     /* RT 48959 - unclear if this should really go */
849 #if 0
850         if (areq->networkError && !(tcell->states & CHasVolRef)) {
851             int i;
852             struct server *sp;
853             struct srvAddr *sap;
854             for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
855                 if ((sp = tcell->cellHosts[i]) == NULL)
856                     break;
857                 for (sap = sp->addr; sap; sap = sap->next_sa)
858                     afs_MarkServerUpOrDown(sap, 0);
859             }
860         }
861 #endif
862         afs_CopyError(&treq, areq);
863         osi_FreeLargeSpace(tbuffer);
864         afs_PutCell(tcell, READ_LOCK);
865         return NULL;
866     }
867     /*
868      * Check to see if this cell has not yet referenced a volume.  If
869      * it hasn't, it's just about to change its status, and we need to mark
870      * this fact down. Note that it is remotely possible that afs_SetupVolume
871      * could fail and we would still not have a volume reference.
872      */
873     if (!(tcell->states & CHasVolRef)) {
874         tcell->states |= CHasVolRef;
875         afs_stats_cmperf.numCellsContacted++;
876     }
877     /*First time a volume in this cell has been referenced */
878     if (type == 2)
879         ve = (char *)utve;
880     else if (type == 1)
881         ve = (char *)ntve;
882     else
883         ve = (char *)tve;
884     tv = afs_SetupVolume(0, aname, ve, tcell, agood, type, &treq);
885     if ((agood == 3) && tv && tv->backVol) {
886         /*
887          * This means that very soon we'll ask for the BK volume so
888          * we'll prefetch it (well we did already.)
889          */
890         tv1 =
891             afs_SetupVolume(tv->backVol, (char *)0, ve, tcell, 0, type, &treq);
892         if (tv1) {
893             tv1->refCount--;
894         }
895     }
896     if ((agood >= 2) && tv && tv->roVol) {
897         /*
898          * This means that very soon we'll ask for the RO volume so
899          * we'll prefetch it (well we did already.)
900          */
901         tv1 = afs_SetupVolume(tv->roVol, NULL, ve, tcell, 0, type, &treq);
902         if (tv1) {
903             tv1->refCount--;
904         }
905     }
906     osi_FreeLargeSpace(tbuffer);
907     afs_PutCell(tcell, READ_LOCK);
908     return tv;
909
910 }                               /*afs_NewVolumeByName */
911
912
913
914 /**
915  *   Call this with the volume structure locked; used for new-style vldb requests.
916  * @param av Volume
917  * @param ve
918  * @param acell
919  */
920 void
921 LockAndInstallVolumeEntry(struct volume *av, struct vldbentry *ve, int acell)
922 {
923     struct server *ts;
924     struct cell *cellp;
925     int i, j;
926     afs_int32 mask;
927     afs_uint32 temp;
928     char types = 0;
929     struct server *serverHost[AFS_MAXHOSTS];
930
931     AFS_STATCNT(InstallVolumeEntry);
932
933     memset(serverHost, 0, sizeof(serverHost));
934
935     /* Determine the type of volume we want */
936     if ((ve->flags & VLF_RWEXISTS) && (av->volume == ve->volumeId[RWVOL])) {
937         mask = VLSF_RWVOL;
938     } else if ((ve->flags & VLF_ROEXISTS)
939                && (av->volume == ve->volumeId[ROVOL])) {
940         mask = VLSF_ROVOL;
941         types |= VRO;
942     } else if ((ve->flags & VLF_BACKEXISTS)
943                && (av->volume == ve->volumeId[BACKVOL])) {
944         /* backup always is on the same volume as parent */
945         mask = VLSF_RWVOL;
946         types |= (VRO | VBackup);
947     } else {
948         mask = 0;               /* Can't find volume in vldb entry */
949     }
950
951     cellp = afs_GetCell(acell, 0);
952
953     /* Step through the VLDB entry making sure each server listed is there */
954     for (i = 0, j = 0; i < ve->nServers; i++) {
955         if (((ve->serverFlags[i] & mask) == 0)
956             || (ve->serverFlags[i] & VLSF_DONTUSE)) {
957             continue;           /* wrong volume or  don't use this volume */
958         }
959
960         temp = htonl(ve->serverNumber[i]);
961         ts = afs_GetServer(&temp, 1, acell, cellp->fsport, WRITE_LOCK,
962                            (afsUUID *) 0, 0, av);
963         serverHost[j] = ts;
964
965         /*
966          * The cell field could be 0 if the server entry was created
967          * first with the 'fs setserverprefs' call which doesn't set
968          * the cell field. Thus if the afs_GetServer call above
969          * follows later on it will find the server entry thus it will
970          * simply return without setting any fields, so we set the
971          * field ourselves below.
972          */
973         if (!ts->cell)
974             ts->cell = cellp;
975         afs_PutServer(ts, WRITE_LOCK);
976         j++;
977     }
978
979     ObtainWriteLock(&av->lock, 109);
980
981     memcpy(av->serverHost, serverHost, sizeof(serverHost));
982
983     /* from above */
984     av->states |= types;
985
986     /* fill in volume types */
987     av->rwVol = ((ve->flags & VLF_RWEXISTS) ? ve->volumeId[RWVOL] : 0);
988     av->roVol = ((ve->flags & VLF_ROEXISTS) ? ve->volumeId[ROVOL] : 0);
989     av->backVol = ((ve->flags & VLF_BACKEXISTS) ? ve->volumeId[BACKVOL] : 0);
990
991     if (ve->flags & VLF_DFSFILESET)
992         av->states |= VForeign;
993
994     afs_SortServers(av->serverHost, AFS_MAXHOSTS);
995 }                               /*InstallVolumeEntry */
996
997
998 void
999 LockAndInstallNVolumeEntry(struct volume *av, struct nvldbentry *ve, int acell)
1000 {
1001     struct server *ts;
1002     struct cell *cellp;
1003     int i, j;
1004     afs_int32 mask;
1005     afs_uint32 temp;
1006     char types = 0;
1007     struct server *serverHost[AFS_MAXHOSTS];
1008
1009     AFS_STATCNT(InstallVolumeEntry);
1010
1011     memset(serverHost, 0, sizeof(serverHost));
1012
1013     /* Determine type of volume we want */
1014     if ((ve->flags & VLF_RWEXISTS) && (av->volume == ve->volumeId[RWVOL])) {
1015         mask = VLSF_RWVOL;
1016     } else if ((ve->flags & VLF_ROEXISTS)
1017                && (av->volume == ve->volumeId[ROVOL])) {
1018         mask = VLSF_ROVOL;
1019         types |= VRO;
1020     } else if ((ve->flags & VLF_BACKEXISTS)
1021                && (av->volume == ve->volumeId[BACKVOL])) {
1022         /* backup always is on the same volume as parent */
1023         mask = VLSF_RWVOL;
1024         types |= (VRO | VBackup);
1025     } else {
1026         mask = 0;               /* Can't find volume in vldb entry */
1027     }
1028
1029     cellp = afs_GetCell(acell, 0);
1030
1031     /* Step through the VLDB entry making sure each server listed is there */
1032     for (i = 0, j = 0; i < ve->nServers; i++) {
1033         if (((ve->serverFlags[i] & mask) == 0)
1034             || (ve->serverFlags[i] & VLSF_DONTUSE)) {
1035             continue;           /* wrong volume or don't use this volume */
1036         }
1037
1038         temp = htonl(ve->serverNumber[i]);
1039         ts = afs_GetServer(&temp, 1, acell, cellp->fsport, WRITE_LOCK,
1040                            (afsUUID *) 0, 0, av);
1041         serverHost[j] = ts;
1042         /*
1043          * The cell field could be 0 if the server entry was created
1044          * first with the 'fs setserverprefs' call which doesn't set
1045          * the cell field. Thus if the afs_GetServer call above
1046          * follows later on it will find the server entry thus it will
1047          * simply return without setting any fields, so we set the
1048          * field ourselves below.
1049          */
1050         if (!ts->cell)
1051             ts->cell = cellp;
1052         afs_PutServer(ts, WRITE_LOCK);
1053         j++;
1054     }
1055
1056     ObtainWriteLock(&av->lock, 110);
1057
1058     memcpy(av->serverHost, serverHost, sizeof(serverHost));
1059
1060     /* from above */
1061     av->states |= types;
1062
1063     /* fill in volume types */
1064     av->rwVol = ((ve->flags & VLF_RWEXISTS) ? ve->volumeId[RWVOL] : 0);
1065     av->roVol = ((ve->flags & VLF_ROEXISTS) ? ve->volumeId[ROVOL] : 0);
1066     av->backVol = ((ve->flags & VLF_BACKEXISTS) ? ve->volumeId[BACKVOL] : 0);
1067
1068     if (ve->flags & VLF_DFSFILESET)
1069         av->states |= VForeign;
1070
1071     afs_SortServers(av->serverHost, AFS_MAXHOSTS);
1072 }                               /*InstallNVolumeEntry */
1073
1074
1075 void
1076 LockAndInstallUVolumeEntry(struct volume *av, struct uvldbentry *ve, int acell,
1077                            struct cell *tcell, struct vrequest *areq)
1078 {
1079     struct server *ts;
1080     struct afs_conn *tconn;
1081     struct cell *cellp;
1082     int i, j;
1083     afs_uint32 serverid;
1084     afs_int32 mask;
1085     int k;
1086     char type = 0;
1087     struct server *serverHost[AFS_MAXHOSTS];
1088
1089     AFS_STATCNT(InstallVolumeEntry);
1090
1091     memset(serverHost, 0, sizeof(serverHost));
1092
1093     /* Determine type of volume we want */
1094     if ((ve->flags & VLF_RWEXISTS) && (av->volume == ve->volumeId[RWVOL])) {
1095         mask = VLSF_RWVOL;
1096     } else if ((ve->flags & VLF_ROEXISTS)
1097                && av->volume == ve->volumeId[ROVOL]) {
1098         mask = VLSF_ROVOL;
1099         type |= VRO;
1100     } else if ((ve->flags & VLF_BACKEXISTS)
1101                && (av->volume == ve->volumeId[BACKVOL])) {
1102         /* backup always is on the same volume as parent */
1103         mask = VLSF_RWVOL;
1104         type |= (VRO | VBackup);
1105     } else {
1106         mask = 0;               /* Can't find volume in vldb entry */
1107     }
1108
1109     cellp = afs_GetCell(acell, 0);
1110
1111     /* Gather the list of servers the VLDB says the volume is on
1112      * and initialize the ve->serverHost[] array. If a server struct
1113      * is not found, then get the list of addresses for the
1114      * server, VL_GetAddrsU(), and create a server struct, afs_GetServer().
1115      */
1116     for (i = 0, j = 0; i < ve->nServers; i++) {
1117         if (((ve->serverFlags[i] & mask) == 0)
1118             || (ve->serverFlags[i] & VLSF_DONTUSE)) {
1119             continue;           /* wrong volume don't use this volume */
1120         }
1121
1122         if (!(ve->serverFlags[i] & VLSF_UUID)) {
1123             /* The server has no uuid */
1124             serverid = htonl(ve->serverNumber[i].time_low);
1125             ts = afs_GetServer(&serverid, 1, acell, cellp->fsport,
1126                                WRITE_LOCK, (afsUUID *) 0, 0, av);
1127         } else {
1128             ts = afs_FindServer(0, cellp->fsport, &ve->serverNumber[i], 0);
1129             if (ts && (ts->sr_addr_uniquifier == ve->serverUnique[i])
1130                 && ts->addr) {
1131                 /* uuid, uniquifier, and portal are the same */
1132             } else {
1133                 afs_uint32 *addrp, code;
1134                 afs_int32 nentries, unique;
1135                 bulkaddrs addrs;
1136                 ListAddrByAttributes attrs;
1137                 afsUUID uuid;
1138                 struct rx_connection *rxconn;
1139
1140                 memset(&attrs, 0, sizeof(attrs));
1141                 attrs.Mask = VLADDR_UUID;
1142                 attrs.uuid = ve->serverNumber[i];
1143                 memset(&uuid, 0, sizeof(uuid));
1144                 memset(&addrs, 0, sizeof(addrs));
1145                 do {
1146                     tconn =
1147                         afs_ConnByMHosts(tcell->cellHosts, tcell->vlport,
1148                                          tcell->cellNum, areq, SHARED_LOCK,
1149                                          0, &rxconn);
1150                     if (tconn) {
1151                         RX_AFS_GUNLOCK();
1152                         code =
1153                             VL_GetAddrsU(rxconn, &attrs, &uuid, &unique,
1154                                          &nentries, &addrs);
1155                         RX_AFS_GLOCK();
1156                     } else {
1157                         code = -1;
1158                     }
1159
1160                     /* Handle corrupt VLDB (defect 7393) */
1161                     if (code == 0 && nentries == 0)
1162                         code = VL_NOENT;
1163
1164                 } while (afs_Analyze
1165                          (tconn, rxconn, code, NULL, areq, -1, SHARED_LOCK, tcell));
1166                 if (code) {
1167                     /* Better handing of such failures; for now we'll simply retry this call */
1168                     areq->volumeError = 1;
1169                     return;
1170                 }
1171
1172                 addrp = addrs.bulkaddrs_val;
1173                 for (k = 0; k < nentries; k++) {
1174                     addrp[k] = htonl(addrp[k]);
1175                 }
1176                 ts = afs_GetServer(addrp, nentries, acell,
1177                                    cellp->fsport, WRITE_LOCK,
1178                                    &ve->serverNumber[i],
1179                                    ve->serverUnique[i], av);
1180                 xdr_free((xdrproc_t) xdr_bulkaddrs, &addrs);
1181             }
1182         }
1183         serverHost[j] = ts;
1184
1185         /* The cell field could be 0 if the server entry was created
1186          * first with the 'fs setserverprefs' call which doesn't set
1187          * the cell field. Thus if the afs_GetServer call above
1188          * follows later on it will find the server entry thus it will
1189          * simply return without setting any fields, so we set the
1190          * field ourselves below.
1191          */
1192         if (!ts->cell)
1193             ts->cell = cellp;
1194         afs_PutServer(ts, WRITE_LOCK);
1195         j++;
1196     }
1197
1198     ObtainWriteLock(&av->lock, 111);
1199
1200     memcpy(av->serverHost, serverHost, sizeof(serverHost));
1201
1202     /* from above */
1203     av->states |= type;
1204
1205     /* fill in volume types */
1206     av->rwVol = ((ve->flags & VLF_RWEXISTS) ? ve->volumeId[RWVOL] : 0);
1207     av->roVol = ((ve->flags & VLF_ROEXISTS) ? ve->volumeId[ROVOL] : 0);
1208     av->backVol = ((ve->flags & VLF_BACKEXISTS) ? ve->volumeId[BACKVOL] : 0);
1209
1210     if (ve->flags & VLF_DFSFILESET)
1211         av->states |= VForeign;
1212
1213     afs_SortServers(av->serverHost, AFS_MAXHOSTS);
1214 }                               /*InstallVolumeEntry */
1215
1216
1217 /**
1218  *   Reset volume info for the specified volume strecture. Mark volume
1219  * to be rechecked next time.
1220  * @param tv
1221  */
1222 void
1223 afs_ResetVolumeInfo(struct volume *tv)
1224 {
1225     int i;
1226
1227     AFS_STATCNT(afs_ResetVolumeInfo);
1228     ObtainWriteLock(&tv->lock, 117);
1229     tv->states |= VRecheck;
1230
1231     /* the hard-mount code in afs_Analyze may not be able to reset this flag
1232      * when VRecheck is set, so clear it here to ensure it gets cleared. */
1233     tv->states &= ~VHardMount;
1234
1235     for (i = 0; i < AFS_MAXHOSTS; i++)
1236         tv->status[i] = not_busy;
1237     if (tv->name) {
1238         afs_osi_Free(tv->name, strlen(tv->name) + 1);
1239         tv->name = NULL;
1240     }
1241     ReleaseWriteLock(&tv->lock);
1242 }