large-partition-support-20080305
[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 RCSID
21     ("$Header$");
22
23 #include <ctype.h>
24 #include <errno.h>
25 #include <sys/stat.h>
26 #include <stdio.h>
27 #include <string.h>
28 #ifdef AFS_NT40_ENV
29 #include <fcntl.h>
30 #include <time.h>
31 #include <io.h>
32 #else
33 #include <sys/param.h>
34 #include <sys/file.h>
35 #include <sys/time.h>
36 #endif
37 #include <afs/cmd.h>
38
39 #include <rx/xdr.h>
40 #include <afs/afsint.h>
41 #include "nfs.h"
42 #include <afs/errors.h>
43 #include "lock.h"
44 #include "lwp.h"
45 #include <afs/afssyscalls.h>
46 #include "ihandle.h"
47 #include "vnode.h"
48 #include "volume.h"
49 #include "partition.h"
50 #include "viceinode.h"
51 #include "volinodes.h"
52 #include <afs/afssyscalls.h>
53
54 #ifdef _AIX
55 #include <time.h>
56 #endif
57
58 #include <dirent.h>
59
60 #ifdef O_LARGEFILE
61 #define afs_stat        stat64
62 #define afs_fstat       fstat64
63 #define afs_open        open64
64 #else /* !O_LARGEFILE */
65 #define afs_stat        stat
66 #define afs_fstat       fstat
67 #define afs_open        open
68 #endif /* !O_LARGEFILE */
69
70 int DumpVnodes = 0;             /* Dump everything, i.e. summary of all vnodes */
71 int DumpInodeNumber = 0;        /* Dump inode numbers with vnodes */
72 int DumpDate = 0;               /* Dump vnode date (server modify date) with vnode */
73 int InodeTimes = 0;             /* Dump some of the dates associated with inodes */
74 #if defined(AFS_NAMEI_ENV)
75 int PrintFileNames = 0;
76 #endif
77 int online = 0;
78 int dheader = 0;
79 int dsizeOnly = 0, totvolsize = 0, Vauxsize = 0, Vdiskused = 0, Vvnodesize =
80     0;
81 int Vvnodesize_k = 0, Vauxsize_k = 0;
82 int Totvolsize = 0, TVauxsize = 0, TVdiskused = 0, TVvnodesize = 0;
83 int Stotvolsize = 0, SVauxsize = 0, SVdiskused = 0, SVvnodesize = 0;
84 int fixheader = 0, saveinodes = 0, orphaned = 0;
85 int VolumeChanged;
86
87 /* Forward Declarations */
88 void PrintHeader(register Volume * vp);
89 void HandleAllPart(void);
90 void HandlePart(struct DiskPartition64 *partP);
91 void HandleVolume(struct DiskPartition64 *partP, char *name);
92 struct DiskPartition64 *FindCurrentPartition(void);
93 Volume *AttachVolume(struct DiskPartition64 *dp, char *volname,
94                      register struct VolumeHeader *header);
95 #if defined(AFS_NAMEI_ENV)
96 void PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
97                 Inode ino, Volume * vp);
98 #else
99 void PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
100                 Inode ino);
101 #endif
102 void PrintVnodes(Volume * vp, VnodeClass class);
103
104 char *
105 date(time_t date)
106 {
107 #define MAX_DATE_RESULT 100
108     static char results[8][MAX_DATE_RESULT];
109     static next;
110     struct tm *tm = localtime(&date);
111     char buf[32];
112
113     (void)strftime(buf, 32, "%Y/%m/%d.%H:%M:%S", tm);   /* NT does not have %T */
114     (void)afs_snprintf(results[next = (next + 1) & 7], MAX_DATE_RESULT,
115                        "%lu (%s)", (unsigned long)date, buf);
116     return results[next];
117 }
118
119 #ifndef AFS_NT40_ENV
120 #include "AFS_component_version_number.c"
121 #endif
122
123 char name[VMAXPATHLEN];
124
125 char BU[1000];
126
127 int
128 ReadHdr1(IHandle_t * ih, char *to, int size, u_int magic, u_int version)
129 {
130     struct versionStamp *vsn;
131     int bad = 0;
132     int code;
133
134     vsn = (struct versionStamp *)to;
135
136     code = IH_IREAD(ih, 0, to, size);
137     if (code != size)
138         return -1;
139
140     if (vsn->magic != magic) {
141         bad++;
142         printf("Inode %s: Bad magic %x (%x): IGNORED\n",
143                PrintInode(NULL, ih->ih_ino), vsn->magic, magic);
144     }
145
146     /* Check is conditional, in case caller wants to inspect version himself */
147     if (version && vsn->version != version) {
148         bad++;
149         printf("Inode %s: Bad version %x (%x): IGNORED\n",
150                PrintInode(NULL, ih->ih_ino), vsn->version, version);
151     }
152     if (bad && fixheader) {
153         vsn->magic = magic;
154         vsn->version = version;
155         printf("Special index inode %s has a bad header. Reconstructing...\n",
156                PrintInode(NULL, ih->ih_ino));
157         code = IH_IWRITE(ih, 0, to, size);
158         if (code != size) {
159             printf("Write failed; header left in damaged state\n");
160         }
161     } else {
162         if (!dsizeOnly && !saveinodes) {
163             printf("Inode %s: Good magic %x and version %x\n",
164                    PrintInode(NULL, ih->ih_ino), magic, version);
165         }
166     }
167     return 0;
168 }
169
170
171 Volume *
172 AttachVolume(struct DiskPartition64 * dp, char *volname,
173              register struct VolumeHeader * header)
174 {
175     register Volume *vp;
176     afs_int32 ec = 0;
177
178     vp = (Volume *) calloc(1, sizeof(Volume));
179     vp->specialStatus = 0;
180     vp->device = dp->device;
181     vp->partition = dp;
182     IH_INIT(vp->vnodeIndex[vLarge].handle, dp->device, header->parent,
183             header->largeVnodeIndex);
184     IH_INIT(vp->vnodeIndex[vSmall].handle, dp->device, header->parent,
185             header->smallVnodeIndex);
186     IH_INIT(vp->diskDataHandle, dp->device, header->parent,
187             header->volumeInfo);
188     IH_INIT(V_linkHandle(vp), dp->device, header->parent, header->linkTable);
189     vp->cacheCheck = 0;         /* XXXX */
190     vp->shuttingDown = 0;
191     vp->goingOffline = 0;
192     vp->nUsers = 1;
193     vp->header = (struct volHeader *)calloc(1, sizeof(*vp->header));
194     ec = ReadHdr1(V_diskDataHandle(vp), (char *)&V_disk(vp),
195                   sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
196     if (!ec) {
197         struct IndexFileHeader iHead;
198         ec = ReadHdr1(vp->vnodeIndex[vSmall].handle, (char *)&iHead,
199                       sizeof(iHead), SMALLINDEXMAGIC, SMALLINDEXVERSION);
200     }
201     if (!ec) {
202         struct IndexFileHeader iHead;
203         ec = ReadHdr1(vp->vnodeIndex[vLarge].handle, (char *)&iHead,
204                       sizeof(iHead), LARGEINDEXMAGIC, LARGEINDEXVERSION);
205     }
206 #ifdef AFS_NAMEI_ENV
207     if (!ec) {
208         struct versionStamp stamp;
209         ec = ReadHdr1(V_linkHandle(vp), (char *)&stamp, sizeof(stamp),
210                       LINKTABLEMAGIC, LINKTABLEVERSION);
211     }
212 #endif
213     if (ec)
214         return (Volume *) 0;
215     return vp;
216 }
217
218
219 static int
220 handleit(struct cmd_syndesc *as, void *arock)
221 {
222     register struct cmd_item *ti;
223     int err = 0;
224     int volumeId = 0;
225     char *partName = 0;
226     struct DiskPartition64 *partP = NULL;
227
228
229 #ifndef AFS_NT40_ENV
230     if (geteuid() != 0) {
231         printf("vol-info must be run as root; sorry\n");
232         exit(1);
233     }
234 #endif
235
236     if (as->parms[0].items)
237         online = 1;
238     else
239         online = 0;
240     if (as->parms[1].items)
241         DumpVnodes = 1;
242     else
243         DumpVnodes = 0;
244     if (as->parms[2].items)
245         DumpDate = 1;
246     else
247         DumpDate = 0;
248     if (as->parms[3].items)
249         DumpInodeNumber = 1;
250     else
251         DumpInodeNumber = 0;
252     if (as->parms[4].items)
253         InodeTimes = 1;
254     else
255         InodeTimes = 0;
256     if ((ti = as->parms[5].items))
257         partName = ti->data;
258     if ((ti = as->parms[6].items))
259         volumeId = strtoul(ti->data, NULL, 10);
260     if (as->parms[7].items)
261         dheader = 1;
262     else
263         dheader = 0;
264     if (as->parms[8].items) {
265         dsizeOnly = 1;
266         dheader = 1;
267         DumpVnodes = 1;
268     } else
269         dsizeOnly = 0;
270     if (as->parms[9].items) {
271         fixheader = 1;
272     } else
273         fixheader = 0;
274     if (as->parms[10].items) {
275         saveinodes = 1;
276         dheader = 1;
277         DumpVnodes = 1;
278     } else
279         saveinodes = 0;
280     if (as->parms[11].items) {
281         orphaned = 1;
282         DumpVnodes = 1;
283     } else
284 #if defined(AFS_NAMEI_ENV)
285     if (as->parms[12].items) {
286         PrintFileNames = 1;
287         DumpVnodes = 1;
288     } else
289 #endif
290         orphaned = 0;
291
292     DInit(10);
293
294     err = VAttachPartitions();
295     if (err) {
296         printf("%d partitions had errors during attach.\n", err);
297     }
298
299     if (partName) {
300         partP = VGetPartition(partName, 0);
301         if (!partP) {
302             printf("%s is not an AFS partition name on this server.\n",
303                    partName);
304             exit(1);
305         }
306     }
307
308     if (!volumeId) {
309         if (!partP) {
310             HandleAllPart();
311         } else {
312             HandlePart(partP);
313         }
314     } else {
315         char name1[128];
316
317         if (!partP) {
318             partP = FindCurrentPartition();
319             if (!partP) {
320                 printf("Current partition is not a vice partition.\n");
321                 exit(1);
322             }
323         }
324         (void)afs_snprintf(name1, sizeof name1, VFORMAT,
325                            (unsigned long)volumeId);
326         if (dsizeOnly && !saveinodes)
327             printf
328                 ("Volume-Id\t  Volsize  Auxsize Inodesize  AVolsize SizeDiff                (VolName)\n");
329         HandleVolume(partP, name1);
330     }
331     return 0;
332 }
333
334 #ifdef AFS_NT40_ENV
335 #include <direct.h>
336 struct DiskPartition64 *
337 FindCurrentPartition()
338 {
339     int dr = _getdrive();
340     struct DiskPartition64 *dp;
341
342     dr--;
343     for (dp = DiskPartitionList; dp; dp = dp->next) {
344         if (*dp->devName - 'A' == dr)
345             break;
346     }
347     if (!dp) {
348         printf("Current drive is not a valid vice partition.\n");
349     }
350     return dp;
351 }
352 #else
353 struct DiskPartition64 *
354 FindCurrentPartition()
355 {
356     char partName[1024];
357     char tmp = '\0';
358     char *p;
359     struct DiskPartition64 *dp;
360
361     if (!getcwd(partName, 1023)) {
362         perror("pwd");
363         exit(1);
364     }
365     p = strchr(&partName[1], '/');
366     if (p) {
367         tmp = *p;
368         *p = '\0';
369     }
370     if (!(dp = VGetPartition(partName, 0))) {
371         if (tmp)
372             *p = tmp;
373         printf("%s is not a valid vice partition.\n", partName);
374         exit(1);
375     }
376     return dp;
377 }
378 #endif
379
380 void
381 HandleAllPart(void)
382 {
383     struct DiskPartition64 *partP;
384
385
386     for (partP = DiskPartitionList; partP; partP = partP->next) {
387         printf("Processing Partition %s:\n", partP->name);
388         HandlePart(partP);
389         Stotvolsize += Totvolsize;
390         SVauxsize += TVauxsize;
391         SVvnodesize += TVvnodesize;
392         SVdiskused += TVdiskused;
393     }
394
395     if (dsizeOnly) {
396         printf("\nServer Totals%12d%9d%10d%10d%9d\n", SVdiskused, SVauxsize,
397                SVvnodesize, Stotvolsize, Stotvolsize - SVdiskused);
398     }
399 }
400
401
402 void
403 HandlePart(struct DiskPartition64 *partP)
404 {
405     int nvols = 0;
406     DIR *dirp;
407     struct dirent *dp;
408 #ifdef AFS_NT40_ENV
409     char pname[64];
410     char *p = pname;
411     (void)sprintf(pname, "%s\\", VPartitionPath(partP));
412 #else
413     char *p = VPartitionPath(partP);
414 #endif
415
416     if (chdir(p) == -1) {
417         printf("Can't chdir to partition %s; giving up\n", p);
418         exit(1);
419     }
420     if ((dirp = opendir(".")) == NULL) {
421         printf("Can't read directory %s; giving up\n", p);
422         exit(1);
423     }
424     if (dsizeOnly && !saveinodes)
425         printf
426             ("Volume-Id\t  Volsize  Auxsize Inodesize  AVolsize SizeDiff                (VolName)\n");
427     while ((dp = readdir(dirp))) {
428         p = (char *)strrchr(dp->d_name, '.');
429         if (p != NULL && strcmp(p, VHDREXT) == 0) {
430             HandleVolume(partP, dp->d_name);
431             Totvolsize += totvolsize;
432             TVauxsize += Vauxsize;
433             TVvnodesize += Vvnodesize;
434             TVdiskused += Vdiskused;
435             nvols++;
436         }
437     }
438     closedir(dirp);
439     if (dsizeOnly) {
440         printf("\nPart Totals  %12d%9d%10d%10d%9d (%d volumes)\n\n",
441                TVdiskused, TVauxsize, TVvnodesize, Totvolsize,
442                Totvolsize - TVdiskused, nvols);
443     }
444 }
445
446
447 void
448 HandleVolume(struct DiskPartition64 *dp, char *name)
449 {
450     struct VolumeHeader header;
451     struct VolumeDiskHeader diskHeader;
452     struct afs_stat status, stat;
453     register int fd;
454     Volume *vp;
455     IHandle_t *ih;
456     char headerName[1024];
457
458     if (online) {
459         printf("volinfo: -online not supported\n");
460         exit(1);
461     } else {
462         afs_int32 n;
463
464         (void)afs_snprintf(headerName, sizeof headerName, "%s/%s",
465                            VPartitionPath(dp), name);
466         if ((fd = afs_open(headerName, O_RDONLY)) == -1
467             || afs_fstat(fd, &status) == -1) {
468             printf("Volinfo: Cannot read volume header %s\n", name);
469             close(fd);
470             exit(1);
471         }
472         n = read(fd, &diskHeader, sizeof(diskHeader));
473
474         if (n != sizeof(diskHeader)
475             || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
476             printf("Volinfo: Error reading volume header %s\n", name);
477             exit(1);
478         }
479         if (diskHeader.stamp.version != VOLUMEHEADERVERSION) {
480             printf
481                 ("Volinfo: Volume %s, version number is incorrect; volume needs salvage\n",
482                  name);
483             exit(1);
484         }
485         DiskToVolumeHeader(&header, &diskHeader);
486
487         if (dheader) {
488             FdHandle_t *fdP;
489             int size = 0;
490             int code;
491
492             if (afs_fstat(fd, &stat) == -1) {
493                 perror("stat");
494                 exit(1);
495             }
496             if (!dsizeOnly && !saveinodes) {
497                 printf("Volume header (size = %d):\n", size = stat.st_size);
498                 printf("\tstamp\t= 0x%x\n", header.stamp.version);
499                 printf("\tVolId\t= %u\n", header.id);
500             }
501
502             IH_INIT(ih, dp->device, header.parent, header.volumeInfo);
503             fdP = IH_OPEN(ih);
504             if (fdP == NULL) {
505                 perror("opening volume info");
506                 exit(1);
507             }
508             code = FDH_SIZE(fdP);
509             if (code == -1) {
510                 perror("fstat");
511                 exit(1);
512             }
513             FDH_REALLYCLOSE(fdP);
514             IH_RELEASE(ih);
515             size += code;
516             if (!dsizeOnly && !saveinodes) {
517                 printf("\tparent\t= %u\n", header.parent);
518                 printf("\tInfo inode\t= %s (size = %d)\n",
519                        PrintInode(NULL, header.volumeInfo), code);
520             }
521
522             IH_INIT(ih, dp->device, header.parent, header.smallVnodeIndex);
523             fdP = IH_OPEN(ih);
524             if (fdP == NULL) {
525                 perror("opening small vnode index");
526                 exit(1);
527             }
528             code = FDH_SIZE(fdP);
529             if (code == -1) {
530                 perror("fstat");
531                 exit(1);
532             }
533             FDH_REALLYCLOSE(fdP);
534             IH_RELEASE(ih);
535             size += code;
536             if (!dsizeOnly && !saveinodes) {
537                 printf("\tSmall inode\t= %s (size = %d)\n",
538                        PrintInode(NULL, header.smallVnodeIndex), code);
539             }
540
541             IH_INIT(ih, dp->device, header.parent, header.largeVnodeIndex);
542             fdP = IH_OPEN(ih);
543             if (fdP == NULL) {
544                 perror("opening large vnode index");
545                 exit(1);
546             }
547             code = FDH_SIZE(fdP);
548             if (code == -1) {
549                 perror("fstat");
550                 exit(1);
551             }
552             FDH_REALLYCLOSE(fdP);
553             IH_RELEASE(ih);
554             size += code;
555             if (!dsizeOnly && !saveinodes) {
556                 printf("\tLarge inode\t= %s (size = %d)\n",
557                        PrintInode(NULL, header.largeVnodeIndex), code);
558 #ifndef AFS_NT40_ENV
559                 printf("Total aux volume size = %d\n\n", size);
560 #endif
561             }
562 #ifdef AFS_NAMEI_ENV
563             IH_INIT(ih, dp->device, header.parent, header.linkTable);
564             fdP = IH_OPEN(ih);
565             if (fdP == NULL) {
566                 perror("opening link table index");
567                 exit(1);
568             }
569             code = FDH_SIZE(fdP);
570             if (code == -1) {
571                 perror("fstat");
572                 exit(1);
573             }
574             FDH_REALLYCLOSE(fdP);
575             IH_RELEASE(ih);
576             size += code;
577             if (!dsizeOnly && !saveinodes) {
578                 printf("\tLink inode\t= %s (size = %d)\n",
579                        PrintInode(NULL, header.linkTable), code);
580                 printf("Total aux volume size = %d\n\n", size);
581             }
582 #endif
583             Vauxsize = size;
584             Vauxsize_k = size / 1024;
585         }
586         close(fd);
587         vp = AttachVolume(dp, name, &header);
588         if (!vp) {
589             printf("Volinfo: Error attaching volume header %s\n", name);
590             return;
591         }
592     }
593     PrintHeader(vp);
594     if (DumpVnodes) {
595         if (!dsizeOnly && !saveinodes)
596             printf("\nLarge vnodes (directories)\n");
597         PrintVnodes(vp, vLarge);
598         if (!dsizeOnly && !saveinodes) {
599             printf("\nSmall vnodes(files, symbolic links)\n");
600             fflush(stdout);
601         }
602         if (saveinodes)
603             printf("Saving all volume files to current directory ...\n");
604         PrintVnodes(vp, vSmall);
605     }
606     if (dsizeOnly) {
607         totvolsize = Vauxsize_k + Vvnodesize_k;
608         if (saveinodes)
609             printf
610                 ("Volume-Id\t  Volsize  Auxsize Inodesize  AVolsize SizeDiff                (VolName)\n");
611         printf("%u\t%9d%9d%10d%10d%9d\t%24s\n", V_id(vp), Vdiskused,
612                Vauxsize_k, Vvnodesize_k, totvolsize, totvolsize - Vdiskused,
613                V_name(vp));
614     }
615     free(vp->header);
616     free(vp);
617 }
618
619 int
620 main(int argc, char **argv)
621 {
622     register struct cmd_syndesc *ts;
623     afs_int32 code;
624
625     ts = cmd_CreateSyntax(NULL, handleit, NULL, "Dump volume's internal state");
626     cmd_AddParm(ts, "-online", CMD_FLAG, CMD_OPTIONAL,
627                 "Get info from running fileserver");
628     cmd_AddParm(ts, "-vnode", CMD_FLAG, CMD_OPTIONAL, "Dump vnode info");
629     cmd_AddParm(ts, "-date", CMD_FLAG, CMD_OPTIONAL,
630                 "Also dump vnode's mod date");
631     cmd_AddParm(ts, "-inode", CMD_FLAG, CMD_OPTIONAL,
632                 "Dump vnode's inode number");
633     cmd_AddParm(ts, "-itime", CMD_FLAG, CMD_OPTIONAL,
634                 "Dump special inode's mod times");
635     cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL,
636                 "AFS partition name (default current partition)");
637     cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
638     cmd_AddParm(ts, "-header", CMD_FLAG, CMD_OPTIONAL,
639                 "Dump volume's header info");
640     cmd_AddParm(ts, "-sizeOnly", CMD_FLAG, CMD_OPTIONAL,
641                 "Dump volume's size");
642     cmd_AddParm(ts, "-fixheader", CMD_FLAG, CMD_OPTIONAL,
643                 "Try to fix header");
644     cmd_AddParm(ts, "-saveinodes", CMD_FLAG, CMD_OPTIONAL,
645                 "Try to save all inodes");
646     cmd_AddParm(ts, "-orphaned", CMD_FLAG, CMD_OPTIONAL,
647                 "List all dir/files without a parent");
648 #if defined(AFS_NAMEI_ENV)
649     cmd_AddParm(ts, "-filenames", CMD_FLAG, CMD_OPTIONAL, "Print filenames");
650 #endif
651     code = cmd_Dispatch(argc, argv);
652     return code;
653 }
654
655 #define typestring(type) (type == RWVOL? "read/write": type == ROVOL? "readonly": type == BACKVOL? "backup": "unknown")
656
657 void
658 PrintHeader(register Volume * vp)
659 {
660     Vdiskused = V_diskused(vp);
661     if (dsizeOnly || saveinodes)
662         return;
663     printf("Volume header for volume %u (%s)\n", V_id(vp), V_name(vp));
664     printf("stamp.magic = %x, stamp.version = %u\n", V_stamp(vp).magic,
665            V_stamp(vp).version);
666     printf
667         ("inUse = %d, inService = %d, blessed = %d, needsSalvaged = %d, dontSalvage = %d\n",
668          V_inUse(vp), V_inService(vp), V_blessed(vp), V_needsSalvaged(vp),
669          V_dontSalvage(vp));
670     printf
671         ("type = %d (%s), uniquifier = %u, needsCallback = %d, destroyMe = %x\n",
672          V_type(vp), typestring(V_type(vp)), V_uniquifier(vp),
673          V_needsCallback(vp), V_destroyMe(vp));
674     printf
675         ("id = %u, parentId = %u, cloneId = %u, backupId = %u, restoredFromId = %u\n",
676          V_id(vp), V_parentId(vp), V_cloneId(vp), V_backupId(vp),
677          V_restoredFromId(vp));
678     printf
679         ("maxquota = %d, minquota = %d, maxfiles = %d, filecount = %d, diskused = %d\n",
680          V_maxquota(vp), V_minquota(vp), V_maxfiles(vp), V_filecount(vp),
681          V_diskused(vp));
682     printf("creationDate = %s, copyDate = %s\n", date(V_creationDate(vp)),
683            date(V_copyDate(vp)));
684     printf("backupDate = %s, expirationDate = %s\n", date(V_backupDate(vp)),
685            date(V_expirationDate(vp)));
686     printf("accessDate = %s, updateDate = %s\n", date(V_accessDate(vp)),
687            date(V_updateDate(vp)));
688     printf("owner = %u, accountNumber = %u\n", V_owner(vp),
689            V_accountNumber(vp));
690     printf
691         ("dayUse = %u; week = (%u, %u, %u, %u, %u, %u, %u), dayUseDate = %s\n",
692          V_dayUse(vp), V_weekUse(vp)[0], V_weekUse(vp)[1], V_weekUse(vp)[2],
693          V_weekUse(vp)[3], V_weekUse(vp)[4], V_weekUse(vp)[5],
694          V_weekUse(vp)[6], date(V_dayUseDate(vp)));
695     printf("volUpdateCounter = %u\n", V_volUpCounter(vp));
696 }
697
698 /* GetFileInfo
699  * OS independent file info. Die on failure.
700  */
701 #ifdef AFS_NT40_ENV
702 char *
703 NT_date(FILETIME * ft)
704 {
705     static char result[8][64];
706     static int next = 0;
707     SYSTEMTIME st;
708     FILETIME lft;
709
710     if (!FileTimeToLocalFileTime(ft, &lft)
711         || !FileTimeToSystemTime(&lft, &st)) {
712         printf("Time conversion failed.\n");
713         exit(1);
714     }
715     sprintf(result[next = ((next + 1) & 7)], "%4d/%02d/%02d.%2d:%2d:%2d",
716             st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
717     return result[next];
718 }
719 #endif
720
721 static void
722 GetFileInfo(FD_t fd, int *size, char **ctime, char **mtime, char **atime)
723 {
724 #ifdef AFS_NT40_ENV
725     BY_HANDLE_FILE_INFORMATION fi;
726     if (!GetFileInformationByHandle(fd, &fi)) {
727         printf("GetFileInformationByHandle failed, exiting\n");
728         exit(1);
729     }
730     *size = (int)fi.nFileSizeLow;
731     *ctime = "N/A";
732     *mtime = NT_date(&fi.ftLastWriteTime);
733     *atime = NT_date(&fi.ftLastAccessTime);
734 #else
735     struct afs_stat status;
736     if (afs_fstat(fd, &status) == -1) {
737         printf("fstat failed %d\n", errno);
738         exit(1);
739     }
740     *size = (int)status.st_size;
741     *ctime = date(status.st_ctime);
742     *mtime = date(status.st_mtime);
743     *atime = date(status.st_atime);
744 #endif
745 }
746
747 void
748 PrintVnodes(Volume * vp, VnodeClass class)
749 {
750     afs_int32 diskSize =
751         (class == vSmall ? SIZEOF_SMALLDISKVNODE : SIZEOF_LARGEDISKVNODE);
752     char buf[SIZEOF_LARGEDISKVNODE];
753     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
754     StreamHandle_t *file;
755     register int vnodeIndex, nVnodes, offset = 0;
756     Inode ino;
757     IHandle_t *ih = vp->vnodeIndex[class].handle;
758     FdHandle_t *fdP;
759     int size;
760     char *ctime, *atime, *mtime;
761     char nfile[50], buffer[256];
762     int total, ofd, len, code, bad = 0;
763
764     fdP = IH_OPEN(ih);
765     if (fdP == NULL) {
766         printf("open failed\n");
767         exit(1);
768     }
769
770     file = FDH_FDOPEN(fdP, "r");
771     if (!file) {
772         printf("fdopen failed\n");
773         exit(1);
774     }
775
776     GetFileInfo(fdP->fd_fd, &size, &ctime, &atime, &mtime);
777     if (InodeTimes && !dsizeOnly) {
778         printf("ichanged : %s\nimodified: %s\niaccessed: %s\n\n", ctime,
779                mtime, atime);
780     }
781
782     nVnodes = (size / diskSize) - 1;
783     if (nVnodes > 0) {
784         STREAM_SEEK(file, diskSize, 0);
785     } else
786         nVnodes = 0;
787
788     for (vnodeIndex = 0;
789          nVnodes && STREAM_READ(vnode, diskSize, 1, file) == 1;
790          nVnodes--, vnodeIndex++, offset += diskSize) {
791
792         ino = VNDISK_GET_INO(vnode);
793         if (saveinodes) {
794             if (VALID_INO(ino) && (class == vSmall)) {
795                 IHandle_t *ih1;
796                 FdHandle_t *fdP1;
797                 IH_INIT(ih1, V_device(vp), V_parentId(vp), ino);
798                 fdP1 = IH_OPEN(ih1);
799                 if (fdP1 == NULL) {
800                     printf("Can't open inode %s error %d (ignored)\n",
801                            PrintInode(NULL, ino), errno);
802                     continue;
803                 }
804                 (void)afs_snprintf(nfile, sizeof nfile, "TmpInode.%s",
805                                    PrintInode(NULL, ino));
806                 ofd = afs_open(nfile, O_CREAT | O_RDWR | O_TRUNC, 0600);
807                 if (ofd < 0) {
808                     printf("Can't create file %s; error %d (ignored)\n",
809                            nfile, errno);
810                     continue;
811                 }
812                 total = bad = 0;
813                 while (1) {
814                     len = FDH_READ(fdP1, buffer, sizeof(buffer));
815                     if (len < 0) {
816                         FDH_REALLYCLOSE(fdP1);
817                         IH_RELEASE(ih1);
818                         close(ofd);
819                         unlink(nfile);
820                         printf
821                             ("Error while reading from inode %s (%d - ignored)\n",
822                              PrintInode(NULL, ino), errno);
823                         bad = 1;
824                         break;
825                     }
826                     if (len == 0)
827                         break;  /* No more input */
828                     code = write(ofd, buffer, len);
829                     if (code != len) {
830                         FDH_REALLYCLOSE(fdP1);
831                         IH_RELEASE(ih1);
832                         close(ofd);
833                         unlink(nfile);
834                         printf
835                             ("Error while writing to \"%s\" (%d - ignored)\n",
836                              nfile, errno);
837                         bad = 1;
838                         break;
839                     }
840                     total += len;
841                 }
842                 if (bad)
843                     continue;
844                 FDH_REALLYCLOSE(fdP1);
845                 IH_RELEASE(ih1);
846                 close(ofd);
847                 printf("... Copied inode %s to file %s (%d bytes)\n",
848                        PrintInode(NULL, ino), nfile, total);
849             }
850         } else {
851 #if defined(AFS_NAMEI_ENV)
852             PrintVnode(offset, vnode,
853                        bitNumberToVnodeNumber(vnodeIndex, class), ino, vp);
854 #else
855             PrintVnode(offset, vnode,
856                        bitNumberToVnodeNumber(vnodeIndex, class), ino);
857 #endif
858         }
859     }
860     STREAM_CLOSE(file);
861     FDH_CLOSE(fdP);
862 }
863
864 #if defined(AFS_NAMEI_ENV)
865 void
866 PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
867            Inode ino, Volume * vp)
868 #else
869 void
870 PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
871            Inode ino)
872 #endif
873 {
874 #if defined(AFS_NAMEI_ENV)
875     IHandle_t *ihtmpp;
876 #if !defined(AFS_NT40_ENV)
877     namei_t filename;
878 #else
879     char filename[MAX_PATH];
880 #endif
881 #endif
882     afs_fsize_t fileLength;
883
884     VNDISK_GET_LEN(fileLength, vnode);
885     Vvnodesize += fileLength;
886     Vvnodesize_k += fileLength / 1024;
887     if (dsizeOnly)
888         return;
889     if (orphaned && (fileLength == 0 || vnode->parent || !offset))
890         return;
891     printf
892         ("%10d Vnode %u.%u.%u cloned: %u, length: %llu linkCount: %d parent: %u",
893          offset, vnodeNumber, vnode->uniquifier, vnode->dataVersion,
894          vnode->cloned, (afs_uintmax_t) fileLength, vnode->linkCount,
895          vnode->parent);
896     if (DumpInodeNumber)
897         printf(" inode: %s", PrintInode(NULL, ino));
898     if (DumpDate)
899         printf(" ServerModTime: %s", date(vnode->serverModifyTime));
900 #if defined(AFS_NAMEI_ENV)
901     if (PrintFileNames) {
902         IH_INIT(ihtmpp, V_device(vp), V_parentId(vp), ino);
903 #if !defined(AFS_NT40_ENV)
904         namei_HandleToName(&filename, ihtmpp);
905         printf(" UFS-Filename: %s", filename.n_path);
906 #else
907         nt_HandleToName(filename, ihtmpp);
908         printf(" NTFS-Filename: %s", filename);
909 #endif
910     }
911 #endif
912     printf("\n");
913 }