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