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