33f3812bc15dfa0cd7e19b67230e3ff169835859
[openafs.git] / src / vol / vol-info.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 /*
11    System:              VICE-TWO
12    Module:              vol-info.c
13    Institution: The Information Technology Center, Carnegie-Mellon University
14
15    */
16
17 #include <afsconfig.h>
18 #include <afs/param.h>
19
20 #include <roken.h>
21
22 #include <ctype.h>
23
24 #ifdef HAVE_SYS_FILE_H
25 #include <sys/file.h>
26 #endif
27
28 #include <afs/cmd.h>
29 #include <afs/dir.h>
30
31 #include <rx/xdr.h>
32 #include <afs/afsint.h>
33 #include "nfs.h"
34 #include <afs/errors.h>
35 #include "lock.h"
36 #include "lwp.h"
37 #include <afs/afssyscalls.h>
38 #include "ihandle.h"
39 #include "vnode.h"
40 #include "volume.h"
41 #include "partition.h"
42 #include "viceinode.h"
43 #include <afs/afssyscalls.h>
44 #include <afs/afsutil.h>
45
46 #ifndef AFS_NT40_ENV
47 #include "AFS_component_version_number.c"
48 #endif
49
50 static const char *progname = "volinfo";
51
52 /* Modes */
53 static int DumpInfo = 1;            /**< Dump volume information, defualt mode*/
54 static int DumpHeader = 0;          /**< Dump volume header files info */
55 static int DumpVnodes = 0;          /**< Dump vnode info */
56 static int DumpInodeNumber = 0;     /**< Dump inode numbers with vnodes */
57 static int DumpDate = 0;            /**< Dump vnode date (server modify date) with vnode */
58 static int InodeTimes = 0;          /**< Dump some of the dates associated with inodes */
59 #if defined(AFS_NAMEI_ENV)
60 static int PrintFileNames = 0;      /**< Dump vnode and special file name filenames */
61 #endif
62 static int ShowOrphaned = 0;        /**< Show "orphaned" vnodes (vnodes with parent of 0) */
63 static int ShowSizes = 0;           /**< Show volume size summary */
64 static int SaveInodes = 0;          /**< Save vnode data to files */
65 static int FixHeader = 0;           /**< Repair header files magic and version fields. */
66
67 /**
68  * Volume size running totals
69  */
70 struct sizeTotals {
71     afs_uint64 diskused_k;      /**< volume size from disk data file, in kilobytes */
72     afs_uint64 auxsize;         /**< size of header files, in bytes  */
73     afs_uint64 auxsize_k;       /**< size of header files, in kilobytes */
74     afs_uint64 vnodesize;       /**< size of the large and small vnodes, in bytes */
75     afs_uint64 vnodesize_k;     /**< size of the large and small vnodes, in kilobytes */
76     afs_uint64 size_k;          /**< size of headers and vnodes, in kilobytes */
77 };
78
79 static struct sizeTotals volumeTotals = { 0, 0, 0, 0, 0, 0 };
80 static struct sizeTotals partitionTotals = { 0, 0, 0, 0, 0, 0 };
81 static struct sizeTotals serverTotals = { 0, 0, 0, 0, 0, 0 };
82 static int PrintingVolumeSizes = 0;     /*print volume size lines */
83
84 /* Forward Declarations */
85 void PrintHeader(Volume * vp);
86 void HandleAllPart(void);
87 void HandlePart(struct DiskPartition64 *partP);
88 void HandleVolume(struct DiskPartition64 *partP, char *name);
89 struct DiskPartition64 *FindCurrentPartition(void);
90 Volume *AttachVolume(struct DiskPartition64 *dp, char *volname,
91                      struct VolumeHeader *header);
92 void PrintVnode(afs_foff_t offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
93                 Inode ino, Volume * vp);
94 void HandleVnodes(Volume * vp, VnodeClass class);
95
96 /**
97  * Format time as a timestamp string
98  *
99  * @param[in] date  time value to format
100  *
101  * @return timestamp string in the form YYYY/MM/DD.hh:mm:ss
102  *
103  * @note A static array of 8 strings are stored by this
104  *       function. The array slots are overwritten, so the
105  *       caller must not reference the returned string after
106  *       seven additional calls to this function.
107  */
108 char *
109 date(time_t date)
110 {
111 #define MAX_DATE_RESULT 100
112     static char results[8][MAX_DATE_RESULT];
113     static int next;
114     struct tm *tm = localtime(&date);
115     char buf[32];
116
117     (void)strftime(buf, 32, "%Y/%m/%d.%H:%M:%S", tm);   /* NT does not have %T */
118     snprintf(results[next = (next + 1) & 7], MAX_DATE_RESULT,
119              "%lu (%s)", (unsigned long)date, buf);
120     return results[next];
121 }
122
123 #ifdef AFS_NT40_ENV
124 /**
125  * Format file time as a timestamp string
126  *
127  * @param[in] ft  file time
128  *
129  * @return timestamp string in the form YYYY/MM/DD.hh:mm:ss
130  *
131  * @note A static array of 8 strings are stored by this
132  *       function. The array slots are overwritten, so the
133  *       caller must not reference the returned string after
134  *       seven additional calls to this function.
135  */
136 char *
137 NT_date(FILETIME * ft)
138 {
139     static char result[8][64];
140     static int next = 0;
141     SYSTEMTIME st;
142     FILETIME lft;
143
144     if (!FileTimeToLocalFileTime(ft, &lft)
145         || !FileTimeToSystemTime(&lft, &st)) {
146         fprintf(stderr, "%s: Time conversion failed.\n", progname);
147         exit(1);
148     }
149     sprintf(result[next = ((next + 1) & 7)], "%4d/%02d/%02d.%2d:%2d:%2d",
150             st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
151     return result[next];
152 }
153 #endif
154
155 /**
156  * Print the volume size table heading line, if needed.
157  *
158  * @return none
159  */
160 static void
161 PrintVolumeSizeHeading(void)
162 {
163     if (!PrintingVolumeSizes) {
164         printf
165             ("Volume-Id\t  Volsize  Auxsize Inodesize  AVolsize SizeDiff                (VolName)\n");
166         PrintingVolumeSizes = 1;
167     }
168 }
169
170 /**
171  * Accumulate totals.
172  *
173  * @return 0
174  */
175 static void
176 AddSizeTotals(struct sizeTotals *a, struct sizeTotals *b)
177 {
178     a->diskused_k += b->diskused_k;
179     a->auxsize += b->auxsize;
180     a->auxsize_k += b->auxsize_k;
181     a->vnodesize += b->vnodesize;
182     a->vnodesize_k += b->vnodesize_k;
183     a->size_k += b->size_k;
184 }
185
186 /**
187  * Print the sizes for a volume.
188  *
189  * @return none
190  */
191 static void
192 PrintVolumeSizes(Volume * vp)
193 {
194     afs_int64 diff_k = volumeTotals.size_k - volumeTotals.diskused_k;
195
196     PrintVolumeSizeHeading();
197     printf("%u\t%9llu%9llu%10llu%10llu%9lld\t%24s\n",
198            V_id(vp),
199            volumeTotals.diskused_k,
200            volumeTotals.auxsize_k, volumeTotals.vnodesize_k,
201            volumeTotals.size_k, diff_k, V_name(vp));
202 }
203
204 /**
205  * Print the size totals for the partition.
206  *
207  * @return none
208  */
209 static void
210 PrintPartitionTotals(afs_uint64 nvols)
211 {
212     afs_int64 diff_k = partitionTotals.size_k - partitionTotals.diskused_k;
213
214     PrintVolumeSizeHeading();
215     printf("\nPart Totals  %12llu%9llu%10llu%10llu%9lld (%llu volumes)\n\n",
216            partitionTotals.diskused_k, partitionTotals.auxsize,
217            partitionTotals.vnodesize, partitionTotals.size_k, diff_k, nvols);
218     PrintingVolumeSizes = 0;
219 }
220
221 /**
222  * Print the size totals for all the partitions.
223  *
224  * @return none
225  */
226 static void
227 PrintServerTotals(void)
228 {
229     afs_int64 diff_k = serverTotals.size_k - serverTotals.diskused_k;
230
231     printf("\nServer Totals%12lld%9lld%10lld%10lld%9lld\n",
232            serverTotals.diskused_k, serverTotals.auxsize,
233            serverTotals.vnodesize, serverTotals.size_k, diff_k);
234 }
235
236 /**
237  * Read a volume header file
238  *
239  * @param[in] ih        ihandle of the header file
240  * @param[in] to        destination
241  * @param[in] size      expected header size
242  * @param[in] magic     expected header magic number
243  * @param[in] version   expected header version number
244  *
245  * @return error code
246  *   @retval 0 success
247  *   @retval -1 failed to read file
248  */
249 int
250 ReadHdr1(IHandle_t * ih, char *to, int size, u_int magic, u_int version)
251 {
252     struct versionStamp *vsn;
253     int bad = 0;
254     int code;
255
256     vsn = (struct versionStamp *)to;
257
258     code = IH_IREAD(ih, 0, to, size);
259     if (code != size)
260         return -1;
261
262     if (vsn->magic != magic) {
263         bad++;
264         fprintf(stderr, "%s: Inode %s: Bad magic %x (%x): IGNORED\n",
265                 progname, PrintInode(NULL, ih->ih_ino), vsn->magic, magic);
266     }
267
268     /* Check is conditional, in case caller wants to inspect version himself */
269     if (version && vsn->version != version) {
270         bad++;
271         fprintf(stderr, "%s: Inode %s: Bad version %x (%x): IGNORED\n",
272                 progname,
273                 PrintInode(NULL, ih->ih_ino), vsn->version, version);
274     }
275     if (bad && FixHeader) {
276         vsn->magic = magic;
277         vsn->version = version;
278         printf("Special index inode %s has a bad header. Reconstructing...\n",
279                PrintInode(NULL, ih->ih_ino));
280         code = IH_IWRITE(ih, 0, to, size);
281         if (code != size) {
282             fprintf(stderr,
283                     "%s: Write failed for inode %s; header left in damaged state\n",
284                     progname, PrintInode(NULL, ih->ih_ino));
285         }
286     } else {
287         if (DumpInfo) {
288             printf("Inode %s: Good magic %x and version %x\n",
289                    PrintInode(NULL, ih->ih_ino), magic, version);
290         }
291     }
292     return 0;
293 }
294
295 /**
296  * Simplified attach volume
297  *
298  * param[in] dp       vice disk partition object
299  * param[in] volname  volume header file name
300  * param[in] header   volume header object
301  *
302  * @return volume object or null on error
303  */
304 Volume *
305 AttachVolume(struct DiskPartition64 * dp, char *volname,
306              struct VolumeHeader * header)
307 {
308     Volume *vp;
309     afs_int32 ec = 0;
310
311     vp = (Volume *) calloc(1, sizeof(Volume));
312     vp->specialStatus = 0;
313     vp->device = dp->device;
314     vp->partition = dp;
315     IH_INIT(vp->vnodeIndex[vLarge].handle, dp->device, header->parent,
316             header->largeVnodeIndex);
317     IH_INIT(vp->vnodeIndex[vSmall].handle, dp->device, header->parent,
318             header->smallVnodeIndex);
319     IH_INIT(vp->diskDataHandle, dp->device, header->parent,
320             header->volumeInfo);
321     IH_INIT(V_linkHandle(vp), dp->device, header->parent, header->linkTable);
322     vp->cacheCheck = 0;         /* XXXX */
323     vp->shuttingDown = 0;
324     vp->goingOffline = 0;
325     vp->nUsers = 1;
326     vp->header = (struct volHeader *)calloc(1, sizeof(*vp->header));
327     ec = ReadHdr1(V_diskDataHandle(vp), (char *)&V_disk(vp),
328                   sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
329     if (!ec) {
330         struct IndexFileHeader iHead;
331         ec = ReadHdr1(vp->vnodeIndex[vSmall].handle, (char *)&iHead,
332                       sizeof(iHead), SMALLINDEXMAGIC, SMALLINDEXVERSION);
333     }
334     if (!ec) {
335         struct IndexFileHeader iHead;
336         ec = ReadHdr1(vp->vnodeIndex[vLarge].handle, (char *)&iHead,
337                       sizeof(iHead), LARGEINDEXMAGIC, LARGEINDEXVERSION);
338     }
339 #ifdef AFS_NAMEI_ENV
340     if (!ec) {
341         struct versionStamp stamp;
342         ec = ReadHdr1(V_linkHandle(vp), (char *)&stamp, sizeof(stamp),
343                       LINKTABLEMAGIC, LINKTABLEVERSION);
344     }
345 #endif
346     if (ec)
347         return (Volume *) 0;
348     return vp;
349 }
350
351 /**
352  * Convert the partition device number into a partition name.
353  *
354  * @param[in]   partId      partition number, 0 to 254
355  * @param[out]  partName    buffer to hold partition name (e.g. /vicepa)
356  * @param[in]   partNameSize    size of partName buffer
357  *
358  * @return status
359  *   @retval 0 success
360  *   @retval -1 error, partId is out of range
361  *   @retval -2 error, partition name exceeds partNameSize
362  */
363 static int
364 GetPartitionName(afs_uint32 partId, char *partName, afs_size_t partNameSize)
365 {
366     const int OLD_NUM_DEVICES = 26;     /* a..z */
367
368     if (partId < OLD_NUM_DEVICES) {
369         if (partNameSize < 8) {
370             return -2;
371         }
372         strlcpy(partName, "/vicep", partNameSize);
373         partName[6] = partId + 'a';
374         partName[7] = '\0';
375         return 0;
376     }
377     if (partId < VOLMAXPARTS) {
378         if (partNameSize < 9) {
379             return -2;
380         }
381         strlcpy(partName, "/vicep", partNameSize);
382         partId -= OLD_NUM_DEVICES;
383         partName[6] = 'a' + (partId / OLD_NUM_DEVICES);
384         partName[7] = 'a' + (partId % OLD_NUM_DEVICES);
385         partName[8] = '\0';
386         return 0;
387     }
388     return -1;
389 }
390
391 /**
392  * Process command line options and start scanning
393  *
394  * @param[in] as     command syntax object
395  * @param[in] arock  opaque object; not used
396  *
397  * @return error code
398  */
399 static int
400 handleit(struct cmd_syndesc *as, void *arock)
401 {
402     struct cmd_item *ti;
403     int err = 0;
404     afs_uint32 volumeId = 0;
405     char *partNameOrId = 0;
406     char partName[64] = "";
407     struct DiskPartition64 *partP = NULL;
408
409
410 #ifndef AFS_NT40_ENV
411     if (geteuid() != 0) {
412         fprintf(stderr, "%s: Must be run as root; sorry\n", progname);
413         return 1;
414     }
415 #endif
416
417     if (as->parms[0].items) {   /* -online */
418         fprintf(stderr, "%s: -online not supported\n", progname);
419         return 1;
420     }
421     if (as->parms[1].items) {   /* -vnode */
422         DumpVnodes = 1;
423     }
424     if (as->parms[2].items) {   /* -date */
425         DumpDate = 1;
426     }
427     if (as->parms[3].items) {   /* -inode */
428         DumpInodeNumber = 1;
429     }
430     if (as->parms[4].items) {   /* -itime */
431         InodeTimes = 1;
432     }
433     if ((ti = as->parms[5].items)) {    /* -part */
434         partNameOrId = ti->data;
435     }
436     if ((ti = as->parms[6].items)) {    /* -volumeid */
437         volumeId = strtoul(ti->data, NULL, 10);
438     }
439     if (as->parms[7].items) {   /* -header */
440         DumpHeader = 1;
441     }
442     if (as->parms[8].items) {   /* -sizeOnly */
443         ShowSizes = 1;
444     }
445     if (as->parms[9].items) {   /* -FixHeader */
446         FixHeader = 1;
447     }
448     if (as->parms[10].items) {  /* -saveinodes */
449         SaveInodes = 1;
450     }
451     if (as->parms[11].items) {  /* -orphaned */
452         ShowOrphaned = 1;
453     }
454 #if defined(AFS_NAMEI_ENV)
455     if (as->parms[12].items) {  /* -filenames */
456         PrintFileNames = 1;
457     }
458 #endif
459
460     /* -saveinodes and -sizeOnly override the default mode.
461      * For compatibility with old versions of volinfo, -orphaned
462      * and -filename options imply -vnodes */
463     if (SaveInodes || ShowSizes) {
464         DumpInfo = 0;
465         DumpHeader = 0;
466         DumpVnodes = 0;
467         InodeTimes = 0;
468         ShowOrphaned = 0;
469     } else if (ShowOrphaned || PrintFileNames) {
470         DumpVnodes = 1;         /* implied */
471     }
472
473     /* Allow user to specify partition by name or id. */
474     if (partNameOrId) {
475         afs_uint32 partId = volutil_GetPartitionID(partNameOrId);
476         if (partId == -1) {
477             fprintf(stderr, "%s: Could not parse '%s' as a partition name.\n",
478                     progname, partNameOrId);
479             return 1;
480         }
481         if (GetPartitionName(partId, partName, sizeof(partName))) {
482             fprintf(stderr,
483                     "%s: Could not format '%s' as a partition name.\n",
484                     progname, partNameOrId);
485             return 1;
486         }
487     }
488
489     DInit(10);
490
491     err = VAttachPartitions();
492     if (err) {
493         fprintf(stderr, "%s: %d partitions had errors during attach.\n",
494                 progname, err);
495     }
496
497     if (partName[0]) {
498         partP = VGetPartition(partName, 0);
499         if (!partP) {
500             fprintf(stderr,
501                     "%s: %s is not an AFS partition name on this server.\n",
502                     progname, partName);
503             return 1;
504         }
505     }
506
507     if (!volumeId) {
508         if (!partP) {
509             HandleAllPart();
510         } else {
511             HandlePart(partP);
512         }
513     } else {
514         char name1[128];
515
516         if (!partP) {
517             partP = FindCurrentPartition();
518             if (!partP) {
519                 fprintf(stderr,
520                         "%s: Current partition is not a vice partition.\n",
521                         progname);
522                 return 1;
523             }
524         }
525         snprintf(name1, sizeof name1, VFORMAT,
526                  afs_printable_uint32_lu(volumeId));
527         HandleVolume(partP, name1);
528     }
529     return 0;
530 }
531
532 /**
533  * Determine if the current directory is a vice partition
534  *
535  * @return disk partition object
536  */
537 #ifdef AFS_NT40_ENV
538 #include <direct.h>
539 struct DiskPartition64 *
540 FindCurrentPartition(void)
541 {
542     int dr = _getdrive();
543     struct DiskPartition64 *dp;
544
545     dr--;
546     for (dp = DiskPartitionList; dp; dp = dp->next) {
547         if (*dp->devName - 'A' == dr)
548             break;
549     }
550     if (!dp) {
551         fprintf(stderr, "%s: Current drive is not a valid vice partition.\n",
552                 progname);
553     }
554     return dp;
555 }
556 #else
557 struct DiskPartition64 *
558 FindCurrentPartition(void)
559 {
560     char partName[1024];
561     char tmp = '\0';
562     char *p;
563     struct DiskPartition64 *dp;
564
565     if (!getcwd(partName, 1023)) {
566         fprintf(stderr, "%s: Failed to get current working directory: ",
567                 progname);
568         perror("pwd");
569         return NULL;
570     }
571     p = strchr(&partName[1], OS_DIRSEPC);
572     if (p) {
573         tmp = *p;
574         *p = '\0';
575     }
576     if (!(dp = VGetPartition(partName, 0))) {
577         if (tmp)
578             *p = tmp;
579         fprintf(stderr, "%s: %s is not a valid vice partition.\n", progname,
580                 partName);
581         return NULL;
582     }
583     return dp;
584 }
585 #endif
586
587 /**
588  * Scan and handle all the partitions detected on this server
589  *
590  * @return none
591  */
592 void
593 HandleAllPart(void)
594 {
595     struct DiskPartition64 *partP;
596
597
598     for (partP = DiskPartitionList; partP; partP = partP->next) {
599         printf("Processing Partition %s:\n", partP->name);
600         HandlePart(partP);
601         if (ShowSizes) {
602             AddSizeTotals(&serverTotals, &partitionTotals);
603         }
604     }
605
606     if (ShowSizes) {
607         PrintServerTotals();
608     }
609 }
610
611 /**
612  * Scan the partition and handle volumes
613  *
614  * @param[in] partP  disk partition to scan
615  *
616  * @return none
617  */
618 void
619 HandlePart(struct DiskPartition64 *partP)
620 {
621     afs_int64 nvols = 0;
622     DIR *dirp;
623     struct dirent *dp;
624 #ifdef AFS_NT40_ENV
625     char pname[64];
626     char *p = pname;
627     (void)sprintf(pname, "%s\\", VPartitionPath(partP));
628 #else
629     char *p = VPartitionPath(partP);
630 #endif
631
632     if ((dirp = opendir(p)) == NULL) {
633         fprintf(stderr, "%s: Can't read directory %s; giving up\n", progname,
634                 p);
635         return;
636     }
637     while ((dp = readdir(dirp))) {
638         p = (char *)strrchr(dp->d_name, '.');
639         if (p != NULL && strcmp(p, VHDREXT) == 0) {
640             HandleVolume(partP, dp->d_name);
641             if (ShowSizes) {
642                 nvols++;
643                 AddSizeTotals(&partitionTotals, &volumeTotals);
644             }
645         }
646     }
647     closedir(dirp);
648     if (ShowSizes) {
649         PrintPartitionTotals(nvols);
650     }
651 }
652
653 /**
654  * Inspect a volume header special file.
655  *
656  * @param[in]  name       descriptive name of the type of header special file
657  * @param[in]  dp         partition object for this volume
658  * @param[in]  header     header object for this volume
659  * @param[in]  inode      fileserver inode number for this header special file
660  * @param[out] psize      total of the header special file
661  *
662  * @return none
663  */
664 void
665 HandleSpecialFile(const char *name, struct DiskPartition64 *dp,
666                   struct VolumeHeader *header, Inode inode,
667                   afs_sfsize_t * psize)
668 {
669     afs_sfsize_t size = 0;
670     IHandle_t *ih = NULL;
671     FdHandle_t *fdP = NULL;
672 #ifdef AFS_NAMEI_ENV
673     namei_t filename;
674 #endif /* AFS_NAMEI_ENV */
675
676     IH_INIT(ih, dp->device, header->parent, inode);
677     fdP = IH_OPEN(ih);
678     if (fdP == NULL) {
679         fprintf(stderr,
680                 "%s: Error opening header file '%s' for volume %u", progname,
681                 name, header->id);
682         perror("open");
683         goto error;
684     }
685     size = FDH_SIZE(fdP);
686     if (size == -1) {
687         fprintf(stderr,
688                 "%s: Error getting size of header file '%s' for volume %u",
689                 progname, name, header->id);
690         perror("fstat");
691         goto error;
692     }
693     if (DumpInfo) {
694         printf("\t%s inode\t= %s (size = %lld)\n",
695                name, PrintInode(NULL, inode), size);
696 #ifdef AFS_NAMEI_ENV
697         namei_HandleToName(&filename, ih);
698         printf("\t%s namei\t= %s\n", name, filename.n_path);
699 #endif /* AFS_NAMEI_ENV */
700     }
701     *psize += size;
702
703   error:
704     if (fdP != NULL) {
705         FDH_REALLYCLOSE(fdP);
706     }
707     if (ih != NULL) {
708         IH_RELEASE(ih);
709     }
710 }
711
712 /**
713  * Inspect this volume header files.
714  *
715  * @param[in]  dp         partition object for this volume
716  * @param[in]  header_fd  volume header file descriptor
717  * @param[in]  header     volume header object
718  * @param[out] psize      total of the header special file
719  *
720  * @return none
721  */
722 void
723 HandleHeaderFiles(struct DiskPartition64 *dp, FD_t header_fd,
724                   struct VolumeHeader *header)
725 {
726     afs_sfsize_t size = 0;
727
728     if (DumpInfo) {
729         size = OS_SIZE(header_fd);
730         printf("Volume header (size = %lld):\n", size);
731         printf("\tstamp\t= 0x%x\n", header->stamp.version);
732         printf("\tVolId\t= %u\n", header->id);
733         printf("\tparent\t= %u\n", header->parent);
734     }
735
736     HandleSpecialFile("Info", dp, header, header->volumeInfo, &size);
737     HandleSpecialFile("Small", dp, header, header->smallVnodeIndex,
738                       &size);
739     HandleSpecialFile("Large", dp, header, header->largeVnodeIndex,
740                       &size);
741 #ifdef AFS_NAMEI_ENV
742     HandleSpecialFile("Link", dp, header, header->linkTable, &size);
743 #endif /* AFS_NAMEI_ENV */
744
745     if (DumpInfo) {
746         printf("Total aux volume size = %lld\n\n", size);
747     }
748
749     if (ShowSizes) {
750         volumeTotals.auxsize = size;
751         volumeTotals.auxsize_k = size / 1024;
752     }
753 }
754
755 /**
756  * Attach and scan the volume and handle the header and vnodes
757  *
758  * Print the volume header and vnode information, depending on the
759  * current modes.
760  *
761  * @param[in] dp    vice partition object for this volume
762  * @param[in] name  volume header file name
763  *
764  * @return none
765  */
766 void
767 HandleVolume(struct DiskPartition64 *dp, char *name)
768 {
769     struct VolumeHeader header;
770     struct VolumeDiskHeader diskHeader;
771     FD_t fd = INVALID_FD;
772     Volume *vp;
773     char headerName[1024];
774     afs_sfsize_t n;
775
776     snprintf(headerName, sizeof headerName, "%s" OS_DIRSEP "%s",
777              VPartitionPath(dp), name);
778     if ((fd = OS_OPEN(headerName, O_RDONLY, 0666)) == INVALID_FD) {
779         fprintf(stderr, "%s: Cannot open volume header %s\n", progname, name);
780         return;
781     }
782     if (OS_SIZE(fd) < 0) {
783         fprintf(stderr, "%s: Cannot read volume header %s\n", progname, name);
784         OS_CLOSE(fd);
785         return;
786     }
787     n = OS_READ(fd, &diskHeader, sizeof(diskHeader));
788     if (n != sizeof(diskHeader)
789         || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
790         fprintf(stderr, "%s: Error reading volume header %s\n", progname,
791                 name);
792         OS_CLOSE(fd);
793         return;
794     }
795     if (diskHeader.stamp.version != VOLUMEHEADERVERSION) {
796         fprintf(stderr,
797                 "%s: Volume %s, version number is incorrect; volume needs to be salvaged\n",
798                 progname, name);
799         OS_CLOSE(fd);
800         return;
801     }
802     DiskToVolumeHeader(&header, &diskHeader);
803     if (DumpHeader || ShowSizes) {
804         HandleHeaderFiles(dp, fd, &header);
805     }
806     OS_CLOSE(fd);
807     vp = AttachVolume(dp, name, &header);
808     if (!vp) {
809         fprintf(stderr, "%s: Error attaching volume header %s\n",
810                 progname, name);
811         return;
812     }
813     if (DumpInfo) {
814         PrintHeader(vp);
815     }
816     if (DumpVnodes || ShowSizes || ShowOrphaned) {
817         HandleVnodes(vp, vLarge);
818     }
819     if (DumpVnodes || ShowSizes || SaveInodes || ShowOrphaned) {
820         HandleVnodes(vp, vSmall);
821     }
822     if (ShowSizes) {
823         volumeTotals.diskused_k = V_diskused(vp);
824         volumeTotals.size_k =
825             volumeTotals.auxsize_k + volumeTotals.vnodesize_k;
826         PrintVolumeSizes(vp);
827     }
828     free(vp->header);
829     free(vp);
830 }
831
832 /**
833  * volinfo program entry
834  */
835 int
836 main(int argc, char **argv)
837 {
838     struct cmd_syndesc *ts;
839     afs_int32 code;
840
841     ts = cmd_CreateSyntax(NULL, handleit, NULL, "Dump volume's internal state");
842     cmd_AddParm(ts, "-online", CMD_FLAG, CMD_OPTIONAL,
843                 "Get info from running fileserver");
844     cmd_AddParm(ts, "-vnode", CMD_FLAG, CMD_OPTIONAL, "Dump vnode info");
845     cmd_AddParm(ts, "-date", CMD_FLAG, CMD_OPTIONAL,
846                 "Also dump vnode's mod date");
847     cmd_AddParm(ts, "-inode", CMD_FLAG, CMD_OPTIONAL,
848                 "Also dump vnode's inode number");
849     cmd_AddParm(ts, "-itime", CMD_FLAG, CMD_OPTIONAL,
850                 "Dump special inode's mod times");
851     cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL,
852                 "AFS partition name or id (default current partition)");
853     cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
854     cmd_AddParm(ts, "-header", CMD_FLAG, CMD_OPTIONAL,
855                 "Dump volume's header info");
856     cmd_AddParm(ts, "-sizeOnly", CMD_FLAG, CMD_OPTIONAL,
857                 "Dump volume's size");
858     cmd_AddParm(ts, "-fixheader", CMD_FLAG, CMD_OPTIONAL,
859                 "Try to fix header");
860     cmd_AddParm(ts, "-saveinodes", CMD_FLAG, CMD_OPTIONAL,
861                 "Try to save all inodes");
862     cmd_AddParm(ts, "-orphaned", CMD_FLAG, CMD_OPTIONAL,
863                 "List all dir/files without a parent");
864 #if defined(AFS_NAMEI_ENV)
865     cmd_AddParm(ts, "-filenames", CMD_FLAG, CMD_OPTIONAL, "Also dump vnode's namei filename");
866 #endif
867     code = cmd_Dispatch(argc, argv);
868     return code;
869 }
870
871 #define typestring(type) (type == RWVOL? "read/write": type == ROVOL? "readonly": type == BACKVOL? "backup": "unknown")
872
873 /**
874  * Print the volume header information
875  *
876  * @param[in]  volume object
877  *
878  * @return none
879  */
880 void
881 PrintHeader(Volume * vp)
882 {
883     printf("Volume header for volume %u (%s)\n", V_id(vp), V_name(vp));
884     printf("stamp.magic = %x, stamp.version = %u\n", V_stamp(vp).magic,
885            V_stamp(vp).version);
886     printf
887         ("inUse = %d, inService = %d, blessed = %d, needsSalvaged = %d, dontSalvage = %d\n",
888          V_inUse(vp), V_inService(vp), V_blessed(vp), V_needsSalvaged(vp),
889          V_dontSalvage(vp));
890     printf
891         ("type = %d (%s), uniquifier = %u, needsCallback = %d, destroyMe = %x\n",
892          V_type(vp), typestring(V_type(vp)), V_uniquifier(vp),
893          V_needsCallback(vp), V_destroyMe(vp));
894     printf
895         ("id = %u, parentId = %u, cloneId = %u, backupId = %u, restoredFromId = %u\n",
896          V_id(vp), V_parentId(vp), V_cloneId(vp), V_backupId(vp),
897          V_restoredFromId(vp));
898     printf
899         ("maxquota = %d, minquota = %d, maxfiles = %d, filecount = %d, diskused = %d\n",
900          V_maxquota(vp), V_minquota(vp), V_maxfiles(vp), V_filecount(vp),
901          V_diskused(vp));
902     printf("creationDate = %s, copyDate = %s\n", date(V_creationDate(vp)),
903            date(V_copyDate(vp)));
904     printf("backupDate = %s, expirationDate = %s\n", date(V_backupDate(vp)),
905            date(V_expirationDate(vp)));
906     printf("accessDate = %s, updateDate = %s\n", date(V_accessDate(vp)),
907            date(V_updateDate(vp)));
908     printf("owner = %u, accountNumber = %u\n", V_owner(vp),
909            V_accountNumber(vp));
910     printf
911         ("dayUse = %u; week = (%u, %u, %u, %u, %u, %u, %u), dayUseDate = %s\n",
912          V_dayUse(vp), V_weekUse(vp)[0], V_weekUse(vp)[1], V_weekUse(vp)[2],
913          V_weekUse(vp)[3], V_weekUse(vp)[4], V_weekUse(vp)[5],
914          V_weekUse(vp)[6], date(V_dayUseDate(vp)));
915     printf("volUpdateCounter = %u\n", V_volUpCounter(vp));
916 }
917
918 /**
919  * Get the size and times of a file
920  *
921  * @param[in]  fd     file descriptor of file to stat
922  * @param[out] size   size of the file
923  * @param[out] ctime  ctime of file as a formatted string
924  * @param[out] mtime  mtime of file as a formatted string
925  * @param[out] atime  atime of file as a formatted string
926  *
927  * @return error code
928  *   @retval 0 success
929  *   @retval -1 failed to retrieve file information
930  */
931 static int
932 GetFileInfo(FD_t fd, afs_sfsize_t * size, char **ctime, char **mtime,
933             char **atime)
934 {
935 #ifdef AFS_NT40_ENV
936     BY_HANDLE_FILE_INFORMATION fi;
937     LARGE_INTEGER fsize;
938     if (!GetFileInformationByHandle(fd, &fi)) {
939         fprintf(stderr, "%s: GetFileInformationByHandle failed\n", progname);
940         return -1;
941     }
942     if (!GetFileSizeEx(fd, &fsize)) {
943         fprintf(stderr, "%s: GetFileSizeEx failed\n", progname);
944         return -1;
945     }
946     *size = fsize.QuadPart;
947     *ctime = "N/A";
948     *mtime = NT_date(&fi.ftLastWriteTime);
949     *atime = NT_date(&fi.ftLastAccessTime);
950 #else
951     struct afs_stat_st status;
952     if (afs_fstat(fd, &status) == -1) {
953         fprintf(stderr, "%s: fstat failed %d\n", progname, errno);
954         return -1;
955     }
956     *size = status.st_size;
957     *ctime = date(status.st_ctime);
958     *mtime = date(status.st_mtime);
959     *atime = date(status.st_atime);
960 #endif
961     return 0;
962 }
963
964 /**
965  * Copy the inode data to a file in the current directory.
966  *
967  * @param[in] vp     volume object
968  * @param[in] vnode  vnode object
969  * @param[in] inode  inode of the source file
970  *
971  * @return none
972  */
973 static void
974 SaveInode(Volume * vp, struct VnodeDiskObject *vnode, Inode ino)
975 {
976     IHandle_t *ih;
977     FdHandle_t *fdP;
978     char nfile[50], buffer[256];
979     int ofd = 0;
980     afs_foff_t total;
981     ssize_t len;
982
983     if (!VALID_INO(ino)) {
984         return;
985     }
986
987     IH_INIT(ih, V_device(vp), V_parentId(vp), ino);
988     fdP = IH_OPEN(ih);
989     if (fdP == NULL) {
990         fprintf(stderr,
991                 "%s: Can't open inode %s error %d (ignored)\n",
992                 progname, PrintInode(NULL, ino), errno);
993         return;
994     }
995     snprintf(nfile, sizeof nfile, "TmpInode.%s", PrintInode(NULL, ino));
996     ofd = afs_open(nfile, O_CREAT | O_RDWR | O_TRUNC, 0600);
997     if (ofd < 0) {
998         fprintf(stderr,
999                 "%s: Can't create file %s; error %d (ignored)\n",
1000                 progname, nfile, errno);
1001
1002         FDH_REALLYCLOSE(fdP);
1003         IH_RELEASE(ih);
1004         return;
1005     }
1006     total = 0;
1007     while (1) {
1008         ssize_t nBytes;
1009         len = FDH_PREAD(fdP, buffer, sizeof(buffer), total);
1010         if (len < 0) {
1011             FDH_REALLYCLOSE(fdP);
1012             IH_RELEASE(ih);
1013             close(ofd);
1014             unlink(nfile);
1015             fprintf(stderr,
1016                     "%s: Error while reading from inode %s (%d)\n",
1017                     progname, PrintInode(NULL, ino), errno);
1018             return;
1019         }
1020         if (len == 0)
1021             break;              /* No more input */
1022         nBytes = write(ofd, buffer, len);
1023         if (nBytes != len) {
1024             FDH_REALLYCLOSE(fdP);
1025             IH_RELEASE(ih);
1026             close(ofd);
1027             unlink(nfile);
1028             fprintf(stderr,
1029                     "%s: Error while writing to \"%s\" (%d - ignored)\n",
1030                     progname, nfile, errno);
1031             return;
1032         }
1033         total += len;
1034     }
1035
1036     FDH_REALLYCLOSE(fdP);
1037     IH_RELEASE(ih);
1038     close(ofd);
1039     printf("... Copied inode %s to file %s (%lu bytes)\n",
1040            PrintInode(NULL, ino), nfile, (unsigned long)total);
1041 }
1042
1043 /**
1044  * Scan a volume index and handle each vnode
1045  *
1046  * @param[in] vp      volume object
1047  * @param[in] class   which index to scan
1048  *
1049  * @return none
1050  */
1051 void
1052 HandleVnodes(Volume * vp, VnodeClass class)
1053 {
1054     afs_int32 diskSize =
1055         (class == vSmall ? SIZEOF_SMALLDISKVNODE : SIZEOF_LARGEDISKVNODE);
1056     char buf[SIZEOF_LARGEDISKVNODE];
1057     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
1058     StreamHandle_t *file = NULL;
1059     int vnodeIndex;
1060     afs_sfsize_t nVnodes;
1061     afs_foff_t offset = 0;
1062     Inode ino;
1063     IHandle_t *ih = vp->vnodeIndex[class].handle;
1064     FdHandle_t *fdP = NULL;
1065     afs_sfsize_t size;
1066     char *ctime, *atime, *mtime;
1067
1068     /* print vnode table heading */
1069     if (class == vLarge) {
1070         if (DumpInfo) {
1071             printf("\nLarge vnodes (directories)\n");
1072         }
1073     } else {
1074         if (DumpInfo) {
1075             printf("\nSmall vnodes(files, symbolic links)\n");
1076             fflush(stdout);
1077         }
1078         if (SaveInodes) {
1079             printf("Saving all volume files to current directory ...\n");
1080             if (ShowSizes) {
1081                 PrintingVolumeSizes = 0;        /* print heading again */
1082             }
1083         }
1084     }
1085
1086     fdP = IH_OPEN(ih);
1087     if (fdP == NULL) {
1088         fprintf(stderr, "%s: open failed: ", progname);
1089         goto error;
1090     }
1091
1092     file = FDH_FDOPEN(fdP, "r");
1093     if (!file) {
1094         fprintf(stderr, "%s: fdopen failed\n", progname);
1095         goto error;
1096     }
1097
1098     if (GetFileInfo(fdP->fd_fd, &size, &ctime, &atime, &mtime) != 0) {
1099         goto error;
1100     }
1101     if (InodeTimes) {
1102         printf("ichanged : %s\nimodified: %s\niaccessed: %s\n\n", ctime,
1103                mtime, atime);
1104     }
1105
1106     nVnodes = (size / diskSize) - 1;
1107     if (nVnodes > 0) {
1108         STREAM_ASEEK(file, diskSize);
1109     } else
1110         nVnodes = 0;
1111
1112     for (vnodeIndex = 0;
1113          nVnodes && STREAM_READ(vnode, diskSize, 1, file) == 1;
1114          nVnodes--, vnodeIndex++, offset += diskSize) {
1115
1116         ino = VNDISK_GET_INO(vnode);
1117         if (ShowSizes) {
1118             afs_fsize_t fileLength;
1119
1120             VNDISK_GET_LEN(fileLength, vnode);
1121             if (fileLength > 0) {
1122                 volumeTotals.vnodesize += fileLength;
1123                 volumeTotals.vnodesize_k += fileLength / 1024;
1124             }
1125         }
1126         if (SaveInodes && (class == vSmall)) {
1127             SaveInode(vp, vnode, ino);
1128         }
1129         if (DumpVnodes || ShowOrphaned) {
1130             PrintVnode(offset, vnode,
1131                        bitNumberToVnodeNumber(vnodeIndex, class), ino, vp);
1132         }
1133     }
1134
1135   error:
1136     if (file) {
1137         STREAM_CLOSE(file);
1138     }
1139     if (fdP) {
1140         FDH_CLOSE(fdP);
1141     }
1142 }
1143
1144 /**
1145  * Print vnode information
1146  *
1147  * @param[in] offset       index offset of this vnode
1148  * @param[in] vnode        vnode object to be printed
1149  * @param[in] vnodeNumber  vnode number
1150  * @param[in] ino          fileserver inode number
1151  * @param[in] vp           parent volume of the vnode
1152  *
1153  * @return none
1154  */
1155 void
1156 PrintVnode(afs_foff_t offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
1157            Inode ino, Volume * vp)
1158 {
1159 #if defined(AFS_NAMEI_ENV)
1160     IHandle_t *ihtmpp;
1161     namei_t filename;
1162 #endif
1163     afs_fsize_t fileLength;
1164
1165     VNDISK_GET_LEN(fileLength, vnode);
1166
1167     /* The check for orphaned vnodes is currently limited to non-empty
1168      * vnodes with a parent of zero (and which are not the first entry
1169      * in the index). */
1170     if (ShowOrphaned && (fileLength == 0 || vnode->parent || !offset))
1171         return;
1172
1173     printf
1174         ("%10lld Vnode %u.%u.%u cloned: %u, length: %llu linkCount: %d parent: %u",
1175          (long long)offset, vnodeNumber, vnode->uniquifier, vnode->dataVersion,
1176          vnode->cloned, (afs_uintmax_t) fileLength, vnode->linkCount,
1177          vnode->parent);
1178     if (DumpInodeNumber)
1179         printf(" inode: %s", PrintInode(NULL, ino));
1180     if (DumpDate)
1181         printf(" ServerModTime: %s", date(vnode->serverModifyTime));
1182 #if defined(AFS_NAMEI_ENV)
1183     if (PrintFileNames) {
1184         IH_INIT(ihtmpp, V_device(vp), V_parentId(vp), ino);
1185         namei_HandleToName(&filename, ihtmpp);
1186 #if !defined(AFS_NT40_ENV)
1187         printf(" UFS-Filename: %s", filename.n_path);
1188 #else
1189         printf(" NTFS-Filename: %s", filename.n_path);
1190 #endif
1191     }
1192 #endif
1193     printf("\n");
1194 }