src/vol/partition.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 #ifndef lint
  11 #endif
  12 /*
  13         System:         VICE-TWO
  14         Module:         partition.c
  15         Institution:    The Information Technology Center, Carnegie-Mellon University
  16
  17  */
  18
  19 #include <afs/param.h>
  20 #include <ctype.h>
  21 #ifdef AFS_NT40_ENV
  22 #include <windows.h>
  23 #include <winbase.h>
  24 #include <winioctl.h>
  25 #else
  26 #include <sys/param.h>
  27
  28 #if AFS_HAVE_STATVFS
  29 #include <sys/statvfs.h>
  30 #endif /* AFS_HAVE_STATVFS */
  31
  32 #if !defined(AFS_SGI_ENV)
  33 #ifdef  AFS_OSF_ENV
  34 #include <sys/mount.h>
  35 #include <ufs/fs.h>
  36 #else   /* AFS_OSF_ENV */
  37 #ifdef AFS_VFSINCL_ENV
  38 #define VFS
  39 #ifdef  AFS_SUN5_ENV
  40 #include <sys/fs/ufs_fs.h>
  41 #else
  42 #include <ufs/fs.h>
  43 #endif
  44 #else /* AFS_VFSINCL_ENV */
  45 #if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV)
  46 #include <sys/fs.h>
  47 #endif
  48 #endif /* AFS_VFSINCL_ENV */
  49 #endif  /* AFS_OSF_ENV */
  50 #include <sys/errno.h>
  51 #include <sys/stat.h>
  52 #include <stdio.h>
  53 #include <sys/file.h>
  54 #ifdef  AFS_AIX_ENV
  55 #include <sys/vfs.h>
  56 #include <sys/lockf.h>
  57 #else
  58 #ifdef  AFS_HPUX_ENV
  59 #include <sys/vfs.h>
  60 #include <unistd.h>
  61 #include <fcntl.h>
  62 #include <checklist.h>
  63 #else
  64 #if     defined(AFS_SUN_ENV)
  65 #include <sys/vfs.h>
  66 #endif
  67 #ifdef AFS_SUN5_ENV
  68 #include <unistd.h>
  69 #include <sys/mnttab.h>
  70 #include <sys/mntent.h>
  71 #else
  72 #ifdef AFS_LINUX22_ENV
  73 #include <mntent.h>
  74 #include <sys/statfs.h>
  75 #else
  76 #include <fstab.h>
  77 #endif
  78 #endif
  79 #endif
  80 #endif
  81 #endif  /* AFS_SGI_ENV */
  82 #endif /* AFS_NT40_ENV */
  83 #if defined(AFS_SGI_ENV)
  84 #include <sys/errno.h>
  85 #include <sys/stat.h>
  86 #include <stdio.h>
  87 #include <sys/file.h>
  88 #include <mntent.h>
  89 #endif
  90
  91 #include <rx/xdr.h>
  92 #include <afs/afsint.h>
  93 #include "nfs.h"
  94 #include <afs/errors.h>
  95 #include "lock.h"
  96 #include "lwp.h"
  97 #include <afs/afssyscalls.h>
  98 #include "ihandle.h"
  99 #ifdef AFS_NAMEI_ENV
 100 #ifdef AFS_NT40_ENV
 101 #include "ntops.h"
 102 #else
 103 #include "namei_ops.h"
 104 #endif
 105 #endif /* AFS_NAMEI_ENV */
 106 #include "vnode.h"
 107 #include "volume.h"
 108 #include "partition.h"
 109 #ifdef AFS_PTHREAD_ENV
 110 #include <assert.h>
 111 #else /* AFS_PTHREAD_ENV */
 112 #include <afs/assert.h>
 113 #endif /* AFS_PTHREAD_ENV */
 114
 115 #if defined(AFS_HPUX_ENV)
 116 #include <sys/types.h>
 117 #include <sys/privgrp.h>
 118 #endif /* defined(AFS_HPUX_ENV) */
 119
 120 #ifdef AFS_AIX42_ENV
 121 #include <jfs/filsys.h>
 122 #endif
 123
 124 int aixlow_water = 8;   /* default 8% */
 125 struct DiskPartition *DiskPartitionList;
 126
 127 #ifdef AFS_SGI_XFS_IOPS_ENV
 128 /* Verify that the on disk XFS inodes on the partition are large enough to
 129  * hold the AFS attribute. Returns -1 if the attribute can't be set or is
 130  * too small to fit in the inode. Returns 0 if the attribute does fit in
 131  * the XFS inode.
 132  */
 133 #include <afs/xfsattrs.h>
 134 static int VerifyXFSInodeSize(char *part, char *fstype)
 135 {
 136     afs_xfs_attr_t junk;
 137     int length = SIZEOF_XFS_ATTR_T;
 138     int fd = 0;
 139     int code = -1;
 140     struct fsxattr fsx;
 141
 142     if (strcmp("xfs", fstype))
 143         return 0;
 144
 145     if (attr_set(part, AFS_XFS_ATTR, &junk, length, ATTR_ROOT) == 0) {
 146         if (((fd=open(part, O_RDONLY, 0)) != -1)
 147             && (fcntl(fd, F_FSGETXATTRA, &fsx) == 0)) {
 148
 149             if (fsx.fsx_nextents) {
 150                 Log("Partition %s: XFS inodes too small, exiting.\n", part);
 151                 Log("Run xfs_size_check utility and remake partitions.\n");
 152             }
 153             else
 154                 code = 0;
 155         }
 156
 157         if (fd > 0)
 158             close(fd);
 159         (void) attr_remove(part, AFS_XFS_ATTR, ATTR_ROOT);
 160     }
 161     return code;
 162 }
 163 #endif
 164
 165
 166 static void VInitPartition_r(char *path, char *devname, Device dev)
 167 {
 168     struct DiskPartition *dp, *op;
 169     dp = (struct DiskPartition *) malloc(sizeof (struct DiskPartition));
 170     /* Add it to the end, to preserve order when we print statistics */
 171     for (op = DiskPartitionList; op; op = op->next) {
 172         if (!op->next)
 173             break;
 174     }
 175     if (op)
 176         op->next = dp;
 177     else
 178         DiskPartitionList = dp;
 179     dp->next = 0;
 180     strcpy(dp->name, path);
 181 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
 182 #ifdef AFS_SUN5_ENV
 183     strcpy(dp->devName, devname);
 184 #else /* AFS_SUN5_ENV */
 185     strcpy(dp->devName, path);
 186 #endif
 187     dp->device = volutil_GetPartitionID(path);
 188 #else
 189     strcpy(dp->devName, devname);
 190     dp->device = dev;
 191 #endif
 192     dp->lock_fd = -1;
 193     dp->flags = 0;
 194     dp->f_files = 1;    /* just a default value */
 195 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
 196     if (programType == fileServer)
 197         (void) namei_ViceREADME(VPartitionPath(dp));
 198 #endif
 199     VSetPartitionDiskUsage_r(dp);
 200 }
 201
 202 static void VInitPartition(char *path, char *devname, Device dev)
 203 {
 204     VOL_LOCK
 205     VInitPartition_r(path, devname, dev);
 206     VOL_UNLOCK
 207 }
 208
 209 #ifndef AFS_NT40_ENV
 210 /* VAttachPartitions() finds the vice partitions on this server. Calls
 211  * VCheckPartition() to do some basic checks on the partition. If the partition
 212  * is a valid vice partition, VCheckPartition will add it to the DiskPartition
 213  * list.
 214  * Returns the number of errors returned by VCheckPartition. An error in
 215  * VCheckPartition means that partition is a valid vice partition but the
 216  * fileserver should not start because of the error found on that partition.
 217  *
 218  * AFS_NAMEI_ENV
 219  * No specific user space file system checks, since we don't know what
 220  * is being used for vice partitions.
 221  *
 222  * Use partition name as devname.
 223  */
 224 int VCheckPartition(part, devname)
 225      char *part;
 226      char *devname;
 227 {
 228     struct stat status;
 229
 230     /* Only keep track of "/vicepx" partitions since it can get hairy
 231      * when NFS mounts are involved.. */
 232     if (strncmp(part, VICE_PARTITION_PREFIX, VICE_PREFIX_SIZE)) {
 233         return 0;
 234     }
 235     if (stat(part, &status) < 0) {
 236         Log("VInitVnodes: Couldn't find file system %s; ignored\n", part);
 237         return 0;
 238     }
 239
 240 #ifndef AFS_AIX32_ENV
 241     if (programType == fileServer) {
 242         char salvpath[MAXPATHLEN];
 243         strcpy(salvpath, part);
 244         strcat(salvpath, "/FORCESALVAGE");
 245         if (stat(salvpath, &status) == 0) {
 246             Log("VInitVnodes: Found %s; aborting\n", salvpath);
 247             return -1;
 248         }
 249     }
 250 #endif
 251
 252 #ifdef AFS_SGI_XFS_IOPS_ENV
 253     if (VerifyXFSInodeSize(part, status.st_fstype) < 0)
 254         return -1;
 255 #endif
 256
 257 #ifdef AFS_DUX40_ENV
 258     if (status.st_ino != ROOTINO) {
 259         Log("%s is not a mounted file system; ignored.\n", part);
 260         return 0;
 261     }
 262 #endif
 263
 264     VInitPartition(part, devname, status.st_dev);
 265
 266     return 0;
 267 }
 268 #endif /* AFS_NT40_ENV */
 269
 270 #ifdef AFS_SUN5_ENV
 271 int VAttachPartitions(void)
 272 {
 273     int errors = 0;
 274     struct mnttab mnt;
 275     FILE *mntfile;
 276
 277     if (!(mntfile = fopen(MNTTAB, "r"))) {
 278         Log("Can't open %s\n", MNTTAB);
 279         perror(MNTTAB);
 280         exit(-1);
 281     }
 282     while (!getmntent(mntfile, &mnt)) {
 283         /* Ignore non ufs or non read/write partitions */
 284         if ((strcmp(mnt.mnt_fstype, "ufs") !=0) ||
 285             (strncmp(mnt.mnt_mntopts, "ro,ignore",9) ==0))
 286             continue;
 287
 288         if (VCheckPartition(mnt.mnt_mountp, mnt.mnt_special) < 0 )
 289             errors ++;
 290     }
 291
 292    (void) fclose(mntfile);
 293
 294     return errors ;
 295 }
 296
 297 #endif /* AFS_SUN5_ENV */
 298 #if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)) || defined(AFS_HPUX_ENV)
 299 int VAttachPartitions(void)
 300 {
 301     int errors = 0;
 302     FILE *mfd;
 303     struct mntent *mntent;
 304
 305     if ((mfd = setmntent(MOUNTED, "r")) == NULL) {
 306         Log("Problems in getting mount entries(setmntent)\n");
 307         exit(-1);
 308     }
 309     while (mntent = getmntent(mfd)) {
 310         if (!hasmntopt(mntent, MNTOPT_RW)) continue;
 311
 312         if (VCheckPartition(mntent->mnt_dir, mntent->mnt_fsname) < 0 )
 313             errors ++;
 314     }
 315
 316     endmntent(mfd);
 317
 318     return errors ;
 319 }
 320 #endif
 321 #ifdef AFS_AIX_ENV
 322 /*
 323  * (This function was grabbed from df.c)
 324  */
 325 int
 326 getmount(vmountpp)
 327 register struct vmount  **vmountpp;     /* place to tell where buffer is */
 328 {
 329         int                     size;
 330         register struct vmount  *vm;
 331         int                     nmounts;
 332
 333         /* set initial size of mntctl buffer to a MAGIC NUMBER */
 334         size = BUFSIZ;
 335
 336         /* try the operation until ok or a fatal error */
 337         while (1) {
 338                 if ((vm = (struct vmount *)malloc(size)) == NULL) {
 339                         /* failed getting memory for mount status buf */
 340                         perror("FATAL ERROR: get_stat malloc failed\n");
 341                         exit(-1);
 342                 }
 343
 344                 /*
 345                  * perform the QUERY mntctl - if it returns > 0, that is the
 346                  * number of vmount structures in the buffer.  If it returns
 347                  * -1, an error occured.  If it returned 0, then look in
 348                  * first word of buffer for needed size.
 349                  */
 350                 if ((nmounts = mntctl(MCTL_QUERY, size, (caddr_t)vm)) > 0) {
 351                         /* OK, got it, now return */
 352                         *vmountpp = vm;
 353                         return(nmounts);
 354
 355                 } else if (nmounts == 0) {
 356                         /* the buffer wasn't big enough .... */
 357                         /* .... get required buffer size */
 358                         size = *(int *)vm;
 359                         free(vm);
 360
 361                 } else {
 362                         /* some other kind of error occurred */
 363                         free(vm);
 364                         return(-1);
 365                 }
 366         }
 367 }
 368
 369 int VAttachPartitions(void)
 370 {
 371     int errors = 0;
 372     int nmounts;
 373     struct vmount *vmountp;
 374
 375     if ((nmounts = getmount(&vmountp)) <= 0)    {
 376         Log("Problems in getting # of mount entries(getmount)\n");
 377         exit(-1);
 378     }
 379     for (; nmounts; nmounts--,
 380          vmountp = (struct vmount *)((int)vmountp + vmountp->vmt_length)) {
 381         char *part = vmt2dataptr(vmountp, VMT_STUB);
 382
 383         if (vmountp->vmt_flags & (MNT_READONLY|MNT_REMOVABLE|MNT_REMOTE))
 384             continue; /* Ignore any "special" partitions */
 385
 386 #ifdef AFS_AIX42_ENV
 387         {
 388             struct superblock fs;
 389             /* The Log statements are non-sequiters in the SalvageLog and don't
 390              * even appear in the VolserLog, so restrict them to the FileLog.
 391              */
 392             if (ReadSuper(&fs, vmt2dataptr(vmountp, VMT_OBJECT))<0) {
 393                 if (programType == fileServer)
 394                     Log("Can't read superblock for %s, ignoring it.\n", part);
 395                 continue;
 396             }
 397             if (IsBigFilesFileSystem(&fs)) {
 398                 if (programType == fileServer)
 399                     Log("%s is a big files filesystem, ignoring it.\n", part);
 400                 continue;
 401             }
 402         }
 403 #endif
 404
 405         if (VCheckPartition(part, vmt2dataptr(vmountp, VMT_OBJECT)) < 0 )
 406             errors ++;
 407     }
 408     return errors ;
 409
 410 }
 411 #endif
 412 #ifdef AFS_DUX40_ENV
 413 int VAttachPartitions(void)
 414 {
 415     int errors = 0;
 416     struct fstab *fsent;
 417
 418     if (setfsent() < 0) {
 419         Log("Error listing filesystems.\n");
 420         exit(-1);
 421     }
 422
 423     while (fsent = getfsent()) {
 424         if (strcmp(fsent->fs_type, "rw") != 0) continue;
 425
 426         if (VCheckPartition(fsent->fs_file, fsent->fs_spec) < 0 )
 427             errors ++;
 428     }
 429     endfsent();
 430
 431     return errors ;
 432 }
 433 #endif
 434
 435 #ifdef AFS_NT40_ENV
 436 #include <string.h>
 437 #include <sys/stat.h>
 438 /* VValidVPTEntry
 439  *
 440  * validate names in vptab.
 441  *
 442  * Return value:
 443  * 1 valid entry
 444  * 0 invalid entry
 445  */
 446
 447 int VValidVPTEntry(struct vptab *vpe)
 448 {
 449     int len = strlen(vpe->vp_name);
 450     int i;
 451
 452     if (len < VICE_PREFIX_SIZE+1 || len > VICE_PREFIX_SIZE + 2)
 453         return 0;
 454     if (strncmp(vpe->vp_name, VICE_PARTITION_PREFIX, VICE_PREFIX_SIZE))
 455         return 0;
 456
 457     for (i=VICE_PREFIX_SIZE; i<len; i++) {
 458         if (vpe->vp_name[i] < 'a' || vpe->vp_name[i] > 'z') {
 459             Log("Invalid partition name %s in registry, ignoring it.\n",
 460                 vpe->vp_name);
 461             return 0;
 462         }
 463     }
 464     if (len == VICE_PREFIX_SIZE + 2) {
 465         i = (int)(vpe->vp_name[VICE_PREFIX_SIZE]-'a') * 26 +
 466             (int)(vpe->vp_name[VICE_PREFIX_SIZE+1]-'a') ;
 467         if (i>255) {
 468             Log("Invalid partition name %s in registry, ignoring it.\n",
 469                 vpe->vp_name);
 470             return 0;
 471         }
 472     }
 473
 474     len = strlen(vpe->vp_dev);
 475     if (len != 2 || vpe->vp_dev[1] != ':'  || vpe->vp_dev[0] < 'A' ||
 476         vpe->vp_dev[0] > 'Z') {
 477         Log("Invalid device name %s in registry, ignoring it.\n",
 478             vpe->vp_dev);
 479         return 0;
 480     }
 481
 482     return 1;
 483 }
 484
 485 int VCheckPartition(char *partName)
 486 {
 487     char volRoot[4];
 488     char volFsType[64];
 489     DWORD dwDummy;
 490     int err;
 491
 492     /* partName is presumed to be of the form "X:" */
 493     (void) sprintf(volRoot, "%c:\\", *partName);
 494
 495     if (!GetVolumeInformation(volRoot,    /* volume root directory */
 496                               NULL,       /* volume name buffer */
 497                               0,          /* volume name size */
 498                               NULL,       /* volume serial number */
 499                               &dwDummy,   /* max component length */
 500                               &dwDummy,   /* file system flags */
 501                               volFsType,  /* file system name */
 502                               sizeof(volFsType))) {
 503         err = GetLastError();
 504         Log("VCheckPartition: Failed to get partition information for %s, ignoring it.\n",
 505             partName);
 506         return -1;
 507     }
 508
 509     if (strcmp(volFsType, "NTFS")) {
 510         Log("VCheckPartition: Partition %s is not an NTFS partition, ignoring it.\n", partName);
 511         return -1;
 512     }
 513
 514     return 0;
 515 }
 516
 517
 518 int VAttachPartitions(void)
 519 {
 520     struct DiskPartition *partP, *prevP, *nextP;
 521     struct vpt_iter iter;
 522     struct vptab entry;
 523
 524     if (vpt_Start(&iter)<0) {
 525         Log("No partitions to attach.\n");
 526         return 0;
 527     }
 528
 529     while (0==vpt_NextEntry(&iter, &entry)) {
 530         if (!VValidVPTEntry(&entry)) {
 531             continue;
 532         }
 533
 534         /* This test for duplicates relies on the fact that the method
 535          * of storing the partition names in the NT registry means the same
 536          * partition name will never appear twice in the list.
 537          */
 538         for (partP = DiskPartitionList; partP; partP = partP->next) {
 539             if (*partP->devName == *entry.vp_dev) {
 540                 Log("Same drive (%s) used for both partition %s and partition %s, ignoring both.\n", entry.vp_dev, partP->name, entry.vp_name);
 541                 partP->flags = PART_DUPLICATE;
 542                 break; /* Only one entry will ever be in this list. */
 543             }
 544         }
 545         if (partP) continue; /* found a duplicate */
 546
 547         if (VCheckPartition(entry.vp_dev)<0)
 548             continue;
 549         /* This test allows for manually inserting the FORCESALVAGE flag
 550          * and thereby invoking the salvager. scandisk obviously won't be
 551          * doing this for us.
 552          */
 553         if (programType == fileServer) {
 554             struct stat status;
 555             char salvpath[MAXPATHLEN];
 556             strcpy(salvpath, entry.vp_dev);
 557             strcat(salvpath, "\\FORCESALVAGE");
 558             if (stat(salvpath, &status) == 0) {
 559                 Log("VAttachPartitions: Found %s; aborting\n", salvpath);
 560                 exit(1);
 561             }
 562         }
 563         VInitPartition(entry.vp_name, entry.vp_dev, *entry.vp_dev - 'A');
 564     }
 565     vpt_Finish(&iter);
 566
 567     /* Run through partition list and clear out the dupes. */
 568     prevP = nextP = NULL;
 569     for (partP = DiskPartitionList; partP; partP = nextP) {
 570         nextP = partP->next;
 571         if (partP->flags == PART_DUPLICATE) {
 572             if (prevP)
 573                 prevP->next = partP->next;
 574             else
 575                 DiskPartitionList = partP->next;
 576             free(partP);
 577         }
 578         else
 579             prevP = partP;
 580     }
 581
 582     return 0;
 583 }
 584 #endif
 585
 586 #ifdef AFS_LINUX22_ENV
 587 int VAttachPartitions(void)
 588 {
 589     int errors = 0;
 590     FILE *mfd;
 591     struct mntent *mntent;
 592
 593     if ((mfd = setmntent("/proc/mounts", "r")) == NULL) {
 594         if ((mfd = setmntent("/etc/mtab", "r")) == NULL) {
 595             Log("Problems in getting mount entries(setmntent)\n");
 596             exit(-1);
 597         }
 598     }
 599     while (mntent = getmntent(mfd)) {
 600         if (VCheckPartition(mntent->mnt_dir, mntent->mnt_fsname) < 0 )
 601             errors ++;
 602     }
 603     endmntent(mfd);
 604
 605     return errors ;
 606 }
 607 #endif /* AFS_LINUX22_ENV */
 608
 609 /* This routine is to be called whenever the actual name of the partition
 610  * is required. The canonical name is still in part->name.
 611  */
 612 char * VPartitionPath(struct DiskPartition *part)
 613 {
 614 #ifdef AFS_NT40_ENV
 615     return part->devName;
 616 #else
 617     return part->name;
 618 #endif
 619 }
 620
 621 /* get partition structure, abortp tells us if we should abort on failure */
 622 struct DiskPartition *VGetPartition_r(char *name, int abortp)
 623 {
 624     register struct DiskPartition *dp;
 625     for (dp = DiskPartitionList; dp; dp = dp->next) {
 626         if (strcmp(dp->name, name) == 0)
 627             break;
 628     }
 629     if (abortp)
 630         assert(dp != NULL);
 631     return dp;
 632 }
 633
 634 struct DiskPartition *VGetPartition(char *name, int abortp)
 635 {
 636     struct DiskPartition *retVal;
 637     VOL_LOCK
 638     retVal = VGetPartition_r(name, abortp);
 639     VOL_UNLOCK
 640     return retVal;
 641 }
 642
 643 #ifdef AFS_NT40_ENV
 644 void VSetPartitionDiskUsage_r(register struct DiskPartition *dp)
 645 {
 646     ULARGE_INTEGER free_user, total, free_total;
 647     int ufree, tot, tfree;
 648
 649     if (!GetDiskFreeSpaceEx(VPartitionPath(dp), &free_user, &total,
 650                             &free_total)) {
 651         printf("Failed to get disk space info for %s, error = %d\n",
 652                dp->name, GetLastError());
 653         return;
 654     }
 655
 656     /* Convert to 1K units. */
 657     ufree = (int) Int64ShraMod32(free_user.QuadPart, 10);
 658     tot = (int) Int64ShraMod32(total.QuadPart, 10);
 659     tfree = (int) Int64ShraMod32(free_total.QuadPart, 10);
 660
 661     dp->minFree = tfree - ufree; /* only used in VPrintDiskStats_r */
 662     dp->totalUsable = tot;
 663     dp->free = tfree;
 664 }
 665
 666 #else
 667 void VSetPartitionDiskUsage_r(register struct DiskPartition *dp)
 668 {
 669     extern int errno;
 670     int fd, totalblks, free, used, availblks, bsize, code;
 671     int reserved;
 672 #if AFS_HAVE_STATVFS
 673     struct statvfs statbuf;
 674 #else
 675     struct statfs statbuf;
 676 #endif
 677
 678     if (dp->flags & PART_DONTUPDATE)
 679         return;
 680     /* Note:  we don't bother syncing because it's only an estimate, update
 681        is syncing every 30 seconds anyway, we only have to keep the disk
 682        approximately 10% from full--you just can't get the stuff in from
 683        the net fast enough to worry */
 684 #if AFS_HAVE_STATVFS
 685     code = statvfs(dp->name, &statbuf);
 686 #else
 687     code = statfs(dp->name, &statbuf);
 688 #endif
 689     if (code < 0) {
 690         Log("statfs of %s failed in VSetPartitionDiskUsage (errno = %d)\n", dp->name, errno);
 691         return;
 692     }
 693     if (statbuf.f_blocks == -1) {   /* Undefined; skip stats.. */
 694         Log("statfs of %s failed in VSetPartitionDiskUsage\n", dp->name);
 695         return;
 696     }
 697     totalblks = statbuf.f_blocks;
 698     free = statbuf.f_bfree;
 699     reserved = free - statbuf.f_bavail;
 700 #if AFS_HAVE_STATVFS
 701     bsize = statbuf.f_frsize;
 702 #else
 703     bsize = statbuf.f_bsize;
 704 #endif
 705     availblks = totalblks - reserved;
 706     dp->f_files = statbuf.f_files;      /* max # of files in partition */
 707
 708     /* Now free and totalblks are in fragment units, but we want them in
 709      * 1K units.
 710      */
 711     if (bsize >= 1024) {
 712         free *= (bsize/1024);
 713         totalblks *= (bsize / 1024);
 714         availblks *= (bsize / 1024 );
 715         reserved *= (bsize / 1024 );
 716     }
 717     else {
 718         free /= (1024/bsize);
 719         totalblks /= (1024/bsize);
 720         availblks /= (1024/bsize);
 721         reserved /= (1024/bsize);
 722     }
 723     /* now compute remaining figures */
 724     used = totalblks - free;
 725
 726     dp->minFree = reserved; /* only used in VPrintDiskStats_r */
 727     dp->totalUsable = availblks;
 728     dp->free = availblks - used; /* this is exactly f_bavail */
 729 }
 730 #endif /* AFS_NT40_ENV */
 731
 732 void VSetPartitionDiskUsage(register struct DiskPartition *dp)
 733 {
 734     VOL_LOCK
 735     VSetPartitionDiskUsage_r(dp);
 736     VOL_UNLOCK
 737 }
 738
 739 void VResetDiskUsage_r(void)
 740 {
 741     struct DiskPartition *dp;
 742     for (dp = DiskPartitionList; dp; dp = dp->next) {
 743         VSetPartitionDiskUsage_r(dp);
 744 #ifndef AFS_PTHREAD_ENV
 745         IOMGR_Poll();
 746 #endif /* !AFS_PTHREAD_ENV */
 747     }
 748 }
 749
 750 void VResetDiskUsage(void)
 751 {
 752     VOL_LOCK
 753     VResetDiskUsage_r();
 754     VOL_UNLOCK
 755 }
 756
 757 void VAdjustDiskUsage_r(Error *ec, Volume *vp, afs_int32 blocks, afs_int32 checkBlocks)
 758 {
 759     afs_int32 rem, minavail;
 760     *ec = 0;
 761     /* why blocks instead of checkBlocks in the check below?  Otherwise, any check
 762        for less than BlocksSpare would skip the error-checking path, and we
 763        could grow existing files forever, not just for another BlocksSpare
 764        blocks. */
 765     if (blocks > 0) {
 766 #ifdef  AFS_AIX32_ENV
 767         if ((rem = vp->partition->free - checkBlocks) <
 768             (minavail = (vp->partition->totalUsable * aixlow_water) / 100))
 769 #else
 770         if (vp->partition->free - checkBlocks < 0)
 771 #endif
 772             *ec = VDISKFULL;
 773         else if (V_maxquota(vp) && V_diskused(vp) + checkBlocks > V_maxquota(vp))
 774             *ec = VOVERQUOTA;
 775     }
 776     vp->partition->free -= blocks;
 777     V_diskused(vp) += blocks;
 778 }
 779
 780 void VAdjustDiskUsage(Error *ec, Volume *vp, afs_int32 blocks, afs_int32 checkBlocks)
 781 {
 782     VOL_LOCK
 783     VAdjustDiskUsage_r(ec, vp, blocks, checkBlocks);
 784     VOL_UNLOCK
 785 }
 786
 787 int VDiskUsage_r(Volume *vp, afs_int32 blocks)
 788 {
 789     afs_int32 rem, minavail;
 790     if (blocks > 0) {
 791 #ifdef  AFS_AIX32_ENV
 792         if ((rem = vp->partition->free - blocks) <
 793             (minavail = (vp->partition->totalUsable * aixlow_water) / 100))
 794 #else
 795         if (vp->partition->free - blocks < 0)
 796 #endif
 797             return(VDISKFULL);
 798     }
 799     vp->partition->free -= blocks;
 800     return 0;
 801 }
 802
 803 int VDiskUsage(Volume *vp, afs_int32 blocks)
 804 {
 805     int retVal;
 806     VOL_LOCK
 807     retVal = VDiskUsage_r(vp, blocks);
 808     VOL_UNLOCK
 809     return retVal;
 810 }
 811
 812 void VPrintDiskStats_r(void)
 813 {
 814     struct DiskPartition *dp;
 815     for (dp = DiskPartitionList; dp; dp = dp->next) {
 816         Log("Partition %s: %d available 1K blocks (minfree=%d), ",
 817             dp->name, dp->totalUsable, dp->minFree);
 818         if (dp->free < 0)
 819             Log("overallocated by %d blocks\n", -dp->free);
 820         else
 821             Log("%d free blocks\n", dp->free);
 822     }
 823 }
 824
 825 void VPrintDiskStats(void)
 826 {
 827     VOL_LOCK
 828     VPrintDiskStats_r();
 829     VOL_UNLOCK
 830 }
 831
 832 #ifdef AFS_NT40_ENV
 833 /* Need a separate lock file on NT, since NT only has mandatory file locks. */
 834 #define LOCKFILE "LOCKFILE"
 835 void VLockPartition_r(char *name)
 836 {
 837     struct DiskPartition *dp = VGetPartition_r(name, 0);
 838     OVERLAPPED lap;
 839
 840     if (!dp) return;
 841     if (dp->lock_fd == -1) {
 842         char path[64];
 843         int rc;
 844         (void) sprintf(path, "%s\\%s", VPartitionPath(dp), LOCKFILE);
 845         dp->lock_fd = (int)CreateFile(path, GENERIC_WRITE,
 846                                  FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 847                                  CREATE_ALWAYS, FILE_ATTRIBUTE_HIDDEN, NULL);
 848         assert (dp->lock_fd != (int)INVALID_HANDLE_VALUE);
 849
 850         memset((char*)&lap, 0, sizeof(lap));
 851         rc = LockFileEx((HANDLE)dp->lock_fd, LOCKFILE_EXCLUSIVE_LOCK,
 852                         0, 1, 0, &lap);
 853         assert(rc);
 854     }
 855 }
 856
 857 void VUnlockPartition_r(char *name)
 858 {
 859     register struct DiskPartition *dp = VGetPartition_r(name, 0);
 860     OVERLAPPED lap;
 861
 862     if (!dp) return;    /* no partition, will fail later */
 863     memset((char*)&lap, 0, sizeof(lap));
 864
 865     UnlockFileEx((HANDLE)dp->lock_fd, 0, 1, 0, &lap);
 866     CloseHandle((HANDLE)dp->lock_fd);
 867     dp->lock_fd = -1;
 868 }
 869 #else /* AFS_NT40_ENV */
 870
 871 #if defined(AFS_HPUX_ENV)
 872 #define BITS_PER_CHAR   (8)
 873 #define BITS(type)      (sizeof(type) * BITS_PER_CHAR)
 874
 875 #define LOCKRDONLY_OFFSET       ((PRIV_LOCKRDONLY - 1) / BITS(int))
 876 #endif /* defined(AFS_HPUX_ENV) */
 877
 878 void VLockPartition_r(char *name)
 879 {
 880     register struct DiskPartition *dp = VGetPartition_r(name, 0);
 881     char *partitionName;
 882     int retries, code;
 883     struct timeval pausing;
 884 #if defined(AFS_HPUX_ENV)
 885     int                 lockfRtn;
 886     struct privgrp_map  privGrpList[PRIV_MAXGRPS];
 887     unsigned int        *globalMask;
 888     int                 globalMaskIndex;
 889 #endif /* defined(AFS_HPUX_ENV) */
 890
 891     if (!dp) return;    /* no partition, will fail later */
 892     if (dp->lock_fd != -1) return;
 893
 894 #if    defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV)
 895     partitionName = dp->devName;
 896     code = O_RDWR;
 897 #else
 898     partitionName = dp->name;
 899     code = O_RDONLY;
 900 #endif
 901
 902     for (retries=25; retries; retries--) {
 903         dp->lock_fd = open(partitionName, code);
 904         if (dp->lock_fd != -1) break;
 905         pausing.tv_sec = 0;
 906         pausing.tv_usec = 500000;
 907         select(0, NULL, NULL, NULL, &pausing);
 908     }
 909     assert(retries != 0);
 910
 911 #if defined (AFS_HPUX_ENV)
 912
 913         assert(getprivgrp(privGrpList) == 0);
 914
 915         /*
 916          * In general, it will difficult and time-consuming ,if not impossible,
 917          * to try to find the privgroup to which this process belongs that has the
 918          * smallest membership, to minimise the security hole.  So, we use the privgrp
 919          * to which everybody belongs.
 920          */
 921         /* first, we have to find the global mask */
 922         for (globalMaskIndex = 0; globalMaskIndex < PRIV_MAXGRPS;
 923              globalMaskIndex++) {
 924           if (privGrpList[globalMaskIndex].priv_groupno == PRIV_GLOBAL) {
 925             globalMask = &(privGrpList[globalMaskIndex].
 926                            priv_mask[LOCKRDONLY_OFFSET]);
 927             break;
 928           }
 929         }
 930
 931         if (((*globalMask) & privmask(PRIV_LOCKRDONLY)) == 0) {
 932           /* allow everybody to set a lock on a read-only file descriptor */
 933           (*globalMask) |= privmask(PRIV_LOCKRDONLY);
 934           assert(setprivgrp(PRIV_GLOBAL,
 935                             privGrpList[globalMaskIndex].priv_mask) == 0);
 936
 937           lockfRtn = lockf(dp->lock_fd, F_LOCK, 0);
 938
 939           /* remove the privilege granted to everybody to lock a read-only fd */
 940           (*globalMask) &= ~(privmask(PRIV_LOCKRDONLY));
 941           assert(setprivgrp(PRIV_GLOBAL,
 942                             privGrpList[globalMaskIndex].priv_mask) == 0);
 943         }
 944         else {
 945           /* in this case, we should be able to do this with impunity, anyway */
 946           lockfRtn = lockf(dp->lock_fd, F_LOCK, 0);
 947         }
 948
 949         assert (lockfRtn != -1);
 950 #else
 951 #if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV)
 952         assert (lockf(dp->lock_fd, F_LOCK, 0) != -1);
 953 #else
 954         assert (flock(dp->lock_fd, LOCK_EX) == 0);
 955 #endif  /* defined(AFS_AIX_ENV) */
 956 #endif
 957 }
 958
 959 void VUnlockPartition_r(char *name)
 960 {
 961     register struct DiskPartition *dp = VGetPartition_r(name, 0);
 962     if (!dp) return;    /* no partition, will fail later */
 963     close(dp->lock_fd);
 964     dp->lock_fd = -1;
 965 }
 966
 967 #endif /* AFS_NT40_ENV */
 968
 969 void VLockPartition(char *name)
 970 {
 971     VOL_LOCK
 972     VLockPartition_r(name);
 973     VOL_UNLOCK
 974 }
 975
 976 void VUnlockPartition(char *name)
 977 {
 978     VOL_LOCK
 979     VUnlockPartition_r(name);
 980     VOL_UNLOCK
 981 }