src/afs/afs_volume.c

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