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