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