e1eb72084f604818263bfbabd29f1eb99bc564cd
[openafs.git] / 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 }