src/vol/vutil.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         System:         VICE-TWO
  12         Module:         vutil.c
  13         Institution:    The Information Technology Center, Carnegie-Mellon University
  14
  15  */
  16
  17 #include <afsconfig.h>
  18 #include <afs/param.h>
  19
  20
  21 #include <stdio.h>
  22 #include <sys/types.h>
  23 #include <errno.h>
  24 #ifdef AFS_NT40_ENV
  25 #include <time.h>
  26 #include <fcntl.h>
  27 #else
  28 #include <sys/time.h>
  29 #include <sys/file.h>
  30 #include <unistd.h>
  31 #endif
  32 #include <dirent.h>
  33 #include <sys/stat.h>
  34 #include <afs/afs_assert.h>
  35
  36 #include <rx/xdr.h>
  37 #include <afs/afsint.h>
  38 #include "nfs.h"
  39 #include <afs/errors.h>
  40 #include "lock.h"
  41 #include "lwp.h"
  42 #include <afs/afssyscalls.h>
  43 #include "ihandle.h"
  44 #include <afs/afsutil.h>
  45 #ifdef AFS_NT40_ENV
  46 #include "ntops.h"
  47 #include <io.h>
  48 #endif
  49 #include "vnode.h"
  50 #include "volume.h"
  51 #include "volume_inline.h"
  52 #include "partition.h"
  53 #include "viceinode.h"
  54
  55 #include "volinodes.h"
  56 #include "vol_prototypes.h"
  57 #include "common.h"
  58
  59 #ifdef  AFS_AIX_ENV
  60 #include <sys/lockf.h>
  61 #endif
  62 #if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV) || defined(AFS_LINUX20_ENV)
  63 #include <string.h>
  64 #else
  65 #include <strings.h>
  66 #endif
  67
  68 #ifdef O_LARGEFILE
  69 #define afs_open        open64
  70 #else /* !O_LARGEFILE */
  71 #define afs_open        open
  72 #endif /* !O_LARGEFILE */
  73
  74
  75 /* Note:  the volume creation functions herein leave the destroyMe flag in the
  76    volume header ON:  this means that the volumes will not be attached by the
  77    file server and WILL BE DESTROYED the next time a system salvage is performed */
  78
  79 #ifdef FSSYNC_BUILD_CLIENT
  80 static void
  81 RemoveInodes(struct afs_inode_info *stuff, Device dev, VolumeId vid)
  82 {
  83     int i;
  84     IHandle_t *handle;
  85
  86     /* This relies on the fact that IDEC only needs the device and NT only
  87      * needs the dev and vid to decrement volume special files.
  88      */
  89     IH_INIT(handle, dev, vid, -1);
  90     for (i = 0; i < MAXINODETYPE; i++) {
  91         Inode inode = *stuff[i].inode;
  92         if (VALID_INO(inode))
  93             IH_DEC(handle, inode, vid);
  94     }
  95     IH_RELEASE(handle);
  96 }
  97
  98 Volume *
  99 VCreateVolume(Error * ec, char *partname, VolId volumeId, VolId parentId)
 100 {                               /* Should be the same as volumeId if there is
 101                                  * no parent */
 102     Volume *retVal;
 103     VOL_LOCK;
 104     retVal = VCreateVolume_r(ec, partname, volumeId, parentId);
 105     VOL_UNLOCK;
 106     return retVal;
 107 }
 108
 109 Volume *
 110 VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
 111 {                               /* Should be the same as volumeId if there is
 112                                  * no parent */
 113     VolumeDiskData vol;
 114     int i, rc;
 115     char headerName[VMAXPATHLEN], volumePath[VMAXPATHLEN];
 116     Device device;
 117     struct DiskPartition64 *partition;
 118     struct VolumeDiskHeader diskHeader;
 119     IHandle_t *handle;
 120     FdHandle_t *fdP;
 121     Inode nearInode = 0;
 122     char *part, *name;
 123     struct stat st;
 124     struct VolumeHeader tempHeader;
 125     struct afs_inode_info stuff[MAXINODETYPE];
 126     afs_ino_str_t stmp;
 127 # ifdef AFS_DEMAND_ATTACH_FS
 128     int locktype = 0;
 129 # endif /* AFS_DEMAND_ATTACH_FS */
 130
 131     init_inode_info(&tempHeader, stuff);
 132
 133     *ec = 0;
 134     memset(&vol, 0, sizeof(vol));
 135     vol.id = volumeId;
 136     vol.parentId = parentId;
 137     vol.copyDate = time(0);     /* The only date which really means when this
 138                                  * @i(instance) of this volume was created.
 139                                  * Creation date does not mean this */
 140
 141     /* Initialize handle for error case below. */
 142     handle = NULL;
 143
 144     /* Verify that the parition is valid before writing to it. */
 145     if (!(partition = VGetPartition_r(partname, 0))) {
 146         Log("VCreateVolume: partition %s is not in service.\n", partname);
 147         *ec = VNOVOL;
 148         return NULL;
 149     }
 150 #if     defined(NEARINODE_HINT)
 151     nearInodeHash(volumeId, nearInode);
 152     nearInode %= partition->f_files;
 153 #endif
 154     VGetVolumePath(ec, vol.id, &part, &name);
 155     if (*ec == VNOVOL || !strcmp(partition->name, part)) {
 156         /* this case is ok */
 157     } else {
 158         /* return EXDEV if it's a clone to an alternate partition
 159          * otherwise assume it's a move */
 160         if (vol.parentId != vol.id) {
 161             *ec = EXDEV;
 162             return NULL;
 163         }
 164     }
 165     *ec = 0;
 166
 167 # ifdef AFS_DEMAND_ATTACH_FS
 168     /* volume doesn't exist yet, but we must lock it to try to prevent something
 169      * else from reading it when we're e.g. half way through creating it (or
 170      * something tries to create the same volume at the same time) */
 171     locktype = VVolLockType(V_VOLUPD, 1);
 172     rc = VLockVolumeByIdNB(volumeId, partition, locktype);
 173     if (rc) {
 174         Log("VCreateVolume: vol %lu already locked by someone else\n",
 175             afs_printable_uint32_lu(volumeId));
 176         *ec = VNOVOL;
 177         return NULL;
 178     }
 179 # else /* AFS_DEMAND_ATTACH_FS */
 180     VLockPartition_r(partname);
 181 # endif /* !AFS_DEMAND_ATTACH_FS */
 182
 183     memset(&tempHeader, 0, sizeof(tempHeader));
 184     tempHeader.stamp.magic = VOLUMEHEADERMAGIC;
 185     tempHeader.stamp.version = VOLUMEHEADERVERSION;
 186     tempHeader.id = vol.id;
 187     tempHeader.parent = vol.parentId;
 188     vol.stamp.magic = VOLUMEINFOMAGIC;
 189     vol.stamp.version = VOLUMEINFOVERSION;
 190     vol.destroyMe = DESTROY_ME;
 191     (void)afs_snprintf(headerName, sizeof headerName, VFORMAT, afs_printable_uint32_lu(vol.id));
 192     (void)afs_snprintf(volumePath, sizeof volumePath, "%s/%s",
 193                        VPartitionPath(partition), headerName);
 194     rc = stat(volumePath, &st);
 195     if (rc == 0 || errno != ENOENT) {
 196         if (rc == 0) {
 197             Log("VCreateVolume: Header file %s already exists!\n",
 198                 volumePath);
 199             *ec = VVOLEXISTS;
 200         } else {
 201             Log("VCreateVolume: Error %d trying to stat header file %s\n",
 202                 errno, volumePath);
 203             *ec = VNOVOL;
 204         }
 205         goto bad_noheader;
 206     }
 207     device = partition->device;
 208
 209     for (i = 0; i < MAXINODETYPE; i++) {
 210         struct afs_inode_info *p = &stuff[i];
 211         if (p->obsolete)
 212             continue;
 213 #ifdef AFS_NAMEI_ENV
 214         *(p->inode) =
 215             IH_CREATE(NULL, device, VPartitionPath(partition), nearInode,
 216                       (p->inodeType == VI_LINKTABLE) ? vol.parentId : vol.id,
 217                       INODESPECIAL, p->inodeType, vol.parentId);
 218         if (!(VALID_INO(*(p->inode)))) {
 219             if (errno == EEXIST && (p->inodeType == VI_LINKTABLE)) {
 220                 /* Increment the reference count instead. */
 221                 IHandle_t *lh;
 222                 int code;
 223
 224 #ifdef AFS_NT40_ENV
 225                 *(p->inode) = nt_MakeSpecIno(VI_LINKTABLE);
 226 #else
 227                 *(p->inode) = namei_MakeSpecIno(vol.parentId, VI_LINKTABLE);
 228 #endif
 229                 IH_INIT(lh, device, parentId, *(p->inode));
 230                 fdP = IH_OPEN(lh);
 231                 if (fdP == NULL) {
 232                     IH_RELEASE(lh);
 233                     goto bad;
 234                 }
 235                 code = IH_INC(lh, *(p->inode), parentId);
 236                 FDH_REALLYCLOSE(fdP);
 237                 IH_RELEASE(lh);
 238                 if (code < 0)
 239                     goto bad;
 240                 continue;
 241             }
 242         }
 243 #else
 244         *(p->inode) =
 245             IH_CREATE(NULL, device, VPartitionPath(partition), nearInode,
 246                       vol.id, INODESPECIAL, p->inodeType, vol.parentId);
 247 #endif
 248
 249         if (!VALID_INO(*(p->inode))) {
 250             Log("VCreateVolume:  Problem creating %s file associated with volume header %s\n", p->description, volumePath);
 251           bad:
 252             if (handle)
 253                 IH_RELEASE(handle);
 254             RemoveInodes(stuff, device, vol.id);
 255             if (!*ec) {
 256                 *ec = VNOVOL;
 257             }
 258             VDestroyVolumeDiskHeader(partition, volumeId, parentId);
 259           bad_noheader:
 260 # ifdef AFS_DEMAND_ATTACH_FS
 261             if (locktype) {
 262                 VUnlockVolumeById(volumeId, partition);
 263             }
 264 # endif /* AFS_DEMAND_ATTACH_FS */
 265             return NULL;
 266         }
 267         IH_INIT(handle, device, vol.parentId, *(p->inode));
 268         fdP = IH_OPEN(handle);
 269         if (fdP == NULL) {
 270             Log("VCreateVolume:  Problem iopen inode %s (err=%d)\n",
 271                 PrintInode(stmp, *(p->inode)), errno);
 272             goto bad;
 273         }
 274         if (FDH_PWRITE(fdP, (char *)&p->stamp, sizeof(p->stamp), 0) !=
 275             sizeof(p->stamp)) {
 276             Log("VCreateVolume:  Problem writing to  inode %s (err=%d)\n",
 277                 PrintInode(stmp, *(p->inode)), errno);
 278             FDH_REALLYCLOSE(fdP);
 279             goto bad;
 280         }
 281         FDH_REALLYCLOSE(fdP);
 282         IH_RELEASE(handle);
 283         nearInode = *(p->inode);
 284     }
 285
 286     IH_INIT(handle, device, vol.parentId, tempHeader.volumeInfo);
 287     fdP = IH_OPEN(handle);
 288     if (fdP == NULL) {
 289         Log("VCreateVolume:  Problem iopen inode %s (err=%d)\n",
 290             PrintInode(stmp, tempHeader.volumeInfo), errno);
 291         goto bad;
 292     }
 293     if (FDH_PWRITE(fdP, (char *)&vol, sizeof(vol), 0) != sizeof(vol)) {
 294         Log("VCreateVolume:  Problem writing to  inode %s (err=%d)\n",
 295             PrintInode(stmp, tempHeader.volumeInfo), errno);
 296         FDH_REALLYCLOSE(fdP);
 297         goto bad;
 298     }
 299     FDH_CLOSE(fdP);
 300     IH_RELEASE(handle);
 301
 302     VolumeHeaderToDisk(&diskHeader, &tempHeader);
 303     rc = VCreateVolumeDiskHeader(&diskHeader, partition);
 304     if (rc) {
 305         Log("VCreateVolume: Error %d trying to write volume header for "
 306             "volume %u on partition %s; volume not created\n", rc,
 307             vol.id, VPartitionPath(partition));
 308         if (rc == EEXIST) {
 309             *ec = VVOLEXISTS;
 310         }
 311         goto bad;
 312     }
 313
 314 # ifdef AFS_DEMAND_ATTACH_FS
 315     if (locktype) {
 316         VUnlockVolumeById(volumeId, partition);
 317     }
 318 # endif /* AFS_DEMAND_ATTACH_FS */
 319     return (VAttachVolumeByName_r(ec, partname, headerName, V_SECRETLY));
 320 }
 321 #endif /* FSSYNC_BUILD_CLIENT */
 322
 323
 324 void
 325 AssignVolumeName(VolumeDiskData * vol, char *name, char *ext)
 326 {
 327     VOL_LOCK;
 328     AssignVolumeName_r(vol, name, ext);
 329     VOL_UNLOCK;
 330 }
 331
 332 void
 333 AssignVolumeName_r(VolumeDiskData * vol, char *name, char *ext)
 334 {
 335     char *dot;
 336     strncpy(vol->name, name, VNAMESIZE - 1);
 337     vol->name[VNAMESIZE - 1] = '\0';
 338     dot = strrchr(vol->name, '.');
 339     if (dot && (strcmp(dot, ".backup") == 0 || strcmp(dot, ".readonly") == 0))
 340         *dot = 0;
 341     if (ext)
 342         strncat(vol->name, ext, VNAMESIZE - 1 - strlen(vol->name));
 343 }
 344
 345 afs_int32
 346 CopyVolumeHeader_r(VolumeDiskData * from, VolumeDiskData * to)
 347 {
 348     /* The id and parentId fields are not copied; these are inviolate--the to volume
 349      * is assumed to have already been created.  The id's cannot be changed once
 350      * creation has taken place, since they are embedded in the various inodes associated
 351      * with the volume.  The copydate is also inviolate--it always reflects the time
 352      * this volume was created (compare with the creation date--the creation date of
 353      * a backup volume is the creation date of the original parent, because the backup
 354      * is used to backup the parent volume). */
 355     Date copydate;
 356     VolumeId id, parent;
 357     id = to->id;
 358     parent = to->parentId;
 359     copydate = to->copyDate;
 360     memcpy(to, from, sizeof(*from));
 361     to->id = id;
 362     to->parentId = parent;
 363     to->copyDate = copydate;
 364     to->destroyMe = DESTROY_ME; /* Caller must always clear this!!! */
 365     to->stamp.magic = VOLUMEINFOMAGIC;
 366     to->stamp.version = VOLUMEINFOVERSION;
 367     return 0;
 368 }
 369
 370 afs_int32
 371 CopyVolumeHeader(VolumeDiskData * from, VolumeDiskData * to)
 372 {
 373     afs_int32 code;
 374
 375     VOL_LOCK;
 376     code = CopyVolumeHeader_r(from, to);
 377     VOL_UNLOCK;
 378     return (code);
 379 }
 380
 381 void
 382 ClearVolumeStats(VolumeDiskData * vol)
 383 {
 384     VOL_LOCK;
 385     ClearVolumeStats_r(vol);
 386     VOL_UNLOCK;
 387 }
 388
 389 void
 390 ClearVolumeStats_r(VolumeDiskData * vol)
 391 {
 392     memset(vol->weekUse, 0, sizeof(vol->weekUse));
 393     vol->dayUse = 0;
 394     vol->dayUseDate = 0;
 395 }
 396
 397 /**
 398  * read an existing volume disk header.
 399  *
 400  * @param[in]  volid  volume id
 401  * @param[in]  dp     disk partition object
 402  * @param[out] hdr    volume disk header or NULL
 403  *
 404  * @note if hdr is NULL, this is essentially an existence test for the vol
 405  *       header
 406  *
 407  * @return operation status
 408  *    @retval 0 success
 409  *    @retval -1 volume header doesn't exist
 410  *    @retval EIO failed to read volume header
 411  *
 412  * @internal
 413  */
 414 afs_int32
 415 VReadVolumeDiskHeader(VolumeId volid,
 416                       struct DiskPartition64 * dp,
 417                       VolumeDiskHeader_t * hdr)
 418 {
 419     afs_int32 code = 0;
 420     int fd;
 421     char path[MAXPATHLEN];
 422
 423     (void)afs_snprintf(path, sizeof(path),
 424                        "%s/" VFORMAT,
 425                        VPartitionPath(dp), afs_printable_uint32_lu(volid));
 426     fd = open(path, O_RDONLY);
 427     if (fd < 0) {
 428         Log("VReadVolumeDiskHeader: Couldn't open header for volume %lu (errno %d).\n",
 429             afs_printable_uint32_lu(volid), errno);
 430         code = -1;
 431
 432     } else if (hdr && read(fd, hdr, sizeof(*hdr)) != sizeof(*hdr)) {
 433         Log("VReadVolumeDiskHeader: Couldn't read header for volume %lu.\n",
 434             afs_printable_uint32_lu(volid));
 435         code = EIO;
 436     }
 437
 438     if (fd >= 0) {
 439         close(fd);
 440     }
 441     return code;
 442 }
 443
 444 #ifdef FSSYNC_BUILD_CLIENT
 445 /**
 446  * write an existing volume disk header.
 447  *
 448  * @param[in] hdr   volume disk header
 449  * @param[in] dp    disk partition object
 450  * @param[in] cr    assert if O_CREAT | O_EXCL should be passed to open()
 451  *
 452  * @return operation status
 453  *    @retval 0 success
 454  *    @retval -1 volume header doesn't exist
 455  *    @retval EIO failed to write volume header
 456  *
 457  * @internal
 458  */
 459 static afs_int32
 460 _VWriteVolumeDiskHeader(VolumeDiskHeader_t * hdr,
 461                         struct DiskPartition64 * dp,
 462                         int flags)
 463 {
 464     afs_int32 code = 0;
 465     int fd;
 466     char path[MAXPATHLEN];
 467
 468 #ifdef AFS_DEMAND_ATTACH_FS
 469     /* prevent racing with VGC scanners reading the vol header while we are
 470      * writing it */
 471     code = VPartHeaderLock(dp, READ_LOCK);
 472     if (code) {
 473         return EIO;
 474     }
 475 #endif /* AFS_DEMAND_ATTACH_FS */
 476
 477     flags |= O_RDWR;
 478
 479     (void)afs_snprintf(path, sizeof(path),
 480                        "%s/" VFORMAT,
 481                        VPartitionPath(dp), afs_printable_uint32_lu(hdr->id));
 482     fd = open(path, flags, 0644);
 483     if (fd < 0) {
 484         code = errno;
 485         Log("_VWriteVolumeDiskHeader: Couldn't open header for volume %lu, "
 486             "error = %d\n", afs_printable_uint32_lu(hdr->id), errno);
 487     } else if (write(fd, hdr, sizeof(*hdr)) != sizeof(*hdr)) {
 488         Log("_VWriteVolumeDiskHeader: Couldn't write header for volume %lu, "
 489             "error = %d\n", afs_printable_uint32_lu(hdr->id), errno);
 490         code = EIO;
 491     }
 492
 493     if (fd >= 0) {
 494         if (close(fd) != 0) {
 495             Log("_VWriteVolumeDiskHeader: Error closing header for volume "
 496                 "%lu, errno %d\n", afs_printable_uint32_lu(hdr->id), errno);
 497         }
 498     }
 499
 500 #ifdef AFS_DEMAND_ATTACH_FS
 501     VPartHeaderUnlock(dp, READ_LOCK);
 502 #endif /* AFS_DEMAND_ATTACH_FS */
 503
 504     return code;
 505 }
 506
 507 /**
 508  * write an existing volume disk header.
 509  *
 510  * @param[in] hdr   volume disk header
 511  * @param[in] dp    disk partition object
 512  *
 513  * @return operation status
 514  *    @retval 0 success
 515  *    @retval ENOENT volume header doesn't exist
 516  *    @retval EIO failed to write volume header
 517  */
 518 afs_int32
 519 VWriteVolumeDiskHeader(VolumeDiskHeader_t * hdr,
 520                        struct DiskPartition64 * dp)
 521 {
 522     afs_int32 code;
 523
 524 #ifdef AFS_DEMAND_ATTACH_FS
 525     VolumeDiskHeader_t oldhdr;
 526     int delvgc = 0, addvgc = 0;
 527     SYNC_response res;
 528
 529     /* first, see if anything with the volume IDs have changed; if so, we
 530      * need to update the VGC */
 531
 532     code = VReadVolumeDiskHeader(hdr->id, dp, &oldhdr);
 533     if (code == 0 && (oldhdr.id != hdr->id || oldhdr.parent != hdr->parent)) {
 534         /* the vol id or parent vol id changed; need to delete the VGC entry
 535          * for the old vol id/parent, and add the new one */
 536         delvgc = 1;
 537         addvgc = 1;
 538
 539     } else if (code) {
 540         /* couldn't get the old header info; add the new header info to the
 541          * VGC in case it hasn't been added yet */
 542         addvgc = 1;
 543     }
 544
 545 #endif /* AFS_DEMAND_ATTACH_FS */
 546
 547     code = _VWriteVolumeDiskHeader(hdr, dp, 0);
 548     if (code) {
 549         goto done;
 550     }
 551
 552 #ifdef AFS_DEMAND_ATTACH_FS
 553     if (delvgc) {
 554         memset(&res, 0, sizeof(res));
 555         code = FSYNC_VGCDel(dp->name, oldhdr.parent, oldhdr.id, FSYNC_WHATEVER, &res);
 556
 557         /* unknown vol id is okay; it just further suggests the old header
 558          * data was bogus, which is fine since we're trying to fix it */
 559         if (code && res.hdr.reason != FSYNC_UNKNOWN_VOLID) {
 560             Log("VWriteVolumeDiskHeader: FSYNC_VGCDel(%s, %lu, %lu) "
 561                 "failed with code %ld reason %ld\n", dp->name,
 562                 afs_printable_uint32_lu(oldhdr.parent),
 563                 afs_printable_uint32_lu(oldhdr.id),
 564                 afs_printable_int32_ld(code),
 565                 afs_printable_int32_ld(res.hdr.reason));
 566         }
 567
 568     }
 569     if (addvgc) {
 570         memset(&res, 0, sizeof(res));
 571         code = FSYNC_VGCAdd(dp->name, hdr->parent, hdr->id, FSYNC_WHATEVER, &res);
 572         if (code) {
 573             Log("VWriteVolumeDiskHeader: FSYNC_VGCAdd(%s, %lu, %lu) "
 574                 "failed with code %ld reason %ld\n", dp->name,
 575                 afs_printable_uint32_lu(hdr->parent),
 576                 afs_printable_uint32_lu(hdr->id),
 577                 afs_printable_int32_ld(code),
 578                 afs_printable_int32_ld(res.hdr.reason));
 579         }
 580     }
 581
 582 #endif /* AFS_DEMAND_ATTACH_FS */
 583
 584  done:
 585     return code;
 586 }
 587
 588 /**
 589  * create and write a volume disk header to disk.
 590  *
 591  * @param[in] hdr   volume disk header
 592  * @param[in] dp    disk partition object
 593  *
 594  * @return operation status
 595  *    @retval 0 success
 596  *    @retval EEXIST volume header already exists
 597  *    @retval EIO failed to write volume header
 598  *
 599  * @internal
 600  */
 601 afs_int32
 602 VCreateVolumeDiskHeader(VolumeDiskHeader_t * hdr,
 603                         struct DiskPartition64 * dp)
 604 {
 605     afs_int32 code = 0;
 606 #ifdef AFS_DEMAND_ATTACH_FS
 607     SYNC_response res;
 608 #endif /* AFS_DEMAND_ATTACH_FS */
 609
 610     code = _VWriteVolumeDiskHeader(hdr, dp, O_CREAT | O_EXCL);
 611     if (code) {
 612         goto done;
 613     }
 614
 615 #ifdef AFS_DEMAND_ATTACH_FS
 616     memset(&res, 0, sizeof(res));
 617     code = FSYNC_VGCAdd(dp->name, hdr->parent, hdr->id, FSYNC_WHATEVER, &res);
 618     if (code) {
 619         Log("VCreateVolumeDiskHeader: FSYNC_VGCAdd(%s, %lu, %lu) failed "
 620             "with code %ld reason %ld\n", dp->name,
 621             afs_printable_uint32_lu(hdr->parent),
 622             afs_printable_uint32_lu(hdr->id),
 623             afs_printable_int32_ld(code),
 624             afs_printable_int32_ld(res.hdr.reason));
 625     }
 626 #endif /* AFS_DEMAND_ATTACH_FS */
 627
 628  done:
 629     return code;
 630 }
 631
 632
 633 /**
 634  * destroy a volume disk header.
 635  *
 636  * @param[in] dp      disk partition object
 637  * @param[in] volid   volume id
 638  * @param[in] parent  parent's volume id, 0 if unknown
 639  *
 640  * @return operation status
 641  *    @retval 0 success
 642  *
 643  * @note if parent is 0, the parent volume ID will be looked up from the
 644  * fileserver
 645  *
 646  * @note for non-DAFS, parent is currently ignored
 647  */
 648 afs_int32
 649 VDestroyVolumeDiskHeader(struct DiskPartition64 * dp,
 650                          VolumeId volid,
 651                          VolumeId parent)
 652 {
 653     afs_int32 code = 0;
 654     char path[MAXPATHLEN];
 655 #ifdef AFS_DEMAND_ATTACH_FS
 656     SYNC_response res;
 657 #endif /* AFS_DEMAND_ATTACH_FS */
 658
 659     (void)afs_snprintf(path, sizeof(path),
 660                        "%s/" VFORMAT,
 661                        VPartitionPath(dp), afs_printable_uint32_lu(volid));
 662     code = unlink(path);
 663     if (code) {
 664         Log("VDestroyVolumeDiskHeader: Couldn't unlink disk header, error = %d\n", errno);
 665         goto done;
 666     }
 667
 668 #ifdef AFS_DEMAND_ATTACH_FS
 669     memset(&res, 0, sizeof(res));
 670     if (!parent) {
 671         FSSYNC_VGQry_response_t q_res;
 672
 673         code = FSYNC_VGCQuery(dp->name, volid, &q_res, &res);
 674         if (code) {
 675             Log("VDestroyVolumeDiskHeader: FSYNC_VGCQuery(%s, %lu) failed "
 676                 "with code %ld, reason %ld\n", dp->name,
 677                 afs_printable_uint32_lu(volid), afs_printable_int32_ld(code),
 678                 afs_printable_int32_ld(res.hdr.reason));
 679             goto done;
 680         }
 681
 682         parent = q_res.rw;
 683
 684     }
 685     code = FSYNC_VGCDel(dp->name, parent, volid, FSYNC_WHATEVER, &res);
 686     if (code) {
 687         Log("VDestroyVolumeDiskHeader: FSYNC_VGCDel(%s, %lu, %lu) failed "
 688             "with code %ld reason %ld\n", dp->name,
 689             afs_printable_uint32_lu(parent),
 690             afs_printable_uint32_lu(volid),
 691             afs_printable_int32_ld(code),
 692             afs_printable_int32_ld(res.hdr.reason));
 693     }
 694 #endif /* AFS_DEMAND_ATTACH_FS */
 695
 696  done:
 697     return code;
 698 }
 699 #endif /* FSSYNC_BUILD_CLIENT */
 700
 701 /**
 702  * handle a single vol header as part of VWalkVolumeHeaders.
 703  *
 704  * @param[in] dp      disk partition
 705  * @param[in] volfunc function to call when a vol header is successfully read
 706  * @param[in] name    full path name to the .vol header
 707  * @param[out] hdr    header data read in from the .vol header
 708  * @param[in] locked  1 if the partition headers are locked, 0 otherwise
 709  * @param[in] rock    the rock to pass to volfunc
 710  *
 711  * @return operation status
 712  *  @retval 0  success
 713  *  @retval -1 fatal error, stop scanning
 714  *  @retval 1  failed to read header
 715  *  @retval 2  volfunc callback indicated error after header read
 716  */
 717 static int
 718 _VHandleVolumeHeader(struct DiskPartition64 *dp, VWalkVolFunc volfunc,
 719                      const char *name, struct VolumeDiskHeader *hdr,
 720                      int locked, void *rock)
 721 {
 722     int error = 0;
 723     int fd;
 724
 725     if ((fd = afs_open(name, O_RDONLY)) == -1
 726         || read(fd, hdr, sizeof(*hdr))
 727         != sizeof(*hdr)
 728         || hdr->stamp.magic != VOLUMEHEADERMAGIC) {
 729         error = 1;
 730     }
 731
 732     if (fd >= 0) {
 733         close(fd);
 734     }
 735
 736 #ifdef AFSFS_DEMAND_ATTACH_FS
 737     if (locked) {
 738         VPartHeaderUnlock(dp);
 739     }
 740 #endif /* AFS_DEMAND_ATTACH_FS */
 741
 742     if (!error && volfunc) {
 743         /* the volume header seems fine; call the caller-supplied
 744          * 'we-found-a-volume-header' function */
 745         int last = 1;
 746
 747 #ifdef AFS_DEMAND_ATTACH_FS
 748         if (!locked) {
 749             last = 0;
 750         }
 751 #endif /* AFS_DEMAND_ATTACH_FS */
 752
 753         error = (*volfunc) (dp, name, hdr, last, rock);
 754         if (error < 0) {
 755             return -1;
 756         }
 757         if (error) {
 758             error = 2;
 759         }
 760     }
 761
 762 #ifdef AFS_DEMAND_ATTACH_FS
 763     if (error && !locked) {
 764         int code;
 765         /* retry reading the volume header under the partition
 766          * header lock, just to be safe and ensure we're not
 767          * racing something rewriting the vol header */
 768         code = VPartHeaderLock(dp, WRITE_LOCK);
 769         if (code) {
 770             Log("Error acquiring partition write lock when "
 771                 "looking at header %s\n", name);
 772             return -1;
 773         }
 774
 775         return _VHandleVolumeHeader(dp, volfunc, name, hdr, 1, rock);
 776     }
 777 #endif /* AFS_DEMAND_ATTACH_FS */
 778
 779     return error;
 780 }
 781
 782 /**
 783  * walk through the list of volume headers on a partition.
 784  *
 785  * This function looks through all of the .vol headers on a partition, reads in
 786  * each header, and calls the supplied volfunc function on each one. If the
 787  * header cannot be read (or volfunc returns a positive error code), DAFS will
 788  * VPartHeaderExLock() and retry. If that fails, or if we are non-DAFS, errfunc
 789  * will be called (which typically will unlink the problem volume header).
 790  *
 791  * If volfunc returns a negative error code, walking the partition will stop
 792  * and we will return an error immediately.
 793  *
 794  * @param[in] dp       partition to walk
 795  * @param[in] partpath the path opendir()
 796  * @param[in] volfunc  the function to call when a header is encountered, or
 797  *                     NULL to just skip over valid headers
 798  * @param[in] errfunc  the function to call when a problematic header is
 799  *                     encountered, or NULL to just skip over bad headers
 800  * @param[in] rock     rock for volfunc and errfunc
 801  *
 802  * @see VWalkVolFunc
 803  * @see VWalkErrFunc
 804  *
 805  * @return operation status
 806  *  @retval 0 success
 807  *  @retval negative fatal error, walk did not finish
 808  */
 809 int
 810 VWalkVolumeHeaders(struct DiskPartition64 *dp, const char *partpath,
 811                    VWalkVolFunc volfunc, VWalkErrFunc errfunc, void *rock)
 812 {
 813     DIR *dirp = NULL;
 814     struct dirent *dentry = NULL;
 815     int code = 0;
 816     struct VolumeDiskHeader diskHeader;
 817
 818     dirp = opendir(partpath);
 819     if (!dirp) {
 820         Log("VWalkVolumeHeaders: cannot open directory %s\n", partpath);
 821         code = -1;
 822         goto done;
 823     }
 824
 825     while ((dentry = readdir(dirp))) {
 826         char *p = dentry->d_name;
 827         p = strrchr(dentry->d_name, '.');
 828         if (p != NULL && strcmp(p, VHDREXT) == 0) {
 829             char name[VMAXPATHLEN];
 830
 831             sprintf(name, "%s/%s", partpath, dentry->d_name);
 832
 833             code = _VHandleVolumeHeader(dp, volfunc, name, &diskHeader, -1, rock);
 834             if (code < 0) {
 835                 /* fatal error, stop walking */
 836                 goto done;
 837             }
 838             if (code && errfunc) {
 839                 /* error with header; call the caller-supplied vol error
 840                  * function */
 841
 842                 struct VolumeDiskHeader *hdr = &diskHeader;
 843                 if (code == 1) {
 844                     /* we failed to read the header at all, so don't pass in
 845                      * the header ptr */
 846                     hdr = NULL;
 847                 }
 848                 (*errfunc) (dp, name, hdr, rock);
 849             }
 850             code = 0;
 851         }
 852     }
 853  done:
 854     if (dirp) {
 855         closedir(dirp);
 856         dirp = NULL;
 857     }
 858
 859     return code;
 860 }
 861
 862 /**
 863  * initialize a struct VLockFile.
 864  *
 865  * @param[in] lf   struct VLockFile to initialize
 866  * @param[in] path Full path to the file to use for locks. The string contents
 867  *                 are copied.
 868  */
 869 void
 870 VLockFileInit(struct VLockFile *lf, const char *path)
 871 {
 872     memset(lf, 0, sizeof(*lf));
 873     lf->path = strdup(path);
 874     lf->fd = INVALID_FD;
 875     MUTEX_INIT(&lf->mutex, "vlockfile", MUTEX_DEFAULT, 0);
 876 }
 877
 878 #ifdef AFS_NT40_ENV
 879 static_inline FD_t
 880 _VOpenPath(const char *path)
 881 {
 882     HANDLE handle;
 883
 884     handle = CreateFile(path,
 885                         GENERIC_READ | GENERIC_WRITE,
 886                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 887                         NULL,
 888                         OPEN_ALWAYS,
 889                         FILE_ATTRIBUTE_HIDDEN,
 890                         NULL);
 891     if (handle == INVALID_HANDLE_VALUE) {
 892         return INVALID_FD;
 893     }
 894
 895     return handle;
 896 }
 897
 898 static_inline int
 899 _VLockFd(FD_t handle, afs_uint32 offset, int locktype, int nonblock)
 900 {
 901     DWORD flags = 0;
 902     OVERLAPPED lap;
 903
 904     if (locktype == WRITE_LOCK) {
 905         flags |= LOCKFILE_EXCLUSIVE_LOCK;
 906     }
 907     if (nonblock) {
 908         flags |= LOCKFILE_FAIL_IMMEDIATELY;
 909     }
 910
 911     memset(&lap, 0, sizeof(lap));
 912     lap.Offset = offset;
 913
 914     if (!LockFileEx(handle, flags, 0, 1, 0, &lap)) {
 915         if (GetLastError() == ERROR_LOCK_VIOLATION) {
 916             return EBUSY;
 917         }
 918         return EIO;
 919     }
 920
 921     return 0;
 922 }
 923
 924 static_inline void
 925 _VUnlockFd(struct VLockFile *lf, afs_uint32 offset)
 926 {
 927     OVERLAPPED lap;
 928
 929     memset(&lap, 0, sizeof(lap));
 930     lap.Offset = offset;
 931
 932     UnlockFileEx(lf->fd, 0, 1, 0, &lap);
 933 }
 934
 935 static_inline void
 936 _VCloseFd(struct VLockFile *lf)
 937 {
 938     CloseHandle(lf->fd);
 939 }
 940
 941 #else /* !AFS_NT40_ENV */
 942
 943 /**
 944  * open a file on the local filesystem suitable for locking
 945  *
 946  * @param[in] path  abs path of the file to open
 947  *
 948  * @return file descriptor
 949  *  @retval INVALID_FD failure opening file
 950  */
 951 static_inline int
 952 _VOpenPath(const char *path)
 953 {
 954     int fd;
 955
 956     fd = open(path, O_RDWR | O_CREAT, 0660);
 957     if (fd < 0) {
 958         return INVALID_FD;
 959     }
 960     return fd;
 961 }
 962
 963 /**
 964  * lock an offset in a file descriptor.
 965  *
 966  * @param[in] fd       file descriptor to lock
 967  * @param[in] offset   offset in file to lock
 968  * @param[in] locktype READ_LOCK or WRITE_LOCK
 969  * @param[in] nonblock 1 to fail immediately, 0 to wait to acquire lock
 970  *
 971  * @return operation status
 972  *  @retval 0 success
 973  *  @retval EBUSY someone else is holding a conflicting lock and nonblock=1 was
 974  *                specified
 975  *  @retval EIO   error acquiring file lock
 976  */
 977 static_inline int
 978 _VLockFd(int fd, afs_uint32 offset, int locktype, int nonblock)
 979 {
 980     int l_type = F_WRLCK;
 981     int cmd = F_SETLKW;
 982     struct flock sf;
 983
 984     if (locktype == READ_LOCK) {
 985         l_type = F_RDLCK;
 986     }
 987     if (nonblock) {
 988         cmd = F_SETLK;
 989     }
 990
 991     sf.l_start = offset;
 992     sf.l_len = 1;
 993     sf.l_type = l_type;
 994     sf.l_whence = SEEK_SET;
 995
 996     if (fcntl(fd, cmd, &sf)) {
 997         if (nonblock && (errno == EACCES || errno == EAGAIN)) {
 998             /* We asked for a nonblocking lock, and it was already locked */
 999             sf.l_pid = 0;
1000             if (fcntl(fd, F_GETLK, &sf) != 0 || sf.l_pid == 0) {
1001                 Log("_VLockFd: fcntl failed with error %d when trying to "
1002                     "query the conflicting lock for fd %d (locktype=%d, "
1003                     "offset=%lu)\n", errno, fd, locktype,
1004                     afs_printable_uint32_lu(offset));
1005             } else {
1006                 Log("_VLockFd: conflicting lock held on fd %d, offset %lu by "
1007                     "pid %ld (locktype=%d)\n", fd,
1008                     afs_printable_uint32_lu(offset), (long int)sf.l_pid,
1009                     locktype);
1010             }
1011             return EBUSY;
1012         }
1013         Log("_VLockFd: fcntl failed with error %d when trying to lock "
1014             "fd %d (locktype=%d, offset=%lu)\n", errno, fd, locktype,
1015             afs_printable_uint32_lu(offset));
1016         return EIO;
1017     }
1018
1019     return 0;
1020 }
1021
1022 /**
1023  * close a file descriptor used for file locking.
1024  *
1025  * @param[in] fd file descriptor to close
1026  */
1027 static_inline void
1028 _VCloseFd(int fd)
1029 {
1030     if (close(fd)) {
1031         Log("_VCloseFd: error %d closing fd %d\n",
1032             errno, fd);
1033     }
1034 }
1035
1036 /**
1037  * unlock a file offset in a file descriptor.
1038  *
1039  * @param[in] fd file descriptor to unlock
1040  * @param[in] offset offset to unlock
1041  */
1042 static_inline void
1043 _VUnlockFd(int fd, afs_uint32 offset)
1044 {
1045     struct flock sf;
1046
1047     sf.l_start = offset;
1048     sf.l_len = 1;
1049     sf.l_type = F_UNLCK;
1050     sf.l_whence = SEEK_SET;
1051
1052     if (fcntl(fd, F_SETLK, &sf)) {
1053         Log("_VUnlockFd: fcntl failed with error %d when trying to unlock "
1054             "fd %d\n", errno, fd);
1055     }
1056 }
1057 #endif /* !AFS_NT40_ENV */
1058
1059 /**
1060  * reinitialize a struct VLockFile.
1061  *
1062  * Use this to close the lock file (unlocking any locks in it), and effectively
1063  * restore lf to the state it was in when it was initialized. This is the same
1064  * as unlocking all of the locks on the file, without having to remember what
1065  * all of the locks were. Do not unlock previously held locks after calling
1066  * this.
1067  *
1068  * @param[in] lf  struct VLockFile to reinit
1069  *
1070  * @pre nobody is waiting for a lock on this lockfile or otherwise using
1071  *      this lockfile at all
1072  */
1073 void
1074 VLockFileReinit(struct VLockFile *lf)
1075 {
1076     MUTEX_ENTER(&lf->mutex);
1077
1078     if (lf->fd != INVALID_FD) {
1079         _VCloseFd(lf->fd);
1080         lf->fd = INVALID_FD;
1081     }
1082
1083     lf->refcount = 0;
1084
1085     MUTEX_EXIT(&lf->mutex);
1086 }
1087
1088 /**
1089  * lock a file on disk for the process.
1090  *
1091  * @param[in] lf       the struct VLockFile representing the file to lock
1092  * @param[in] offset   the offset in the file to lock
1093  * @param[in] locktype READ_LOCK or WRITE_LOCK
1094  * @param[in] nonblock 0 to wait for conflicting locks to clear before
1095  *                     obtaining the lock; 1 to fail immediately if a
1096  *                     conflicting lock is held by someone else
1097  *
1098  * @return operation status
1099  *  @retval 0 success
1100  *  @retval EBUSY someone else is holding a conflicting lock and nonblock=1 was
1101  *                specified
1102  *  @retval EIO   error acquiring file lock
1103  *
1104  * @note DAFS only
1105  *
1106  * @note do not try to lock/unlock the same offset in the same file from
1107  * different threads; use VGetDiskLock to protect threads from each other in
1108  * addition to other processes
1109  */
1110 int
1111 VLockFileLock(struct VLockFile *lf, afs_uint32 offset, int locktype, int nonblock)
1112 {
1113     int code;
1114
1115     osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
1116
1117     MUTEX_ENTER(&lf->mutex);
1118
1119     if (lf->fd == INVALID_FD) {
1120         lf->fd = _VOpenPath(lf->path);
1121         if (lf->fd == INVALID_FD) {
1122             MUTEX_EXIT(&lf->mutex);
1123             return EIO;
1124         }
1125     }
1126
1127     lf->refcount++;
1128
1129     MUTEX_EXIT(&lf->mutex);
1130
1131     code = _VLockFd(lf->fd, offset, locktype, nonblock);
1132
1133     if (code) {
1134         MUTEX_ENTER(&lf->mutex);
1135         if (--lf->refcount < 1) {
1136             _VCloseFd(lf->fd);
1137             lf->fd = INVALID_FD;
1138         }
1139         MUTEX_EXIT(&lf->mutex);
1140     }
1141
1142     return code;
1143 }
1144
1145 void
1146 VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset)
1147 {
1148     MUTEX_ENTER(&lf->mutex);
1149
1150     osi_Assert(lf->fd != INVALID_FD);
1151
1152     if (--lf->refcount < 1) {
1153         _VCloseFd(lf->fd);
1154         lf->fd = INVALID_FD;
1155     } else {
1156         _VUnlockFd(lf->fd, offset);
1157     }
1158
1159     MUTEX_EXIT(&lf->mutex);
1160 }
1161
1162 #ifdef AFS_DEMAND_ATTACH_FS
1163
1164 /**
1165  * initialize a struct VDiskLock.
1166  *
1167  * @param[in] dl struct VDiskLock to initialize
1168  * @param[in] lf the struct VLockFile to associate with this disk lock
1169  */
1170 void
1171 VDiskLockInit(struct VDiskLock *dl, struct VLockFile *lf, afs_uint32 offset)
1172 {
1173     osi_Assert(lf);
1174     memset(dl, 0, sizeof(*dl));
1175     Lock_Init(&dl->rwlock);
1176     MUTEX_INIT(&dl->mutex, "disklock", MUTEX_DEFAULT, 0);
1177     CV_INIT(&dl->cv, "disklock cv", CV_DEFAULT, 0);
1178     dl->lockfile = lf;
1179     dl->offset = offset;
1180 }
1181
1182 /**
1183  * acquire a lock on a file on local disk.
1184  *
1185  * @param[in] dl       the VDiskLock structure corresponding to the file on disk
1186  * @param[in] locktype READ_LOCK if you want a read lock, or WRITE_LOCK if
1187  *                     you want a write lock
1188  * @param[in] nonblock 0 to wait for conflicting locks to clear before
1189  *                     obtaining the lock; 1 to fail immediately if a
1190  *                     conflicting lock is held by someone else
1191  *
1192  * @return operation status
1193  *  @retval 0 success
1194  *  @retval EBUSY someone else is holding a conflicting lock and nonblock=1 was
1195  *                specified
1196  *  @retval EIO   error acquiring file lock
1197  *
1198  * @note DAFS only
1199  *
1200  * @note while normal fcntl-y locks on Unix systems generally only work per-
1201  * process, this interface also deals with locks between threads in the
1202  * process in addition to different processes acquiring the lock
1203  */
1204 int
1205 VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
1206 {
1207     int code = 0;
1208     osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
1209
1210     if (nonblock) {
1211         if (locktype == READ_LOCK) {
1212             ObtainReadLockNoBlock(&dl->rwlock, code);
1213         } else {
1214             ObtainWriteLockNoBlock(&dl->rwlock, code);
1215         }
1216
1217         if (code) {
1218             return EBUSY;
1219         }
1220
1221     } else if (locktype == READ_LOCK) {
1222         ObtainReadLock(&dl->rwlock);
1223     } else {
1224         ObtainWriteLock(&dl->rwlock);
1225     }
1226
1227     MUTEX_ENTER(&dl->mutex);
1228
1229     if ((dl->flags & VDISKLOCK_ACQUIRING)) {
1230         /* Some other thread is waiting to acquire an fs lock. If nonblock=1,
1231          * we can return immediately, since we know we'll need to wait to
1232          * acquire. Otherwise, wait for the other thread to finish acquiring
1233          * the fs lock */
1234         if (nonblock) {
1235             code = EBUSY;
1236         } else {
1237             while ((dl->flags & VDISKLOCK_ACQUIRING)) {
1238                 CV_WAIT(&dl->cv, &dl->mutex);
1239             }
1240         }
1241     }
1242
1243     if (code == 0 && !(dl->flags & VDISKLOCK_ACQUIRED)) {
1244         /* no other thread holds the lock on the actual file; so grab one */
1245
1246         /* first try, don't block on the lock to see if we can get it without
1247          * waiting */
1248         code = VLockFileLock(dl->lockfile, dl->offset, locktype, 1);
1249
1250         if (code == EBUSY && !nonblock) {
1251
1252             /* mark that we are waiting on the fs lock */
1253             dl->flags |= VDISKLOCK_ACQUIRING;
1254
1255             MUTEX_EXIT(&dl->mutex);
1256             code = VLockFileLock(dl->lockfile, dl->offset, locktype, nonblock);
1257             MUTEX_ENTER(&dl->mutex);
1258
1259             dl->flags &= ~VDISKLOCK_ACQUIRING;
1260
1261             if (code == 0) {
1262                 dl->flags |= VDISKLOCK_ACQUIRED;
1263             }
1264
1265             CV_BROADCAST(&dl->cv);
1266         }
1267     }
1268
1269     if (code) {
1270         if (locktype == READ_LOCK) {
1271             ReleaseReadLock(&dl->rwlock);
1272         } else {
1273             ReleaseWriteLock(&dl->rwlock);
1274         }
1275     } else {
1276         /* successfully got the lock, so inc the number of unlocks we need
1277          * to do before we can unlock the actual file */
1278         ++dl->lockers;
1279     }
1280
1281     MUTEX_EXIT(&dl->mutex);
1282
1283     return code;
1284 }
1285
1286 /**
1287  * release a lock on a file on local disk.
1288  *
1289  * @param[in] dl the struct VDiskLock to release
1290  * @param[in] locktype READ_LOCK if you are unlocking a read lock, or
1291  *                     WRITE_LOCK if you are unlocking a write lock
1292  *
1293  * @return operation status
1294  *  @retval 0 success
1295  */
1296 void
1297 VReleaseDiskLock(struct VDiskLock *dl, int locktype)
1298 {
1299     osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
1300
1301     MUTEX_ENTER(&dl->mutex);
1302     osi_Assert(dl->lockers > 0);
1303
1304     if (--dl->lockers < 1) {
1305         /* no threads are holding this lock anymore, so we can release the
1306          * actual disk lock */
1307         VLockFileUnlock(dl->lockfile, dl->offset);
1308         dl->flags &= ~VDISKLOCK_ACQUIRED;
1309     }
1310
1311     MUTEX_EXIT(&dl->mutex);
1312
1313     if (locktype == READ_LOCK) {
1314         ReleaseReadLock(&dl->rwlock);
1315     } else {
1316         ReleaseWriteLock(&dl->rwlock);
1317     }
1318 }
1319
1320 #endif /* AFS_DEMAND_ATTACH_FS */