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