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