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