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