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 DiskPartition *partP);
  91 void HandleVolume(struct DiskPartition *partP, char *name);
  92 struct DiskPartition *FindCurrentPartition(void);
  93 Volume *AttachVolume(struct DiskPartition *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 DiskPartition * 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 DiskPartition *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 DiskPartition *
 337 FindCurrentPartition()
 338 {
 339     int dr = _getdrive();
 340     struct DiskPartition *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 DiskPartition *
 354 FindCurrentPartition()
 355 {
 356     char partName[1024];
 357     char tmp = '\0';
 358     char *p;
 359     struct DiskPartition *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 DiskPartition *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 DiskPartition *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 DiskPartition *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 }