2 * Copyright 2000, International Business Machines Corporation and others.
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
9 * Portions Copyright (c) 2003 Apple Computer, Inc.
10 * Portions Copyright (c) 2006 Sine Nomine Associates
17 Institution: The Information Technology Center, Carnegie-Mellon University
21 #include <afsconfig.h>
22 #include <afs/param.h>
34 #include <sys/param.h>
35 #include <sys/types.h>
37 #if AFS_HAVE_STATVFS || AFS_HAVE_STATVFS64
38 #include <sys/statvfs.h>
39 #endif /* AFS_HAVE_STATVFS */
40 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
41 #include <sys/mount.h>
44 #if !defined(AFS_SGI_ENV)
46 #include <sys/mount.h>
48 #else /* AFS_OSF_ENV */
49 #ifdef AFS_VFSINCL_ENV
52 #include <sys/fs/ufs_fs.h>
54 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
55 #include <ufs/ufs/dinode.h>
56 #include <ufs/ffs/fs.h>
61 #else /* AFS_VFSINCL_ENV */
62 #if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
65 #endif /* AFS_VFSINCL_ENV */
66 #endif /* AFS_OSF_ENV */
73 #include <sys/lockf.h>
79 #include <checklist.h>
81 #if defined(AFS_SUN_ENV)
89 #include <sys/mnttab.h>
90 #include <sys/mntent.h>
92 #ifdef AFS_LINUX22_ENV
94 #include <sys/statfs.h>
101 #endif /* AFS_SGI_ENV */
102 #endif /* AFS_NT40_ENV */
103 #if defined(AFS_SGI_ENV)
104 #include <sys/errno.h>
105 #include <sys/stat.h>
107 #include <sys/file.h>
112 #include <afs/afsint.h>
114 #include <afs/errors.h>
117 #include <afs/afssyscalls.h>
123 #include "namei_ops.h"
125 #endif /* AFS_NT40_ENV */
126 #endif /* AFS_NAMEI_ENV */
129 #include "partition.h"
130 #ifdef AFS_PTHREAD_ENV
132 #else /* AFS_PTHREAD_ENV */
133 #include <afs/assert.h>
134 #endif /* AFS_PTHREAD_ENV */
136 #if defined(AFS_HPUX_ENV)
137 #include <sys/types.h>
138 #include <sys/privgrp.h>
139 #endif /* defined(AFS_HPUX_ENV) */
142 #include <jfs/filsys.h>
147 #define afs_stat stat64
148 #define afs_open open64
149 #define afs_fopen fopen64
151 #if AFS_HAVE_STATVFS64
152 # define afs_statvfs statvfs64
154 # if AFS_HAVE_STATFS64
155 # define afs_statfs statfs64
157 # if AFS_HAVE_STATVFS
158 # define afs_statvfs statvfs
160 # define afs_statfs statfs
161 # endif /* !AFS_HAVE_STATVFS */
162 # endif /* !AFS_HAVE_STATFS64 */
163 #endif /* !AFS_HAVE_STATVFS64 */
164 #endif /* !AFS_NT40_ENV */
166 #else /* !O_LARGEFILE */
168 #define afs_stat stat
169 #define afs_open open
170 #define afs_fopen fopen
173 #define afs_statvfs statvfs
174 #else /* !AFS_HAVE_STATVFS */
175 #define afs_statfs statfs
176 #endif /* !AFS_HAVE_STATVFS */
177 #endif /* !AFS_NT40_ENV */
179 #endif /* !O_LARGEFILE */
181 /*@printflike@*/ extern void Log(const char *format, ...);
183 int aixlow_water = 8; /* default 8% */
184 struct DiskPartition *DiskPartitionList;
186 #ifdef AFS_DEMAND_ATTACH_FS
187 static struct DiskPartition *DiskPartitionTable[VOLMAXPARTS+1];
189 static struct DiskPartition * VLookupPartition_r(char * path);
190 static void AddPartitionToTable_r(struct DiskPartition *);
191 static void DeletePartitionFromTable_r(struct DiskPartition *);
192 #endif /* AFS_DEMAND_ATTACH_FS */
194 #ifdef AFS_SGI_XFS_IOPS_ENV
195 /* Verify that the on disk XFS inodes on the partition are large enough to
196 * hold the AFS attribute. Returns -1 if the attribute can't be set or is
197 * too small to fit in the inode. Returns 0 if the attribute does fit in
200 #include <afs/xfsattrs.h>
202 VerifyXFSInodeSize(char *part, char *fstype)
205 int length = SIZEOF_XFS_ATTR_T;
210 if (strcmp("xfs", fstype))
213 if (attr_set(part, AFS_XFS_ATTR, &junk, length, ATTR_ROOT) == 0) {
214 if (((fd = open(part, O_RDONLY, 0)) != -1)
215 && (fcntl(fd, F_FSGETXATTRA, &fsx) == 0)) {
217 if (fsx.fsx_nextents) {
218 Log("Partition %s: XFS inodes too small, exiting.\n", part);
219 Log("Run xfs_size_check utility and remake partitions.\n");
226 (void)attr_remove(part, AFS_XFS_ATTR, ATTR_ROOT);
230 #endif /* AFS_SGI_XFS_IOPS_ENV */
233 VInitPartitionPackage(void)
235 #ifdef AFS_DEMAND_ATTACH_ENV
236 memset(&DiskPartitionTable, 0, sizeof(DiskPartitionTable));
237 #endif /* AFS_DEMAND_ATTACH_ENV */
242 VInitPartition_r(char *path, char *devname, Device dev)
244 struct DiskPartition *dp, *op;
245 dp = (struct DiskPartition *)malloc(sizeof(struct DiskPartition));
246 /* Add it to the end, to preserve order when we print statistics */
247 for (op = DiskPartitionList; op; op = op->next) {
254 DiskPartitionList = dp;
256 dp->name = (char *)malloc(strlen(path) + 1);
257 strncpy(dp->name, path, strlen(path) + 1);
258 dp->index = volutil_GetPartitionID(path);
259 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
260 /* Create a lockfile for the partition, of the form /vicepa/Lock/vicepa */
261 dp->devName = (char *)malloc(2 * strlen(path) + 6);
262 strcpy(dp->devName, path);
263 strcat(dp->devName, "/");
264 strcat(dp->devName, "Lock");
265 mkdir(dp->devName, 0700);
266 strcat(dp->devName, path);
267 close(afs_open(dp->devName, O_RDWR | O_CREAT, 0600));
268 dp->device = dp->index;
270 dp->devName = (char *)malloc(strlen(devname) + 1);
271 strncpy(dp->devName, devname, strlen(devname) + 1);
276 dp->f_files = 1; /* just a default value */
277 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
278 if (programType == fileServer)
279 (void)namei_ViceREADME(VPartitionPath(dp));
281 VSetPartitionDiskUsage_r(dp);
282 #ifdef AFS_DEMAND_ATTACH_FS
283 AddPartitionToTable_r(dp);
284 queue_Init(&dp->vol_list);
285 assert(pthread_cond_init(&dp->vol_list.cv, NULL) == 0);
286 #endif /* AFS_DEMAND_ATTACH_FS */
290 VInitPartition(char *path, char *devname, Device dev)
293 VInitPartition_r(path, devname, dev);
298 /* VAttachPartitions() finds the vice partitions on this server. Calls
299 * VCheckPartition() to do some basic checks on the partition. If the partition
300 * is a valid vice partition, VCheckPartition will add it to the DiskPartition
302 * Returns the number of errors returned by VCheckPartition. An error in
303 * VCheckPartition means that partition is a valid vice partition but the
304 * fileserver should not start because of the error found on that partition.
307 * No specific user space file system checks, since we don't know what
308 * is being used for vice partitions.
310 * Use partition name as devname.
313 VCheckPartition(char *part, char *devname)
315 struct afs_stat status;
316 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_NT40_ENV)
317 char AFSIDatPath[MAXPATHLEN];
320 /* Only keep track of "/vicepx" partitions since it can get hairy
321 * when NFS mounts are involved.. */
322 if (strncmp(part, VICE_PARTITION_PREFIX, VICE_PREFIX_SIZE)) {
325 if (afs_stat(part, &status) < 0) {
326 Log("VInitVnodes: Couldn't find file system %s; ignored\n", part);
329 #ifndef AFS_AIX32_ENV
330 if (programType == fileServer) {
331 char salvpath[MAXPATHLEN];
332 strcpy(salvpath, part);
333 strcat(salvpath, "/FORCESALVAGE");
334 if (afs_stat(salvpath, &status) == 0) {
335 Log("VInitVnodes: Found %s; aborting\n", salvpath);
341 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_NT40_ENV)
342 strcpy(AFSIDatPath, part);
343 strcat(AFSIDatPath, "/AFSIDat");
345 if (afs_stat(AFSIDatPath, &status) < 0) {
349 dirp = opendir(part);
351 while (dp = readdir(dirp)) {
352 if (dp->d_name[0] == 'V') {
353 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);
360 #else /* AFS_NAMEI_ENV */
361 if (afs_stat(AFSIDatPath, &status) == 0) {
362 Log("This program is compiled without AFS_NAMEI_ENV, but partition %s seems to contain volumes which use the namei-interface; aborting\n", part);
366 #ifdef AFS_SGI_XFS_IOPS_ENV
367 if (VerifyXFSInodeSize(part, status.st_fstype) < 0)
370 #endif /* AFS_NAMEI_ENV */
371 #endif /* !AFS_LINUX20_ENV && !AFS_NT40_ENV */
373 #if defined(AFS_DUX40_ENV) && !defined(AFS_NAMEI_ENV)
374 if (status.st_ino != ROOTINO) {
375 Log("%s is not a mounted file system; ignored.\n", part);
380 VInitPartition(part, devname, status.st_dev);
385 /* VIsAlwaysAttach() checks whether a /vicepX directory should always be
386 * attached (return value 1), or only attached when it is a separately
387 * mounted partition (return value 0). For non-NAMEI environments, it
391 VIsAlwaysAttach(char *part)
398 if (strncmp(part, VICE_PARTITION_PREFIX, VICE_PREFIX_SIZE))
401 strncpy(checkfile, part, 100);
402 strcat(checkfile, "/");
403 strcat(checkfile, VICE_ALWAYSATTACH_FILE);
405 ret = afs_stat(checkfile, &st);
406 return (ret < 0) ? 0 : 1;
407 #else /* AFS_NAMEI_ENV */
409 #endif /* AFS_NAMEI_ENV */
412 /* VAttachPartitions2() looks for and attaches /vicepX partitions
413 * where a special file (VICE_ALWAYSATTACH_FILE) exists. This is
414 * used to attach /vicepX directories which aren't on dedicated
415 * partitions, in the NAMEI fileserver.
426 while ((de = readdir(dirp))) {
428 strncat(pname, de->d_name, 20);
429 pname[sizeof(pname) - 1] = '\0';
431 /* Only keep track of "/vicepx" partitions since automounter
433 if (VIsAlwaysAttach(pname))
434 VCheckPartition(pname, "");
437 #endif /* AFS_NAMEI_ENV */
439 #endif /* AFS_NT40_ENV */
443 VAttachPartitions(void)
449 if (!(mntfile = afs_fopen(MNTTAB, "r"))) {
450 Log("Can't open %s\n", MNTTAB);
454 while (!getmntent(mntfile, &mnt)) {
455 /* Ignore non ufs or non read/write partitions */
456 /* but allow zfs too if we're in the NAMEI environment */
459 ((!(strcmp(mnt.mnt_fstype, "ufs") &&
460 strcmp(mnt.mnt_fstype, "zfs"))))
462 (strcmp(mnt.mnt_fstype, "ufs") != 0)
464 || (strncmp(mnt.mnt_mntopts, "ro,ignore", 9) == 0))
467 /* If we're going to always attach this partition, do it later. */
468 if (VIsAlwaysAttach(mnt.mnt_mountp))
471 if (VCheckPartition(mnt.mnt_mountp, mnt.mnt_special) < 0)
475 (void)fclose(mntfile);
477 /* Process the always-attach partitions, if any. */
478 VAttachPartitions2();
483 #endif /* AFS_SUN5_ENV */
484 #if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)) || defined(AFS_HPUX_ENV)
486 VAttachPartitions(void)
490 struct mntent *mntent;
492 if ((mfd = setmntent(MOUNTED, "r")) == NULL) {
493 Log("Problems in getting mount entries(setmntent)\n");
496 while (mntent = getmntent(mfd)) {
497 if (!hasmntopt(mntent, MNTOPT_RW))
500 /* If we're going to always attach this partition, do it later. */
501 if (VIsAlwaysAttach(mntent->mnt_dir))
504 if (VCheckPartition(mntent->mnt_dir, mntent->mnt_fsname) < 0)
510 /* Process the always-attach partitions, if any. */
511 VAttachPartitions2();
518 * (This function was grabbed from df.c)
521 getmount(register struct vmount **vmountpp)
524 register struct vmount *vm;
527 /* set initial size of mntctl buffer to a MAGIC NUMBER */
530 /* try the operation until ok or a fatal error */
532 if ((vm = (struct vmount *)malloc(size)) == NULL) {
533 /* failed getting memory for mount status buf */
534 perror("FATAL ERROR: get_stat malloc failed\n");
539 * perform the QUERY mntctl - if it returns > 0, that is the
540 * number of vmount structures in the buffer. If it returns
541 * -1, an error occured. If it returned 0, then look in
542 * first word of buffer for needed size.
544 if ((nmounts = mntctl(MCTL_QUERY, size, (caddr_t) vm)) > 0) {
545 /* OK, got it, now return */
549 } else if (nmounts == 0) {
550 /* the buffer wasn't big enough .... */
551 /* .... get required buffer size */
556 /* some other kind of error occurred */
564 VAttachPartitions(void)
568 struct vmount *vmountp;
570 if ((nmounts = getmount(&vmountp)) <= 0) {
571 Log("Problems in getting # of mount entries(getmount)\n");
576 (struct vmount *)((int)vmountp + vmountp->vmt_length)) {
577 char *part = vmt2dataptr(vmountp, VMT_STUB);
579 if (vmountp->vmt_flags & (MNT_READONLY | MNT_REMOVABLE | MNT_REMOTE))
580 continue; /* Ignore any "special" partitions */
583 #ifndef AFS_NAMEI_ENV
585 struct superblock fs;
586 /* The Log statements are non-sequiters in the SalvageLog and don't
587 * even appear in the VolserLog, so restrict them to the FileLog.
589 if (ReadSuper(&fs, vmt2dataptr(vmountp, VMT_OBJECT)) < 0) {
590 if (programType == fileServer)
591 Log("Can't read superblock for %s, ignoring it.\n", part);
594 if (IsBigFilesFileSystem(&fs)) {
595 if (programType == fileServer)
596 Log("%s is a big files filesystem, ignoring it.\n", part);
603 /* If we're going to always attach this partition, do it later. */
604 if (VIsAlwaysAttach(part))
607 if (VCheckPartition(part, vmt2dataptr(vmountp, VMT_OBJECT)) < 0)
611 /* Process the always-attach partitions, if any. */
612 VAttachPartitions2();
617 #if defined(AFS_DUX40_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
619 VAttachPartitions(void)
624 if (setfsent() < 0) {
625 Log("Error listing filesystems.\n");
629 while (fsent = getfsent()) {
630 if (strcmp(fsent->fs_type, "rw") != 0)
633 /* If we're going to always attach this partition, do it later. */
634 if (VIsAlwaysAttach(fsent->fs_file))
637 if (VCheckPartition(fsent->fs_file, fsent->fs_spec) < 0)
642 /* Process the always-attach partitions, if any. */
643 VAttachPartitions2();
651 #include <sys/stat.h>
654 * validate names in vptab.
662 VValidVPTEntry(struct vptab *vpe)
664 int len = strlen(vpe->vp_name);
667 if (len < VICE_PREFIX_SIZE + 1 || len > VICE_PREFIX_SIZE + 2)
669 if (strncmp(vpe->vp_name, VICE_PARTITION_PREFIX, VICE_PREFIX_SIZE))
672 for (i = VICE_PREFIX_SIZE; i < len; i++) {
673 if (vpe->vp_name[i] < 'a' || vpe->vp_name[i] > 'z') {
674 Log("Invalid partition name %s in registry, ignoring it.\n",
679 if (len == VICE_PREFIX_SIZE + 2) {
680 i = (int)(vpe->vp_name[VICE_PREFIX_SIZE] - 'a') * 26 +
681 (int)(vpe->vp_name[VICE_PREFIX_SIZE + 1] - 'a');
683 Log("Invalid partition name %s in registry, ignoring it.\n",
689 len = strlen(vpe->vp_dev);
690 if (len != 2 || vpe->vp_dev[1] != ':' || vpe->vp_dev[0] < 'A'
691 || vpe->vp_dev[0] > 'Z') {
692 Log("Invalid device name %s in registry, ignoring it.\n",
701 VCheckPartition(char *partName)
708 /* partName is presumed to be of the form "X:" */
709 (void)sprintf(volRoot, "%c:\\", *partName);
711 if (!GetVolumeInformation(volRoot, /* volume root directory */
712 NULL, /* volume name buffer */
713 0, /* volume name size */
714 NULL, /* volume serial number */
715 &dwDummy, /* max component length */
716 &dwDummy, /* file system flags */
717 volFsType, /* file system name */
718 sizeof(volFsType))) {
719 err = GetLastError();
720 Log("VCheckPartition: Failed to get partition information for %s, ignoring it.\n", partName);
724 if (strcmp(volFsType, "NTFS")) {
725 Log("VCheckPartition: Partition %s is not an NTFS partition, ignoring it.\n", partName);
734 VAttachPartitions(void)
736 struct DiskPartition *partP, *prevP, *nextP;
737 struct vpt_iter iter;
740 if (vpt_Start(&iter) < 0) {
741 Log("No partitions to attach.\n");
745 while (0 == vpt_NextEntry(&iter, &entry)) {
746 if (!VValidVPTEntry(&entry)) {
750 /* This test for duplicates relies on the fact that the method
751 * of storing the partition names in the NT registry means the same
752 * partition name will never appear twice in the list.
754 for (partP = DiskPartitionList; partP; partP = partP->next) {
755 if (*partP->devName == *entry.vp_dev) {
756 Log("Same drive (%s) used for both partition %s and partition %s, ignoring both.\n", entry.vp_dev, partP->name, entry.vp_name);
757 partP->flags = PART_DUPLICATE;
758 break; /* Only one entry will ever be in this list. */
762 continue; /* found a duplicate */
764 if (VCheckPartition(entry.vp_dev) < 0)
766 /* This test allows for manually inserting the FORCESALVAGE flag
767 * and thereby invoking the salvager. scandisk obviously won't be
770 if (programType == fileServer) {
771 struct afs_stat status;
772 char salvpath[MAXPATHLEN];
773 strcpy(salvpath, entry.vp_dev);
774 strcat(salvpath, "\\FORCESALVAGE");
775 if (afs_stat(salvpath, &status) == 0) {
776 Log("VAttachPartitions: Found %s; aborting\n", salvpath);
780 VInitPartition(entry.vp_name, entry.vp_dev, *entry.vp_dev - 'A');
784 /* Run through partition list and clear out the dupes. */
785 prevP = nextP = NULL;
786 for (partP = DiskPartitionList; partP; partP = nextP) {
788 if (partP->flags == PART_DUPLICATE) {
790 prevP->next = partP->next;
792 DiskPartitionList = partP->next;
802 #ifdef AFS_LINUX22_ENV
804 VAttachPartitions(void)
808 struct mntent *mntent;
810 if ((mfd = setmntent("/proc/mounts", "r")) == NULL) {
811 if ((mfd = setmntent("/etc/mtab", "r")) == NULL) {
812 Log("Problems in getting mount entries(setmntent)\n");
816 while ((mntent = getmntent(mfd))) {
817 /* If we're going to always attach this partition, do it later. */
818 if (VIsAlwaysAttach(mntent->mnt_dir))
821 if (VCheckPartition(mntent->mnt_dir, mntent->mnt_fsname) < 0)
826 /* Process the always-attach partitions, if any. */
827 VAttachPartitions2();
831 #endif /* AFS_LINUX22_ENV */
833 /* This routine is to be called whenever the actual name of the partition
834 * is required. The canonical name is still in part->name.
837 VPartitionPath(struct DiskPartition *part)
840 return part->devName;
846 /* get partition structure, abortp tells us if we should abort on failure */
847 struct DiskPartition *
848 VGetPartition_r(char *name, int abortp)
850 register struct DiskPartition *dp;
851 #ifdef AFS_DEMAND_ATTACH_FS
852 dp = VLookupPartition_r(name);
853 #else /* AFS_DEMAND_ATTACH_FS */
854 for (dp = DiskPartitionList; dp; dp = dp->next) {
855 if (strcmp(dp->name, name) == 0)
858 #endif /* AFS_DEMAND_ATTACH_FS */
864 struct DiskPartition *
865 VGetPartition(char *name, int abortp)
867 struct DiskPartition *retVal;
869 retVal = VGetPartition_r(name, abortp);
876 VSetPartitionDiskUsage_r(register struct DiskPartition *dp)
878 ULARGE_INTEGER free_user, total, free_total;
879 int ufree, tot, tfree;
881 if (!GetDiskFreeSpaceEx
882 (VPartitionPath(dp), &free_user, &total, &free_total)) {
883 printf("Failed to get disk space info for %s, error = %d\n", dp->name,
888 /* Convert to 1K units. */
889 ufree = (int)Int64ShraMod32(free_user.QuadPart, 10);
890 tot = (int)Int64ShraMod32(total.QuadPart, 10);
891 tfree = (int)Int64ShraMod32(free_total.QuadPart, 10);
893 dp->minFree = tfree - ufree; /* only used in VPrintDiskStats_r */
894 dp->totalUsable = tot;
900 VSetPartitionDiskUsage_r(register struct DiskPartition *dp)
902 int fd, totalblks, free, used, availblks, bsize, code;
905 struct afs_statvfs statbuf;
907 struct afs_statfs statbuf;
910 if (dp->flags & PART_DONTUPDATE)
912 /* Note: we don't bother syncing because it's only an estimate, update
913 * is syncing every 30 seconds anyway, we only have to keep the disk
914 * approximately 10% from full--you just can't get the stuff in from
915 * the net fast enough to worry */
917 code = afs_statvfs(dp->name, &statbuf);
919 code = afs_statfs(dp->name, &statbuf);
922 Log("statfs of %s failed in VSetPartitionDiskUsage (errno = %d)\n",
926 if (statbuf.f_blocks == -1) { /* Undefined; skip stats.. */
927 Log("statfs of %s failed in VSetPartitionDiskUsage\n", dp->name);
930 totalblks = statbuf.f_blocks;
931 free = statbuf.f_bfree;
932 reserved = free - statbuf.f_bavail;
934 bsize = statbuf.f_frsize;
936 bsize = statbuf.f_bsize;
938 availblks = totalblks - reserved;
939 dp->f_files = statbuf.f_files; /* max # of files in partition */
941 /* Now free and totalblks are in fragment units, but we want them in
945 free *= (bsize / 1024);
946 totalblks *= (bsize / 1024);
947 availblks *= (bsize / 1024);
948 reserved *= (bsize / 1024);
950 free /= (1024 / bsize);
951 totalblks /= (1024 / bsize);
952 availblks /= (1024 / bsize);
953 reserved /= (1024 / bsize);
955 /* now compute remaining figures */
956 used = totalblks - free;
958 dp->minFree = reserved; /* only used in VPrintDiskStats_r */
959 dp->totalUsable = availblks;
960 dp->free = availblks - used; /* this is exactly f_bavail */
962 #endif /* AFS_NT40_ENV */
965 VSetPartitionDiskUsage(register struct DiskPartition *dp)
968 VSetPartitionDiskUsage_r(dp);
973 VResetDiskUsage_r(void)
975 struct DiskPartition *dp;
976 for (dp = DiskPartitionList; dp; dp = dp->next) {
977 VSetPartitionDiskUsage_r(dp);
978 #ifndef AFS_PTHREAD_ENV
980 #endif /* !AFS_PTHREAD_ENV */
985 VResetDiskUsage(void)
993 VAdjustDiskUsage_r(Error * ec, Volume * vp, afs_sfsize_t blocks,
994 afs_sfsize_t checkBlocks)
997 /* why blocks instead of checkBlocks in the check below? Otherwise, any check
998 * for less than BlocksSpare would skip the error-checking path, and we
999 * could grow existing files forever, not just for another BlocksSpare
1002 #ifdef AFS_AIX32_ENV
1003 afs_int32 rem, minavail;
1005 if ((rem = vp->partition->free - checkBlocks) < (minavail =
1011 if (vp->partition->free - checkBlocks < 0)
1014 else if (V_maxquota(vp)
1015 && V_diskused(vp) + checkBlocks > V_maxquota(vp))
1018 vp->partition->free -= blocks;
1019 V_diskused(vp) += blocks;
1023 VAdjustDiskUsage(Error * ec, Volume * vp, afs_sfsize_t blocks,
1024 afs_sfsize_t checkBlocks)
1027 VAdjustDiskUsage_r(ec, vp, blocks, checkBlocks);
1032 VDiskUsage_r(Volume * vp, afs_sfsize_t blocks)
1035 #ifdef AFS_AIX32_ENV
1036 afs_int32 rem, minavail;
1038 if ((rem = vp->partition->free - blocks) < (minavail =
1041 aixlow_water) / 100))
1043 if (vp->partition->free - blocks < 0)
1047 vp->partition->free -= blocks;
1052 VDiskUsage(Volume * vp, afs_sfsize_t blocks)
1056 retVal = VDiskUsage_r(vp, blocks);
1062 VPrintDiskStats_r(void)
1064 struct DiskPartition *dp;
1065 for (dp = DiskPartitionList; dp; dp = dp->next) {
1066 Log("Partition %s: %d available 1K blocks (minfree=%d), ", dp->name,
1067 dp->totalUsable, dp->minFree);
1069 Log("overallocated by %d blocks\n", -dp->free);
1071 Log("%d free blocks\n", dp->free);
1076 VPrintDiskStats(void)
1079 VPrintDiskStats_r();
1084 /* Need a separate lock file on NT, since NT only has mandatory file locks. */
1085 #define LOCKFILE "LOCKFILE"
1087 VLockPartition_r(char *name)
1089 struct DiskPartition *dp = VGetPartition_r(name, 0);
1094 if (dp->lock_fd == -1) {
1097 (void)sprintf(path, "%s\\%s", VPartitionPath(dp), LOCKFILE);
1099 (int)CreateFile(path, GENERIC_WRITE,
1100 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1101 CREATE_ALWAYS, FILE_ATTRIBUTE_HIDDEN, NULL);
1102 assert(dp->lock_fd != (int)INVALID_HANDLE_VALUE);
1104 memset((char *)&lap, 0, sizeof(lap));
1105 rc = LockFileEx((HANDLE) dp->lock_fd, LOCKFILE_EXCLUSIVE_LOCK, 0, 1,
1112 VUnlockPartition_r(char *name)
1114 register struct DiskPartition *dp = VGetPartition_r(name, 0);
1118 return; /* no partition, will fail later */
1119 memset((char *)&lap, 0, sizeof(lap));
1121 UnlockFileEx((HANDLE) dp->lock_fd, 0, 1, 0, &lap);
1122 CloseHandle((HANDLE) dp->lock_fd);
1125 #else /* AFS_NT40_ENV */
1127 #if defined(AFS_HPUX_ENV)
1128 #define BITS_PER_CHAR (8)
1129 #define BITS(type) (sizeof(type) * BITS_PER_CHAR)
1131 #define LOCKRDONLY_OFFSET ((PRIV_LOCKRDONLY - 1) / BITS(int))
1132 #endif /* defined(AFS_HPUX_ENV) */
1135 VLockPartition_r(char *name)
1137 register struct DiskPartition *dp = VGetPartition_r(name, 0);
1138 char *partitionName;
1140 struct timeval pausing;
1141 #if defined(AFS_HPUX_ENV)
1143 struct privgrp_map privGrpList[PRIV_MAXGRPS];
1144 unsigned int *globalMask;
1145 int globalMaskIndex;
1146 #endif /* defined(AFS_HPUX_ENV) */
1147 #if defined(AFS_DARWIN_ENV)
1148 char lockfile[MAXPATHLEN];
1149 #endif /* defined(AFS_DARWIN_ENV) */
1150 #ifdef AFS_NAMEI_ENV
1151 #ifdef AFS_AIX42_ENV
1152 char LockFileName[MAXPATHLEN + 1];
1154 sprintf((char *)&LockFileName, "%s/AFSINODE_FSLock", name);
1155 partitionName = (char *)&LockFileName;
1160 return; /* no partition, will fail later */
1161 if (dp->lock_fd != -1)
1164 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV)
1165 #if !defined(AFS_AIX42_ENV) || !defined(AFS_NAMEI_ENV)
1166 partitionName = dp->devName;
1169 #elif defined(AFS_DARWIN_ENV)
1170 strlcpy((partitionName = lockfile), dp->name, sizeof(lockfile));
1171 strlcat(lockfile, "/.lock.afs", sizeof(lockfile));
1172 code = O_RDONLY | O_CREAT;
1174 partitionName = dp->name;
1178 for (retries = 25; retries; retries--) {
1179 dp->lock_fd = afs_open(partitionName, code);
1180 if (dp->lock_fd != -1)
1182 if (errno == ENOENT)
1185 pausing.tv_usec = 500000;
1186 select(0, NULL, NULL, NULL, &pausing);
1188 assert(retries != 0);
1190 #if defined (AFS_HPUX_ENV)
1192 assert(getprivgrp(privGrpList) == 0);
1195 * In general, it will difficult and time-consuming ,if not impossible,
1196 * to try to find the privgroup to which this process belongs that has the
1197 * smallest membership, to minimise the security hole. So, we use the privgrp
1198 * to which everybody belongs.
1200 /* first, we have to find the global mask */
1201 for (globalMaskIndex = 0; globalMaskIndex < PRIV_MAXGRPS;
1202 globalMaskIndex++) {
1203 if (privGrpList[globalMaskIndex].priv_groupno == PRIV_GLOBAL) {
1205 &(privGrpList[globalMaskIndex].priv_mask[LOCKRDONLY_OFFSET]);
1210 if (((*globalMask) & privmask(PRIV_LOCKRDONLY)) == 0) {
1211 /* allow everybody to set a lock on a read-only file descriptor */
1212 (*globalMask) |= privmask(PRIV_LOCKRDONLY);
1213 assert(setprivgrp(PRIV_GLOBAL, privGrpList[globalMaskIndex].priv_mask)
1216 lockfRtn = lockf(dp->lock_fd, F_LOCK, 0);
1218 /* remove the privilege granted to everybody to lock a read-only fd */
1219 (*globalMask) &= ~(privmask(PRIV_LOCKRDONLY));
1220 assert(setprivgrp(PRIV_GLOBAL, privGrpList[globalMaskIndex].priv_mask)
1223 /* in this case, we should be able to do this with impunity, anyway */
1224 lockfRtn = lockf(dp->lock_fd, F_LOCK, 0);
1227 assert(lockfRtn != -1);
1229 #if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV)
1230 assert(lockf(dp->lock_fd, F_LOCK, 0) != -1);
1232 assert(flock(dp->lock_fd, LOCK_EX) == 0);
1233 #endif /* defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) */
1238 VUnlockPartition_r(char *name)
1240 register struct DiskPartition *dp = VGetPartition_r(name, 0);
1242 return; /* no partition, will fail later */
1247 #endif /* AFS_NT40_ENV */
1250 VLockPartition(char *name)
1253 VLockPartition_r(name);
1258 VUnlockPartition(char *name)
1261 VUnlockPartition_r(name);
1265 #ifdef AFS_DEMAND_ATTACH_FS
1266 /* XXX not sure this will work on AFS_NT40_ENV
1267 * needs to be tested!
1269 struct DiskPartition *
1270 VGetPartitionById_r(afs_int32 id, int abortp)
1272 struct DiskPartition * dp = NULL;
1274 if ((id >= 0) && (id <= VOLMAXPARTS)) {
1275 dp = DiskPartitionTable[id];
1284 struct DiskPartition *
1285 VGetPartitionById(afs_int32 id, int abortp)
1287 struct Diskpartition * dp;
1290 dp = VGetPartitionById_r(id, abortp);
1296 static struct DiskPartition *
1297 VLookupPartition_r(char * path)
1299 afs_int32 id = volutil_GetPartitionID(path);
1301 if (id < 0 || id > VOLMAXPARTS)
1304 return DiskPartitionTable[id];
1308 AddPartitionToTable_r(struct DiskPartition * dp)
1310 assert(dp->index >= 0 && dp->index <= VOLMAXPARTS);
1311 DiskPartitionTable[dp->index] = dp;
1315 DeletePartitionFromTable_r(struct DiskPartition * dp)
1317 assert(dp->index >= 0 && dp->index <= VOLMAXPARTS);
1318 DiskPartitionTable[dp->index] = NULL;
1320 #endif /* AFS_DEMAND_ATTACH_FS */