support-namei-fileserver-on-solaris8-20010305
[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
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 }