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