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 #include <afs/acl.h>
  33 #include <afs/prs_fs.h>
  34 #include <rx/rx_queue.h>
  35
  36 #include "nfs.h"
  37 #include "lock.h"
  38 #include "ihandle.h"
  39 #include "vnode.h"
  40 #include "volume.h"
  41 #include "partition.h"
  42 #include "salvage.h"
  43 #include "daemon_com_inline.h"
  44 #include "fssync_inline.h"
  45 #include "vol-info.h"
  46
  47 static int volinfo_init = 0;
  48 static const char *progname = "";
  49 static const char *PLACEHOLDER = "-";
  50
  51
  52 /* Numeric column type ids */
  53 typedef enum columnType {
  54 #define c(x) col_##x,
  55     VOLSCAN_COLUMNS
  56 #undef c
  57     max_column_type
  58 } columnType;
  59
  60 struct columnName {
  61     columnType type;
  62     const char *name;
  63 };
  64
  65 /* Table of id:name tuples of possible columns. */
  66 struct columnName ColumnName[] = {
  67 #define c(x) { col_##x, #x },
  68     VOLSCAN_COLUMNS
  69 #undef c
  70     {max_column_type, NULL}
  71 };
  72
  73
  74 /* VnodeDetails union descriminator */
  75 typedef enum {
  76     VNODE_U_NONE,
  77     VNODE_U_MOUNT,
  78     VNODE_U_SYMLINK,
  79     VNODE_U_POS_ACCESS,
  80     VNODE_U_NEG_ACCESS
  81 } vnode_details_u_t;
  82
  83 struct VnodeDetails {
  84     Volume *vp;
  85     VnodeClass class;
  86     VnodeDiskObject *vnode;
  87     VnodeId vnodeNumber;
  88     afs_foff_t offset;
  89     int index;
  90     char *path;
  91     vnode_details_u_t t;
  92     union {
  93         struct {
  94             char type;
  95             char *cell;
  96             char *vol;
  97         } mnt;
  98         char *target;
  99         struct acl_accessEntry *access;
 100     } u;
 101 };
 102
 103
 104 static int NeedDirIndex;        /**< Large vnode index handle is needed for path lookups. */
 105 static FdHandle_t *DirIndexFd = NULL; /**< Current large vnode index handle for path lookups. */
 106
 107 static int NumOutputColumns = 0;
 108 static columnType OutputColumn[max_column_type];
 109
 110 /**
 111  * Volume size running totals
 112  */
 113 struct sizeTotals {
 114     afs_uint64 diskused_k;      /**< volume size from disk data file, in kilobytes */
 115     afs_uint64 auxsize;         /**< size of header files, in bytes  */
 116     afs_uint64 auxsize_k;       /**< size of header files, in kilobytes */
 117     afs_uint64 vnodesize;       /**< size of the large and small vnodes, in bytes */
 118     afs_uint64 vnodesize_k;     /**< size of the large and small vnodes, in kilobytes */
 119     afs_uint64 size_k;          /**< size of headers and vnodes, in kilobytes */
 120 };
 121
 122 static struct sizeTotals volumeTotals = { 0, 0, 0, 0, 0, 0 };
 123 static struct sizeTotals partitionTotals = { 0, 0, 0, 0, 0, 0 };
 124 static struct sizeTotals serverTotals = { 0, 0, 0, 0, 0, 0 };
 125 static int PrintingVolumeSizes = 0;     /*print volume size lines */
 126
 127 /**
 128  * List of procedures to call when scanning vnodes.
 129  */
 130 struct VnodeScanProc {
 131     struct opr_queue link;
 132     const char *heading;
 133     void (*proc) (struct VolInfoOpt *opt, struct VnodeDetails * vdp);
 134 };
 135 static struct opr_queue VnodeScanLists[nVNODECLASSES];
 136
 137 /* Forward Declarations */
 138 static void PrintHeader(Volume * vp);
 139 static void HandleAllPart(struct VolInfoOpt *opt);
 140 static void HandlePart(struct VolInfoOpt *opt, struct DiskPartition64 *partP);
 141 static void HandleVolume(struct VolInfoOpt *opt, struct DiskPartition64 *partP, char *name);
 142 static struct DiskPartition64 *FindCurrentPartition(void);
 143 static Volume *AttachVolume(struct VolInfoOpt *opt, struct DiskPartition64 *dp, char *volname,
 144                      struct VolumeHeader *header);
 145 static void HandleVnodes(struct VolInfoOpt *opt, Volume * vp, VnodeClass class);
 146 static void PrintColumnHeading(struct VolInfoOpt *opt);
 147 static void PrintColumns(struct VolInfoOpt *opt, struct VnodeDetails *vdp, const char *desc);
 148
 149 /* externs */
 150 extern void SetSalvageDirHandle(DirHandle * dir, afs_int32 volume,
 151                                 Device device, Inode inode,
 152                                 int *volumeChanged);
 153 extern void FidZap(DirHandle * file);
 154
 155 /**
 156  * Format time as a timestamp string
 157  *
 158  * @param[in] date  time value to format
 159  *
 160  * @return timestamp string in the form YYYY/MM/DD.hh:mm:ss
 161  *
 162  * @note A static array of 8 strings are stored by this
 163  *       function. The array slots are overwritten, so the
 164  *       caller must not reference the returned string after
 165  *       seven additional calls to this function.
 166  */
 167 static char *
 168 date(time_t date)
 169 {
 170 #define MAX_DATE_RESULT 100
 171     static char results[8][MAX_DATE_RESULT];
 172     static int next;
 173     struct tm *tm = localtime(&date);
 174     char buf[32];
 175
 176     (void)strftime(buf, 32, "%Y/%m/%d.%H:%M:%S", tm);   /* NT does not have %T */
 177     snprintf(results[next = (next + 1) & 7], MAX_DATE_RESULT,
 178              "%lu (%s)", (unsigned long)date, buf);
 179     return results[next];
 180 }
 181
 182 #ifdef AFS_NT40_ENV
 183 /**
 184  * Format file time as a timestamp string
 185  *
 186  * @param[in] ft  file time
 187  *
 188  * @return timestamp string in the form YYYY/MM/DD.hh:mm:ss
 189  *
 190  * @note A static array of 8 strings are stored by this
 191  *       function. The array slots are overwritten, so the
 192  *       caller must not reference the returned string after
 193  *       seven additional calls to this function.
 194  */
 195 static char *
 196 NT_date(FILETIME * ft)
 197 {
 198     static char result[8][64];
 199     static int next = 0;
 200     SYSTEMTIME st;
 201     FILETIME lft;
 202
 203     if (!FileTimeToLocalFileTime(ft, &lft)
 204         || !FileTimeToSystemTime(&lft, &st)) {
 205         fprintf(stderr, "%s: Time conversion failed.\n", progname);
 206         exit(1);
 207     }
 208     sprintf(result[next = ((next + 1) & 7)], "%4d/%02d/%02d.%2d:%2d:%2d",
 209             st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
 210     return result[next];
 211 }
 212 #endif
 213
 214 /**
 215  * Add vnode size to the running volume totals.
 216  *
 217  * @param[in]  vdp   vnode details object
 218  *
 219  * @return none
 220  */
 221 void
 222 volinfo_AddVnodeToSizeTotals(struct VolInfoOpt *opt, struct VnodeDetails *vdp)
 223 {
 224     afs_fsize_t fileLength;
 225
 226     VNDISK_GET_LEN(fileLength, vdp->vnode);
 227     if (fileLength > 0) {
 228         volumeTotals.vnodesize += fileLength;
 229         volumeTotals.vnodesize_k += fileLength / 1024;
 230     }
 231 }
 232
 233 /**
 234  * Print the volume size table heading line, if needed.
 235  *
 236  * @return none
 237  */
 238 static void
 239 PrintVolumeSizeHeading(void)
 240 {
 241     if (!PrintingVolumeSizes) {
 242         printf
 243             ("Volume-Id\t  Volsize  Auxsize Inodesize  AVolsize SizeDiff                (VolName)\n");
 244         PrintingVolumeSizes = 1;
 245     }
 246 }
 247
 248 /**
 249  * Accumulate totals.
 250  *
 251  * @return 0
 252  */
 253 static void
 254 AddSizeTotals(struct sizeTotals *a, struct sizeTotals *b)
 255 {
 256     a->diskused_k += b->diskused_k;
 257     a->auxsize += b->auxsize;
 258     a->auxsize_k += b->auxsize_k;
 259     a->vnodesize += b->vnodesize;
 260     a->vnodesize_k += b->vnodesize_k;
 261     a->size_k += b->size_k;
 262 }
 263
 264 /**
 265  * Print the sizes for a volume.
 266  *
 267  * @return none
 268  */
 269 static void
 270 PrintVolumeSizes(Volume * vp)
 271 {
 272     afs_int64 diff_k = volumeTotals.size_k - volumeTotals.diskused_k;
 273
 274     PrintVolumeSizeHeading();
 275     printf("%" AFS_VOLID_FMT "\t%9llu%9llu%10llu%10llu%9lld\t%24s\n",
 276            afs_printable_VolumeId_lu(V_id(vp)),
 277            volumeTotals.diskused_k,
 278            volumeTotals.auxsize_k, volumeTotals.vnodesize_k,
 279            volumeTotals.size_k, diff_k, V_name(vp));
 280 }
 281
 282 /**
 283  * Print the size totals for the partition.
 284  *
 285  * @return none
 286  */
 287 static void
 288 PrintPartitionTotals(afs_uint64 nvols)
 289 {
 290     afs_int64 diff_k = partitionTotals.size_k - partitionTotals.diskused_k;
 291
 292     PrintVolumeSizeHeading();
 293     printf("\nPart Totals  %12llu%9llu%10llu%10llu%9lld (%llu volumes)\n\n",
 294            partitionTotals.diskused_k, partitionTotals.auxsize,
 295            partitionTotals.vnodesize, partitionTotals.size_k, diff_k, nvols);
 296     PrintingVolumeSizes = 0;
 297 }
 298
 299 /**
 300  * Print the size totals for all the partitions.
 301  *
 302  * @return none
 303  */
 304 static void
 305 PrintServerTotals(void)
 306 {
 307     afs_int64 diff_k = serverTotals.size_k - serverTotals.diskused_k;
 308
 309     printf("\nServer Totals%12lld%9lld%10lld%10lld%9lld\n",
 310            serverTotals.diskused_k, serverTotals.auxsize,
 311            serverTotals.vnodesize, serverTotals.size_k, diff_k);
 312 }
 313
 314 /**
 315  * Read a volume header file
 316  *
 317  * @param[in] ih        ihandle of the header file
 318  * @param[in] to        destination
 319  * @param[in] size      expected header size
 320  * @param[in] magic     expected header magic number
 321  * @param[in] version   expected header version number
 322  *
 323  * @return error code
 324  *   @retval 0 success
 325  *   @retval -1 failed to read file
 326  */
 327 static int
 328 ReadHdr1(struct VolInfoOpt *opt, IHandle_t * ih, char *to, afs_sfsize_t size,
 329          u_int magic, u_int version)
 330 {
 331     struct versionStamp *vsn;
 332     int bad = 0;
 333     int code;
 334
 335     vsn = (struct versionStamp *)to;
 336
 337     code = IH_IREAD(ih, 0, to, size);
 338     if (code != size)
 339         return -1;
 340
 341     if (vsn->magic != magic) {
 342         bad++;
 343         fprintf(stderr, "%s: Inode %s: Bad magic %x (%x): IGNORED\n",
 344                 progname, PrintInode(NULL, ih->ih_ino), vsn->magic, magic);
 345     }
 346
 347     /* Check is conditional, in case caller wants to inspect version himself */
 348     if (version && vsn->version != version) {
 349         bad++;
 350         fprintf(stderr, "%s: Inode %s: Bad version %x (%x): IGNORED\n",
 351                 progname,
 352                 PrintInode(NULL, ih->ih_ino), vsn->version, version);
 353     }
 354     if (bad && opt->fixHeader) {
 355         vsn->magic = magic;
 356         vsn->version = version;
 357         printf("Special index inode %s has a bad header. Reconstructing...\n",
 358                PrintInode(NULL, ih->ih_ino));
 359         code = IH_IWRITE(ih, 0, to, size);
 360         if (code != size) {
 361             fprintf(stderr,
 362                     "%s: Write failed for inode %s; header left in damaged state\n",
 363                     progname, PrintInode(NULL, ih->ih_ino));
 364         }
 365     }
 366     if (!bad && opt->dumpInfo) {
 367         printf("Inode %s: Good magic %x and version %x\n",
 368                PrintInode(NULL, ih->ih_ino), magic, version);
 369     }
 370     return 0;
 371 }
 372
 373 /**
 374  * Simplified attach volume
 375  *
 376  * param[in] dp       vice disk partition object
 377  * param[in] volname  volume header file name
 378  * param[in] header   volume header object
 379  *
 380  * @return volume object or null on error
 381  */
 382 static Volume *
 383 AttachVolume(struct VolInfoOpt *opt, struct DiskPartition64 *dp,
 384              char *volname, struct VolumeHeader *header)
 385 {
 386     Volume *vp;
 387     afs_int32 ec = 0;
 388
 389     if (opt->checkout) {
 390         afs_int32 code;
 391         SYNC_response response;
 392         VolumeId volid = header->id;
 393
 394         memset(&response, 0, sizeof(response));
 395         code =
 396             FSYNC_VolOp(volid, dp->name, FSYNC_VOL_NEEDVOLUME, V_DUMP,
 397                         &response);
 398         if (code != SYNC_OK) {
 399             if (response.hdr.reason == FSYNC_SALVAGE) {
 400                 fprintf(stderr,
 401                         "%s: file server says volume %lu is salvaging.\n",
 402                         progname, afs_printable_uint32_lu(volid));
 403                 return NULL;
 404             } else {
 405                 fprintf(stderr,
 406                         "%s: attach of volume %lu denied by file server.\n",
 407                         progname, afs_printable_uint32_lu(volid));
 408                 return NULL;
 409             }
 410         }
 411     }
 412
 413     vp = (Volume *) calloc(1, sizeof(Volume));
 414     if (!vp) {
 415         fprintf(stderr, "%s: Failed to allocate volume object.\n", progname);
 416         return NULL;
 417     }
 418     vp->specialStatus = 0;
 419     vp->device = dp->device;
 420     vp->partition = dp;
 421     IH_INIT(vp->vnodeIndex[vLarge].handle, dp->device, header->parent,
 422             header->largeVnodeIndex);
 423     IH_INIT(vp->vnodeIndex[vSmall].handle, dp->device, header->parent,
 424             header->smallVnodeIndex);
 425     IH_INIT(vp->diskDataHandle, dp->device, header->parent,
 426             header->volumeInfo);
 427     IH_INIT(V_linkHandle(vp), dp->device, header->parent, header->linkTable);
 428     vp->cacheCheck = 0;         /* XXXX */
 429     vp->shuttingDown = 0;
 430     vp->goingOffline = 0;
 431     vp->nUsers = 1;
 432     vp->header = calloc(1, sizeof(*vp->header));
 433     if (!vp->header) {
 434         fprintf(stderr, "%s: Failed to allocate volume header.\n", progname);
 435         free(vp);
 436         return NULL;
 437     }
 438     ec = ReadHdr1(opt, V_diskDataHandle(vp), (char *)&V_disk(vp),
 439                   sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
 440     if (!ec) {
 441         struct IndexFileHeader iHead;
 442         ec = ReadHdr1(opt, vp->vnodeIndex[vSmall].handle, (char *)&iHead,
 443                       sizeof(iHead), SMALLINDEXMAGIC, SMALLINDEXVERSION);
 444     }
 445     if (!ec) {
 446         struct IndexFileHeader iHead;
 447         ec = ReadHdr1(opt, vp->vnodeIndex[vLarge].handle, (char *)&iHead,
 448                       sizeof(iHead), LARGEINDEXMAGIC, LARGEINDEXVERSION);
 449     }
 450 #ifdef AFS_NAMEI_ENV
 451     if (!ec) {
 452         struct versionStamp stamp;
 453         ec = ReadHdr1(opt, V_linkHandle(vp), (char *)&stamp, sizeof(stamp),
 454                       LINKTABLEMAGIC, LINKTABLEVERSION);
 455     }
 456 #endif
 457     if (ec)
 458         return (Volume *) 0;
 459     return vp;
 460 }
 461
 462 /**
 463  * Simplified detach volume
 464  *
 465  * param[in] vp       volume object from AttachVolume
 466  *
 467  * @return none
 468  */
 469 static void
 470 DetachVolume(struct VolInfoOpt *opt, Volume * vp)
 471 {
 472     if (opt->checkout) {
 473         afs_int32 code;
 474         SYNC_response response;
 475         memset(&response, 0, sizeof(response));
 476
 477         code = FSYNC_VolOp(V_id(vp), V_partition(vp)->name,
 478                            FSYNC_VOL_ON, FSYNC_WHATEVER, &response);
 479         if (code != SYNC_OK) {
 480             fprintf(stderr, "%s: FSSYNC error %d (%s)\n", progname, code,
 481                     SYNC_res2string(code));
 482             fprintf(stderr, "%s:  protocol response code was %d (%s)\n",
 483                     progname, response.hdr.response,
 484                     SYNC_res2string(response.hdr.response));
 485             fprintf(stderr, "%s:  protocol reason code was %d (%s)\n",
 486                     progname, response.hdr.reason,
 487                     FSYNC_reason2string(response.hdr.reason));
 488         }
 489     }
 490
 491     IH_RELEASE(vp->vnodeIndex[vLarge].handle);
 492     IH_RELEASE(vp->vnodeIndex[vSmall].handle);
 493     IH_RELEASE(vp->diskDataHandle);
 494     IH_RELEASE(V_linkHandle(vp));
 495     free(vp->header);
 496     free(vp);
 497 }
 498
 499 /**
 500  * Convert the partition device number into a partition name.
 501  *
 502  * @param[in]   partId      partition number, 0 to 254
 503  * @param[out]  partName    buffer to hold partition name (e.g. /vicepa)
 504  * @param[in]   partNameSize    size of partName buffer
 505  *
 506  * @return status
 507  *   @retval 0 success
 508  *   @retval -1 error, partId is out of range
 509  *   @retval -2 error, partition name exceeds partNameSize
 510  */
 511 static int
 512 GetPartitionName(afs_uint32 partId, char *partName, afs_size_t partNameSize)
 513 {
 514     const afs_uint32 OLD_NUM_DEVICES = 26;      /* a..z */
 515
 516     if (partId < OLD_NUM_DEVICES) {
 517         if (partNameSize < 8) {
 518             return -2;
 519         }
 520         strlcpy(partName, "/vicep", partNameSize);
 521         partName[6] = partId + 'a';
 522         partName[7] = '\0';
 523         return 0;
 524     }
 525     if (partId < VOLMAXPARTS) {
 526         if (partNameSize < 9) {
 527             return -2;
 528         }
 529         strlcpy(partName, "/vicep", partNameSize);
 530         partId -= OLD_NUM_DEVICES;
 531         partName[6] = 'a' + (partId / OLD_NUM_DEVICES);
 532         partName[7] = 'a' + (partId % OLD_NUM_DEVICES);
 533         partName[8] = '\0';
 534         return 0;
 535     }
 536     return -1;
 537 }
 538
 539 /**
 540  * Scan the volumes in the partitions
 541  *
 542  * Scan the specified volume in the specified partition if both
 543  * are given. Scan all the volumes in the specified partition if
 544  * only the partition is given.  If neither a partition nor volume
 545  * is given, scan all the volumes in all the partitions.  If only
 546  * the volume is given, attempt to find it in the current working
 547  * directory.
 548  *
 549  * @param[in] partNameOrId   partition name or id to be scannned
 550  * @param[in] volumeId       volume id to be scanned
 551  *
 552  * @return 0 if successful
 553  */
 554 int
 555 volinfo_ScanPartitions(struct VolInfoOpt *opt, char *partNameOrId, VolumeId volumeId)
 556 {
 557     int err = 0;
 558     char partName[64] = "";
 559     struct DiskPartition64 *partP = NULL;
 560
 561     if (opt->checkout) {
 562         if (!FSYNC_clientInit()) {
 563             fprintf(stderr, "%s: Failed to connect to fileserver.\n",
 564                     progname);
 565             return 1;
 566         }
 567     }
 568
 569
 570     /* Allow user to specify partition by name or id. */
 571     if (partNameOrId) {
 572         afs_uint32 partId = volutil_GetPartitionID(partNameOrId);
 573         if (partId == -1) {
 574             fprintf(stderr, "%s: Could not parse '%s' as a partition name.\n",
 575                     progname, partNameOrId);
 576             err = 1;
 577             goto cleanup;
 578         }
 579         if (GetPartitionName(partId, partName, sizeof(partName))) {
 580             fprintf(stderr,
 581                     "%s: Could not format '%s' as a partition name.\n",
 582                     progname, partNameOrId);
 583             err = 1;
 584             goto cleanup;
 585         }
 586     }
 587
 588     err = VAttachPartitions();
 589     if (err) {
 590         fprintf(stderr, "%s: %d partitions had errors during attach.\n",
 591                 progname, err);
 592         err = 1;
 593         goto cleanup;
 594     }
 595
 596     if (partName[0]) {
 597         partP = VGetPartition(partName, 0);
 598         if (!partP) {
 599             fprintf(stderr,
 600                     "%s: %s is not an AFS partition name on this server.\n",
 601                     progname, partName);
 602             err = 1;
 603             goto cleanup;
 604         }
 605     }
 606
 607     if (!volumeId) {
 608         if (opt->printHeading) {
 609             PrintColumnHeading(opt);
 610         }
 611         if (!partP) {
 612             HandleAllPart(opt);
 613         } else {
 614             HandlePart(opt, partP);
 615         }
 616     } else {
 617         char name1[128];
 618
 619         if (!partP) {
 620             partP = FindCurrentPartition();
 621             if (!partP) {
 622                 fprintf(stderr,
 623                         "%s: Current partition is not a vice partition.\n",
 624                         progname);
 625                 err = 1;
 626                 goto cleanup;
 627             }
 628         }
 629         snprintf(name1, sizeof name1, VFORMAT,
 630                  afs_printable_VolumeId_lu(volumeId));
 631         if (opt->printHeading) {
 632             PrintColumnHeading(opt);
 633         }
 634         HandleVolume(opt, partP, name1);
 635     }
 636
 637   cleanup:
 638     if (opt->checkout) {
 639         FSYNC_clientFinis();
 640     }
 641     return err;
 642 }
 643
 644 /**
 645  * Add a vnode scanning procedure
 646  *
 647  * @param[in]   class   vnode class for this handler
 648  * @param[in]   proc    handler proc to be called by HandleVnodes
 649  * @param[in]   heading optional string to pring before scanning vnodes
 650  *
 651  * @return none
 652  */
 653 void
 654 volinfo_AddVnodeHandler(int vnodeClass,
 655                 void (*proc) (struct VolInfoOpt * opt,
 656                               struct VnodeDetails * vdp), const char *heading)
 657 {
 658     struct VnodeScanProc *entry = malloc(sizeof(struct VnodeScanProc));
 659     entry->proc = proc;
 660     entry->heading = heading;
 661     opr_queue_Append(&VnodeScanLists[vnodeClass], (struct opr_queue *)entry);
 662 }
 663
 664 /**
 665  * Initialize the vol-info module.
 666  */
 667 int
 668 volinfo_Init(const char *aprogname)
 669 {
 670     if (!volinfo_init) {
 671         progname = aprogname;  /* for error messages */
 672 #ifndef AFS_NT40_ENV
 673         if (geteuid() != 0) {
 674             fprintf(stderr, "%s: Must be run as root.\n", progname);
 675             return EPERM;
 676         }
 677 #endif
 678         DInit(1024);
 679         VInitVnodes(vLarge, 0);
 680         VInitVnodes(vSmall, 0);
 681         opr_queue_Init(&VnodeScanLists[vLarge]);
 682         opr_queue_Init(&VnodeScanLists[vSmall]);
 683         volinfo_init = 1;
 684     }
 685     return 0;
 686 }
 687
 688 /**
 689  * Alloc an options structure with default values.
 690  *
 691  * The caller must free the options pointer after use.
 692  *
 693  * @param[out] optp address of options pointer
 694  * @return 0 on success
 695  */
 696 int
 697 volinfo_Options(struct VolInfoOpt **optp)
 698 {
 699     struct VolInfoOpt *opt;
 700
 701     opt = calloc(1, sizeof(struct VolInfoOpt));
 702     if (!opt) {
 703         fprintf(stderr, "%s: Failed to allocate options (%d).\n", progname, ENOMEM);
 704         return ENOMEM;
 705     }
 706     opt->dumpInfo = 1;
 707     gethostname(opt->hostname, sizeof(opt->hostname));
 708     opt->columnDelim[0] = ' ';
 709     opt->checkMagic = 1;
 710     *optp = opt;
 711     return 0;
 712 }
 713
 714 /**
 715  * Add a column type to be displayed.
 716  *
 717  * @param[in]  name   column type name
 718  *
 719  * @return error code
 720  *   @retval 0 success
 721  *   @retval 1 too many columns
 722  *   @retval 2 invalid column name
 723  */
 724 int
 725 volinfo_AddOutputColumn(char *name)
 726 {
 727     int i;
 728
 729     if (NumOutputColumns >= sizeof(OutputColumn) / sizeof(*OutputColumn)) {
 730         fprintf(stderr, "%s: Too many output columns (%d).\n", progname,
 731                 NumOutputColumns);
 732         return 1;
 733     }
 734     for (i = 0; i < max_column_type; i++) {
 735         if (!strcmp(ColumnName[i].name, name)) {
 736             columnType t = ColumnName[i].type;
 737             OutputColumn[NumOutputColumns++] = t;
 738
 739             if (t == col_path) {
 740                 NeedDirIndex = 1;
 741             }
 742             return 0;
 743         }
 744     }
 745     return 2;
 746 }
 747
 748
 749 /**
 750  * Determine if the current directory is a vice partition
 751  *
 752  * @return disk partition object
 753  */
 754 #ifdef AFS_NT40_ENV
 755 #include <direct.h>
 756 static struct DiskPartition64 *
 757 FindCurrentPartition(void)
 758 {
 759     int dr = _getdrive();
 760     struct DiskPartition64 *dp;
 761
 762     dr--;
 763     for (dp = DiskPartitionList; dp; dp = dp->next) {
 764         if (*dp->devName - 'A' == dr)
 765             break;
 766     }
 767     if (!dp) {
 768         fprintf(stderr, "%s: Current drive is not a valid vice partition.\n",
 769                 progname);
 770     }
 771     return dp;
 772 }
 773 #else
 774 static struct DiskPartition64 *
 775 FindCurrentPartition(void)
 776 {
 777     char partName[1024];
 778     char tmp = '\0';
 779     char *p;
 780     struct DiskPartition64 *dp;
 781
 782     if (!getcwd(partName, 1023)) {
 783         fprintf(stderr, "%s: Failed to get current working directory: ",
 784                 progname);
 785         perror("pwd");
 786         return NULL;
 787     }
 788     p = strchr(&partName[1], OS_DIRSEPC);
 789     if (p) {
 790         tmp = *p;
 791         *p = '\0';
 792     }
 793     if (!(dp = VGetPartition(partName, 0))) {
 794         if (tmp)
 795             *p = tmp;
 796         fprintf(stderr, "%s: %s is not a valid vice partition.\n", progname,
 797                 partName);
 798         return NULL;
 799     }
 800     return dp;
 801 }
 802 #endif
 803
 804 /**
 805  * Scan and handle all the partitions detected on this server
 806  *
 807  * @return none
 808  */
 809 static void
 810 HandleAllPart(struct VolInfoOpt *opt)
 811 {
 812     struct DiskPartition64 *partP;
 813
 814     for (partP = DiskPartitionList; partP; partP = partP->next) {
 815         if (opt->dumpInfo || opt->saveInodes || opt->showSizes) {
 816             printf("Processing Partition %s:\n", partP->name);
 817         }
 818         HandlePart(opt, partP);
 819         if (opt->showSizes) {
 820             AddSizeTotals(&serverTotals, &partitionTotals);
 821         }
 822     }
 823
 824     if (opt->showSizes) {
 825         PrintServerTotals();
 826     }
 827 }
 828
 829 /**
 830  * Scan the partition and handle volumes
 831  *
 832  * @param[in] partP  disk partition to scan
 833  *
 834  * @return none
 835  */
 836 static void
 837 HandlePart(struct VolInfoOpt *opt, struct DiskPartition64 *partP)
 838 {
 839     afs_int64 nvols = 0;
 840     DIR *dirp;
 841     struct dirent *dp;
 842 #ifdef AFS_NT40_ENV
 843     char pname[64];
 844     char *p = pname;
 845     (void)sprintf(pname, "%s\\", VPartitionPath(partP));
 846 #else
 847     char *p = VPartitionPath(partP);
 848 #endif
 849
 850     if ((dirp = opendir(p)) == NULL) {
 851         fprintf(stderr, "%s: Can't read directory %s; giving up\n", progname,
 852                 p);
 853         return;
 854     }
 855     while ((dp = readdir(dirp))) {
 856         p = (char *)strrchr(dp->d_name, '.');
 857         if (p != NULL && strcmp(p, VHDREXT) == 0) {
 858             HandleVolume(opt, partP, dp->d_name);
 859             if (opt->showSizes) {
 860                 nvols++;
 861                 AddSizeTotals(&partitionTotals, &volumeTotals);
 862             }
 863         }
 864     }
 865     closedir(dirp);
 866     if (opt->showSizes) {
 867         PrintPartitionTotals(nvols);
 868     }
 869 }
 870
 871 /**
 872  * Inspect a volume header special file.
 873  *
 874  * @param[in]  name       descriptive name of the type of header special file
 875  * @param[in]  dp         partition object for this volume
 876  * @param[in]  header     header object for this volume
 877  * @param[in]  inode      fileserver inode number for this header special file
 878  * @param[out] psize      total of the header special file
 879  *
 880  * @return none
 881  */
 882 static void
 883 HandleSpecialFile(struct VolInfoOpt *opt, const char *name, struct DiskPartition64 *dp,
 884                   struct VolumeHeader *header, Inode inode,
 885                   afs_sfsize_t * psize)
 886 {
 887     afs_sfsize_t size = -1;
 888     IHandle_t *ih = NULL;
 889     FdHandle_t *fdP = NULL;
 890 #ifdef AFS_NAMEI_ENV
 891     namei_t filename;
 892 #endif /* AFS_NAMEI_ENV */
 893
 894     IH_INIT(ih, dp->device, header->parent, inode);
 895     fdP = IH_OPEN(ih);
 896     if (fdP == NULL) {
 897         fprintf(stderr,
 898                 "%s: Error opening header file '%s' for volume %" AFS_VOLID_FMT "\n", progname,
 899                 name, afs_printable_VolumeId_lu(header->id));
 900         perror("open");
 901         goto error;
 902     }
 903     size = FDH_SIZE(fdP);
 904     if (size == -1) {
 905         fprintf(stderr,
 906                 "%s: Error getting size of header file '%s' for volume %" AFS_VOLID_FMT "\n",
 907                 progname, name, afs_printable_VolumeId_lu(header->id));
 908         perror("fstat");
 909         goto error;
 910     }
 911     *psize += size;
 912
 913   error:
 914     if (opt->dumpInfo) {
 915         printf("\t%s inode\t= %s (size = ", name, PrintInode(NULL, inode));
 916         if (size != -1) {
 917             printf("%lld)\n", size);
 918         } else {
 919             printf("unknown)\n");
 920         }
 921 #ifdef AFS_NAMEI_ENV
 922         namei_HandleToName(&filename, ih);
 923         printf("\t%s namei\t= %s\n", name, filename.n_path);
 924 #endif /* AFS_NAMEI_ENV */
 925     }
 926
 927     if (fdP != NULL) {
 928         FDH_REALLYCLOSE(fdP);
 929     }
 930     if (ih != NULL) {
 931         IH_RELEASE(ih);
 932     }
 933 }
 934
 935 /**
 936  * Inspect this volume header files.
 937  *
 938  * @param[in]  dp         partition object for this volume
 939  * @param[in]  header_fd  volume header file descriptor
 940  * @param[in]  header     volume header object
 941  * @param[out] psize      total of the header special file
 942  *
 943  * @return none
 944  */
 945 static void
 946 HandleHeaderFiles(struct VolInfoOpt *opt, struct DiskPartition64 *dp, FD_t header_fd,
 947                   struct VolumeHeader *header)
 948 {
 949     afs_sfsize_t size = 0;
 950
 951     if (opt->dumpInfo) {
 952         size = OS_SIZE(header_fd);
 953         printf("Volume header (size = %lld):\n", size);
 954         printf("\tstamp\t= 0x%x\n", header->stamp.version);
 955         printf("\tVolId\t= %" AFS_VOLID_FMT "\n", afs_printable_VolumeId_lu(header->id));
 956         printf("\tparent\t= %" AFS_VOLID_FMT "\n", afs_printable_VolumeId_lu(header->parent));
 957     }
 958
 959     HandleSpecialFile(opt, "Info", dp, header, header->volumeInfo, &size);
 960     HandleSpecialFile(opt, "Small", dp, header, header->smallVnodeIndex,
 961                       &size);
 962     HandleSpecialFile(opt, "Large", dp, header, header->largeVnodeIndex,
 963                       &size);
 964 #ifdef AFS_NAMEI_ENV
 965     HandleSpecialFile(opt, "Link", dp, header, header->linkTable, &size);
 966 #endif /* AFS_NAMEI_ENV */
 967
 968     if (opt->dumpInfo) {
 969         printf("Total aux volume size = %lld\n\n", size);
 970     }
 971
 972     if (opt->showSizes) {
 973         volumeTotals.auxsize = size;
 974         volumeTotals.auxsize_k = size / 1024;
 975     }
 976 }
 977
 978 /**
 979  * Determine if the vnodes of this volume should be scanned.
 980  *
 981  * @param[in]  vp   volume object
 982  *
 983  * @return true if vnodes should be scanned
 984  */
 985 static int
 986 IsScannable(struct VolInfoOpt *opt, Volume * vp)
 987 {
 988     if (opr_queue_IsEmpty(&VnodeScanLists[vLarge]) &&
 989         opr_queue_IsEmpty(&VnodeScanLists[vSmall])) {
 990         return 0;
 991     }
 992     if (!opt->scanVolType) {
 993         return 1;               /* filtering disabled; do not check vol type */
 994     }
 995     switch (V_type(vp)) {
 996     case RWVOL:
 997         return opt->scanVolType & SCAN_RW;
 998     case ROVOL:
 999         return opt->scanVolType & SCAN_RO;
1000     case BACKVOL:
1001         return opt->scanVolType & SCAN_BK;
1002     default:
1003         fprintf(stderr, "%s: Volume %" AFS_VOLID_FMT "; Unknown volume type %d\n", progname,
1004                 afs_printable_VolumeId_lu(V_id(vp)), V_type(vp));
1005         break;
1006     }
1007     return 0;
1008 }
1009
1010 /**
1011  * Attach and scan the volume and handle the header and vnodes
1012  *
1013  * Print the volume header and vnode information, depending on the
1014  * current modes.
1015  *
1016  * @param[in] dp    vice partition object for this volume
1017  * @param[in] name  volume header file name
1018  *
1019  * @return none
1020  */
1021 static void
1022 HandleVolume(struct VolInfoOpt *opt, struct DiskPartition64 *dp, char *name)
1023 {
1024     struct VolumeHeader header;
1025     struct VolumeDiskHeader diskHeader;
1026     FD_t fd = INVALID_FD;
1027     Volume *vp = NULL;
1028     char headerName[1024];
1029     afs_sfsize_t n;
1030
1031     snprintf(headerName, sizeof headerName, "%s" OS_DIRSEP "%s",
1032              VPartitionPath(dp), name);
1033     if ((fd = OS_OPEN(headerName, O_RDONLY, 0666)) == INVALID_FD) {
1034         fprintf(stderr, "%s: Cannot open volume header %s\n", progname, name);
1035         goto cleanup;
1036     }
1037     if (OS_SIZE(fd) < 0) {
1038         fprintf(stderr, "%s: Cannot read volume header %s\n", progname, name);
1039         goto cleanup;
1040     }
1041     n = OS_READ(fd, &diskHeader, sizeof(diskHeader));
1042     if (n != sizeof(diskHeader)
1043         || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
1044         fprintf(stderr, "%s: Error reading volume header %s\n", progname,
1045                 name);
1046         goto cleanup;
1047     }
1048     if (diskHeader.stamp.version != VOLUMEHEADERVERSION) {
1049         fprintf(stderr,
1050                 "%s: Volume %s, version number is incorrect; volume needs to be salvaged\n",
1051                 progname, name);
1052         goto cleanup;
1053     }
1054
1055     DiskToVolumeHeader(&header, &diskHeader);
1056     if (opt->dumpHeader || opt->showSizes) {
1057         HandleHeaderFiles(opt, dp, fd, &header);
1058     }
1059
1060     vp = AttachVolume(opt, dp, name, &header);
1061     if (!vp) {
1062         fprintf(stderr, "%s: Error attaching volume header %s\n",
1063                 progname, name);
1064         goto cleanup;
1065     }
1066
1067     if (opt->dumpInfo) {
1068         PrintHeader(vp);
1069     }
1070     if (IsScannable(opt, vp)) {
1071         if (NeedDirIndex) {
1072             IHandle_t *ih = vp->vnodeIndex[vLarge].handle;
1073             DirIndexFd = IH_OPEN(ih);
1074             if (DirIndexFd == NULL) {
1075                 fprintf(stderr, "%s: Failed to open index for directories.",
1076                         progname);
1077             }
1078         }
1079
1080         HandleVnodes(opt, vp, vLarge);
1081         HandleVnodes(opt, vp, vSmall);
1082
1083         if (DirIndexFd) {
1084             FDH_CLOSE(DirIndexFd);
1085             DirIndexFd = NULL;
1086         }
1087     }
1088     if (opt->showSizes) {
1089         volumeTotals.diskused_k = V_diskused(vp);
1090         volumeTotals.size_k =
1091             volumeTotals.auxsize_k + volumeTotals.vnodesize_k;
1092         if (opt->saveInodes) {
1093             PrintingVolumeSizes = 0;    /* print heading again */
1094         }
1095         PrintVolumeSizes(vp);
1096     }
1097
1098   cleanup:
1099     if (fd != INVALID_FD) {
1100         OS_CLOSE(fd);
1101     }
1102     if (vp) {
1103         DetachVolume(opt, vp);
1104     }
1105 }
1106
1107 /**
1108  * Return a display string for the volume type.
1109  *
1110  * @param[in]  type  volume type
1111  *
1112  * @return volume type description string
1113  */
1114 static_inline char *
1115 volumeTypeString(int type)
1116 {
1117     return
1118         (type == RWVOL ? "read/write" :
1119          (type == ROVOL ? "readonly" :
1120           (type == BACKVOL ? "backup" : "unknown")));
1121 }
1122
1123 /**
1124  * Return a short display string for the volume type.
1125  *
1126  * @param[in]  type  volume type
1127  *
1128  * @return volume type short description string
1129  */
1130 static_inline char *
1131 volumeTypeShortString(int type)
1132 {
1133     return
1134         (type == RWVOL ? "RW" :
1135          (type == ROVOL ? "RO" : (type == BACKVOL ? "BK" : "??")));
1136 }
1137
1138 /**
1139  * Print the volume header information
1140  *
1141  * @param[in]  volume object
1142  *
1143  * @return none
1144  */
1145 static void
1146 PrintHeader(Volume * vp)
1147 {
1148     printf("Volume header for volume %" AFS_VOLID_FMT " (%s)\n", afs_printable_VolumeId_lu(V_id(vp)), V_name(vp));
1149     printf("stamp.magic = %x, stamp.version = %u\n", V_stamp(vp).magic,
1150            V_stamp(vp).version);
1151     printf
1152         ("inUse = %d, inService = %d, blessed = %d, needsSalvaged = %d, dontSalvage = %d\n",
1153          V_inUse(vp), V_inService(vp), V_blessed(vp), V_needsSalvaged(vp),
1154          V_dontSalvage(vp));
1155     printf
1156         ("type = %d (%s), uniquifier = %u, needsCallback = %d, destroyMe = %x\n",
1157          V_type(vp), volumeTypeString(V_type(vp)), V_uniquifier(vp),
1158          V_needsCallback(vp), V_destroyMe(vp));
1159     printf
1160         ("id = %" AFS_VOLID_FMT ", parentId = %" AFS_VOLID_FMT ", cloneId = %" AFS_VOLID_FMT ", backupId = %" AFS_VOLID_FMT ", restoredFromId = %" AFS_VOLID_FMT "\n",
1161          afs_printable_VolumeId_lu(V_id(vp)), afs_printable_VolumeId_lu(V_parentId(vp)), afs_printable_VolumeId_lu(V_cloneId(vp)), afs_printable_VolumeId_lu(V_backupId(vp)), afs_printable_VolumeId_lu(V_restoredFromId(vp)));
1162     printf
1163         ("maxquota = %d, minquota = %d, maxfiles = %d, filecount = %d, diskused = %d\n",
1164          V_maxquota(vp), V_minquota(vp), V_maxfiles(vp), V_filecount(vp),
1165          V_diskused(vp));
1166     printf("creationDate = %s, copyDate = %s\n", date(V_creationDate(vp)),
1167            date(V_copyDate(vp)));
1168     printf("backupDate = %s, expirationDate = %s\n", date(V_backupDate(vp)),
1169            date(V_expirationDate(vp)));
1170     printf("accessDate = %s, updateDate = %s\n", date(V_accessDate(vp)),
1171            date(V_updateDate(vp)));
1172     printf("owner = %u, accountNumber = %u\n", V_owner(vp),
1173            V_accountNumber(vp));
1174     printf
1175         ("dayUse = %u; week = (%u, %u, %u, %u, %u, %u, %u), dayUseDate = %s\n",
1176          V_dayUse(vp), V_weekUse(vp)[0], V_weekUse(vp)[1], V_weekUse(vp)[2],
1177          V_weekUse(vp)[3], V_weekUse(vp)[4], V_weekUse(vp)[5],
1178          V_weekUse(vp)[6], date(V_dayUseDate(vp)));
1179     printf("volUpdateCounter = %u\n", V_volUpCounter(vp));
1180 }
1181
1182 /**
1183  * Get the size and times of a file
1184  *
1185  * @param[in]  fd     file descriptor of file to stat
1186  * @param[out] size   size of the file
1187  * @param[out] ctime  ctime of file as a formatted string
1188  * @param[out] mtime  mtime of file as a formatted string
1189  * @param[out] atime  atime of file as a formatted string
1190  *
1191  * @return error code
1192  *   @retval 0 success
1193  *   @retval -1 failed to retrieve file information
1194  */
1195 static int
1196 GetFileInfo(FD_t fd, afs_sfsize_t * size, char **ctime, char **mtime,
1197             char **atime)
1198 {
1199 #ifdef AFS_NT40_ENV
1200     BY_HANDLE_FILE_INFORMATION fi;
1201     LARGE_INTEGER fsize;
1202     if (!GetFileInformationByHandle(fd, &fi)) {
1203         fprintf(stderr, "%s: GetFileInformationByHandle failed\n", progname);
1204         return -1;
1205     }
1206     if (!GetFileSizeEx(fd, &fsize)) {
1207         fprintf(stderr, "%s: GetFileSizeEx failed\n", progname);
1208         return -1;
1209     }
1210     *size = fsize.QuadPart;
1211     *ctime = "N/A";
1212     *mtime = NT_date(&fi.ftLastWriteTime);
1213     *atime = NT_date(&fi.ftLastAccessTime);
1214 #else
1215     struct afs_stat_st status;
1216     if (afs_fstat(fd, &status) == -1) {
1217         fprintf(stderr, "%s: fstat failed %d\n", progname, errno);
1218         return -1;
1219     }
1220     *size = status.st_size;
1221     *ctime = date(status.st_ctime);
1222     *mtime = date(status.st_mtime);
1223     *atime = date(status.st_atime);
1224 #endif
1225     return 0;
1226 }
1227
1228 /**
1229  * Copy the inode data to a file in the current directory.
1230  *
1231  * @param[in] vdp     vnode details object
1232  *
1233  * @return none
1234  */
1235 void
1236 volinfo_SaveInode(struct VolInfoOpt *opt, struct VnodeDetails *vdp)
1237 {
1238     IHandle_t *ih;
1239     FdHandle_t *fdP;
1240     char nfile[50], buffer[256];
1241     int ofd = 0;
1242     afs_foff_t total;
1243     ssize_t len;
1244     Inode ino = VNDISK_GET_INO(vdp->vnode);
1245
1246     if (!VALID_INO(ino)) {
1247         return;
1248     }
1249
1250     IH_INIT(ih, V_device(vdp->vp), V_parentId(vdp->vp), ino);
1251     fdP = IH_OPEN(ih);
1252     if (fdP == NULL) {
1253         fprintf(stderr,
1254                 "%s: Can't open inode %s error %d (ignored)\n",
1255                 progname, PrintInode(NULL, ino), errno);
1256         return;
1257     }
1258     snprintf(nfile, sizeof nfile, "TmpInode.%s", PrintInode(NULL, ino));
1259     ofd = afs_open(nfile, O_CREAT | O_RDWR | O_TRUNC, 0600);
1260     if (ofd < 0) {
1261         fprintf(stderr,
1262                 "%s: Can't create file %s; error %d (ignored)\n",
1263                 progname, nfile, errno);
1264
1265         FDH_REALLYCLOSE(fdP);
1266         IH_RELEASE(ih);
1267         return;
1268     }
1269     total = 0;
1270     while (1) {
1271         ssize_t nBytes;
1272         len = FDH_PREAD(fdP, buffer, sizeof(buffer), total);
1273         if (len < 0) {
1274             FDH_REALLYCLOSE(fdP);
1275             IH_RELEASE(ih);
1276             close(ofd);
1277             unlink(nfile);
1278             fprintf(stderr,
1279                     "%s: Error while reading from inode %s (%d)\n",
1280                     progname, PrintInode(NULL, ino), errno);
1281             return;
1282         }
1283         if (len == 0)
1284             break;              /* No more input */
1285         nBytes = write(ofd, buffer, (size_t)len);
1286         if (nBytes != len) {
1287             FDH_REALLYCLOSE(fdP);
1288             IH_RELEASE(ih);
1289             close(ofd);
1290             unlink(nfile);
1291             fprintf(stderr,
1292                     "%s: Error while writing to \"%s\" (%d - ignored)\n",
1293                     progname, nfile, errno);
1294             return;
1295         }
1296         total += len;
1297     }
1298
1299     FDH_REALLYCLOSE(fdP);
1300     IH_RELEASE(ih);
1301     close(ofd);
1302     printf("... Copied inode %s to file %s (%lu bytes)\n",
1303            PrintInode(NULL, ino), nfile, (unsigned long)total);
1304 }
1305
1306 /**
1307  * get the VnodeDiskObject for a directory given its vnode id.
1308  *
1309  * @param[in]   vp       volume object
1310  * @param[in]   parent   vnode id to read
1311  * @param[out]  pvn      vnode disk object to populate
1312  *
1313  * @post pvn contains copy of disk object for parent id
1314  *
1315  * @return operation status
1316  *   @retval 0   success
1317  *   @retval -1  failure
1318  */
1319 static int
1320 GetDirVnode(struct VolInfoOpt *opt, Volume * vp, VnodeId parent, VnodeDiskObject * pvn)
1321 {
1322     afs_int32 code;
1323     afs_foff_t offset;
1324
1325     if (!DirIndexFd) {
1326         return -1;              /* previously failed to open the large vnode index. */
1327     }
1328     if (parent % 2 == 0) {
1329         fprintf(stderr, "%s: Invalid parent vnode id %lu in volume %lu\n",
1330                 progname,
1331                 afs_printable_uint32_lu(parent),
1332                 afs_printable_uint32_lu(V_id(vp)));
1333     }
1334     offset = vnodeIndexOffset(&VnodeClassInfo[vLarge], parent);
1335     code = FDH_SEEK(DirIndexFd, offset, 0);
1336     if (code == -1) {
1337         fprintf(stderr,
1338                 "%s: GetDirVnode: seek failed for %lu.%lu to offset %llu\n",
1339                 progname, afs_printable_uint32_lu(V_id(vp)),
1340                 afs_printable_uint32_lu(parent), (long long unsigned)offset);
1341         return -1;
1342     }
1343     code = FDH_READ(DirIndexFd, pvn, SIZEOF_LARGEDISKVNODE);
1344     if (code != SIZEOF_LARGEDISKVNODE) {
1345         fprintf(stderr,
1346                 "%s: GetDirVnode: read failed for %lu.%lu at offset %llu\n",
1347                 progname, afs_printable_uint32_lu(V_id(vp)),
1348                 afs_printable_uint32_lu(parent), (long long unsigned)offset);
1349         return -1;
1350     }
1351     if (opt->checkMagic && (pvn->vnodeMagic != LARGEVNODEMAGIC)) {
1352         fprintf(stderr, "%s: GetDirVnode: bad vnode magic for %lu.%lu at offset %llu\n",
1353                 progname, afs_printable_uint32_lu(V_id(vp)),
1354                 afs_printable_uint32_lu(parent), (long long unsigned)offset);
1355         return -1;
1356     }
1357     if (!pvn->dataVersion) {
1358         fprintf(stderr, "%s: GetDirVnode: dv is zero for %lu.%lu at offset %llu\n",
1359                 progname, afs_printable_uint32_lu(V_id(vp)),
1360                 afs_printable_uint32_lu(parent), (long long unsigned)offset);
1361         return -1;
1362     }
1363     return 0;
1364 }
1365
1366 /**
1367  * Perform inverse lookup on a vice directory object to map a fid onto a dirent string.
1368  *
1369  * @param[in]   vp          volume object
1370  * @param[in]   pvnode      parent directory vnode object
1371  * @param[in]   cvnid       child vnode id to inverse lookup
1372  * @param[in]   cuniq       child uniquifier to inverse lookup
1373  * @param[out]  dirent      buffer in which to store dirent string
1374  * @param[out]  dirent_len  length of dirent buffer
1375  *
1376  * @post dirent contains string for the (cvnid, cuniq) entry
1377  *
1378  * @return operation status
1379  *    @retval 0 success
1380  */
1381 static int
1382 GetDirEntry(Volume * vp, VnodeDiskObject * pvnode, VnodeId cvnid,
1383             afs_uint32 cuniq, char *dirent, size_t dirent_len)
1384 {
1385     DirHandle dir;
1386     Inode ino;
1387     int volumeChanged;
1388     afs_int32 code;
1389
1390     ino = VNDISK_GET_INO(pvnode);
1391     if (!VALID_INO(ino)) {
1392         fprintf(stderr, "%s: GetDirEntry invalid parent ino\n", progname);
1393         return -1;
1394     }
1395     SetSalvageDirHandle(&dir, V_parentId(vp), V_device(vp), ino,
1396                         &volumeChanged);
1397     code = afs_dir_InverseLookup(&dir, cvnid, cuniq, dirent, dirent_len);
1398     if (code) {
1399         fprintf(stderr, "%s: afs_dir_InverseLookup failed with code %d\n",
1400                 progname, code);
1401     }
1402     FidZap(&dir);
1403     return code;
1404 }
1405
1406 /**
1407  * Lookup the path of this vnode, relative to the root of the volume.
1408  *
1409  * @param[in] vdp    vnode details
1410  *
1411  * @return status
1412  *   @retval 0 success
1413  *   @retval -1 error
1414  */
1415 static int
1416 LookupPath(struct VolInfoOpt *opt, struct VnodeDetails *vdp)
1417 {
1418 #define MAX_PATH_LEN 1023
1419     static char path_buffer[MAX_PATH_LEN + 1];
1420     static char dirent[MAX_PATH_LEN + 1];
1421     char vnode_buffer[SIZEOF_LARGEDISKVNODE];
1422     struct VnodeDiskObject *pvn = (struct VnodeDiskObject *)vnode_buffer;
1423     int code = 0;
1424     int space;
1425     char *cursor;
1426     Volume *vp = vdp->vp;
1427     VnodeId parent = vdp->vnode->parent;
1428     VnodeId cvnid = vdp->vnodeNumber;
1429     afs_uint32 cuniq = vdp->vnode->uniquifier;
1430
1431     if (!parent) {
1432         vdp->path = "/";        /* this is root */
1433         return 0;
1434     }
1435
1436     space = sizeof(path_buffer) - 1;
1437     cursor = &path_buffer[space];
1438     *cursor = '\0';
1439
1440     while (parent) {
1441         int len;
1442
1443         code = GetDirVnode(opt, vp, parent, pvn);
1444         if (code) {
1445             cursor = NULL;
1446             break;
1447         }
1448         code = GetDirEntry(vp, pvn, cvnid, cuniq, dirent, MAX_PATH_LEN);
1449         if (code) {
1450             cursor = NULL;
1451             break;
1452         }
1453
1454         len = strlen(dirent);
1455         if (len == 0) {
1456             fprintf(stderr,
1457                     "%s: Failed to lookup path for fid %lu.%lu.%lu: empty dir entry\n",
1458                     progname, afs_printable_uint32_lu(V_id(vdp->vp)),
1459                     afs_printable_uint32_lu(vdp->vnodeNumber),
1460                     afs_printable_uint32_lu(vdp->vnode->uniquifier));
1461             cursor = NULL;
1462             code = -1;
1463             break;
1464         }
1465
1466         if (space < (len + 1)) {
1467             fprintf(stderr,
1468                     "%s: Failed to lookup path for fid %lu.%lu.%lu: path exceeds max length (%u).\n",
1469                     progname, afs_printable_uint32_lu(V_id(vdp->vp)),
1470                     afs_printable_uint32_lu(vdp->vnodeNumber),
1471                     afs_printable_uint32_lu(vdp->vnode->uniquifier),
1472                     MAX_PATH_LEN);
1473             cursor = NULL;
1474             code = -1;
1475             break;
1476         }
1477
1478         /* prepend path component */
1479         cursor -= len;
1480         memcpy(cursor, dirent, len);
1481         *--cursor = '/';
1482         space -= (len + 1);
1483
1484         /* next parent */
1485         cvnid = parent;
1486         cuniq = pvn->uniquifier;
1487         parent = pvn->parent;
1488     }
1489
1490     if (cursor) {
1491         vdp->path = cursor;
1492     }
1493     return code;
1494 }
1495
1496 /**
1497  * Read the symlink target and determine if this vnode is a mount point.
1498  *
1499  * @param[inout]   vdp    vnode details object
1500  *
1501  * @return error code
1502  *   @retval 0 success
1503  *   @retval -1 failure
1504  */
1505 static int
1506 ReadSymlinkTarget(struct VnodeDetails *vdp)
1507 {
1508 #define MAX_SYMLINK_LEN 1023
1509     static char buffer[MAX_SYMLINK_LEN + 1];
1510     int code;
1511     Volume *vp = vdp->vp;
1512     VnodeDiskObject *vnode = vdp->vnode;
1513     VnodeId vnodeNumber = vdp->vnodeNumber;
1514     IHandle_t *ihP = NULL;
1515     FdHandle_t *fdP = NULL;
1516     afs_fsize_t fileLength;
1517     int readLength;
1518     Inode ino;
1519
1520     ino = VNDISK_GET_INO(vnode);
1521     VNDISK_GET_LEN(fileLength, vnode);
1522
1523     if (fileLength > MAX_SYMLINK_LEN) {
1524         fprintf(stderr,
1525                 "%s: Symlink contents for fid (%lu.%lu.%lu.%lu) exceeds "
1526                 "%u, file length is %llu)!\n", progname,
1527                 afs_printable_uint32_lu(V_id(vp)),
1528                 afs_printable_uint32_lu(vnodeNumber),
1529                 afs_printable_uint32_lu(vnode->uniquifier),
1530                 afs_printable_uint32_lu(vnode->dataVersion),
1531                 MAX_SYMLINK_LEN,
1532                 fileLength);
1533         return -1;
1534     }
1535     if (fileLength == 0) {
1536         fprintf(stderr,
1537                 "%s: Symlink contents for fid (%lu.%lu.%lu.%lu) is empty.\n",
1538                 progname,
1539                 afs_printable_uint32_lu(V_id(vp)),
1540                 afs_printable_uint32_lu(vnodeNumber),
1541                 afs_printable_uint32_lu(vnode->uniquifier),
1542                 afs_printable_uint32_lu(vnode->dataVersion));
1543         return -1;
1544     }
1545
1546     IH_INIT(ihP, V_device(vp), V_parentId(vp), ino);
1547     fdP = IH_OPEN(ihP);
1548     if (fdP == NULL) {
1549         code = -1;
1550         goto cleanup;
1551     }
1552     if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
1553         code = -1;
1554         goto cleanup;
1555     }
1556     readLength = FDH_READ(fdP, buffer, fileLength);
1557     if (readLength < 0) {
1558         fprintf(stderr,
1559                 "%s: Error reading symlink contents for fid (%lu.%lu.%lu.%lu); "
1560                 "errno %d\n",
1561                 progname,
1562                 afs_printable_uint32_lu(V_id(vp)),
1563                 afs_printable_uint32_lu(vnodeNumber),
1564                 afs_printable_uint32_lu(vnode->uniquifier),
1565                 afs_printable_uint32_lu(vnode->dataVersion), errno);
1566         code = -1;
1567         goto cleanup;
1568     } else if (readLength != fileLength) {
1569         fprintf(stderr,
1570                 "%s: Symlink contents for fid (%lu.%lu.%lu.%lu) don't match "
1571                 "vnode file length metadata (len=%llu, actual=%lld)!\n",
1572                 progname,
1573                 afs_printable_uint32_lu(V_id(vp)),
1574                 afs_printable_uint32_lu(vnodeNumber),
1575                 afs_printable_uint32_lu(vnode->uniquifier),
1576                 afs_printable_uint32_lu(vnode->dataVersion), fileLength,
1577                 (long long)readLength);
1578         code = -1;
1579         goto cleanup;
1580     }
1581     code = 0;
1582
1583     if (readLength > 1 && (buffer[0] == '#' || buffer[0] == '%')
1584         && buffer[readLength - 1] == '.') {
1585         char *sep;
1586         buffer[readLength - 1] = '\0';  /* stringify; clobbers trailing dot */
1587         sep = strchr(buffer, ':');
1588         vdp->t = VNODE_U_MOUNT;
1589         vdp->u.mnt.type = buffer[0];
1590         if (!sep) {
1591             vdp->u.mnt.cell = NULL;
1592             vdp->u.mnt.vol = buffer + 1;
1593         } else {
1594             *sep = '\0';
1595             vdp->u.mnt.cell = buffer + 1;
1596             vdp->u.mnt.vol = sep + 1;
1597         }
1598     } else {
1599         buffer[readLength] = '\0';
1600         vdp->t = VNODE_U_SYMLINK;
1601         vdp->u.target = buffer;
1602     }
1603
1604   cleanup:
1605     if (fdP) {
1606         FDH_CLOSE(fdP);
1607     }
1608     if (ihP) {
1609         IH_RELEASE(ihP);
1610     }
1611     return code;
1612 }
1613
1614 /**
1615  * Print vnode details line
1616  *
1617  * @param[inout]  vdp   vnode details object
1618  *
1619  * @return none
1620  */
1621 void
1622 volinfo_PrintVnodeDetails(struct VolInfoOpt *opt, struct VnodeDetails *vdp)
1623 {
1624     switch (vdp->vnode->type) {
1625     case vNull:
1626         break;
1627     case vFile:
1628         if (opt->findVnType & FIND_FILE) {
1629             PrintColumns(opt, vdp, "file");
1630         }
1631         break;
1632     case vDirectory:
1633         if (opt->findVnType & FIND_DIR) {
1634             PrintColumns(opt, vdp, "dir");
1635         }
1636         break;
1637     case vSymlink:
1638         if (opt->findVnType & (FIND_MOUNT | FIND_SYMLINK)) {
1639             ReadSymlinkTarget(vdp);
1640             if ((opt->findVnType & FIND_MOUNT) && (vdp->t == VNODE_U_MOUNT)) {
1641                 PrintColumns(opt, vdp, "mount");
1642             }
1643             if ((opt->findVnType & FIND_SYMLINK) && (vdp->t == VNODE_U_SYMLINK)) {
1644                 PrintColumns(opt, vdp, "symlink");
1645             }
1646         }
1647         break;
1648     default:
1649         fprintf(stderr,
1650                 "%s: Warning: unexpected vnode type %u on fid %lu.%lu.%lu",
1651                 progname, vdp->vnode->type,
1652                 afs_printable_uint32_lu(V_id(vdp->vp)),
1653                 afs_printable_uint32_lu(vdp->vnodeNumber),
1654                 afs_printable_uint32_lu(vdp->vnode->uniquifier));
1655     }
1656 }
1657
1658 /**
1659  * Print each access entry of a vnode
1660  *
1661  * @param[in]  vdp   vnode details object
1662  *
1663  * @return none
1664  */
1665 void
1666 volinfo_ScanAcl(struct VolInfoOpt *opt, struct VnodeDetails *vdp)
1667 {
1668     int i;
1669     struct acl_accessList *acl;
1670     VnodeDiskObject *vnode = vdp->vnode;
1671
1672     if (vnode->type == vNull) {
1673         return;
1674     }
1675
1676     acl = VVnodeDiskACL(vnode);
1677     for (i = 0; i < acl->positive; i++) {
1678         vdp->t = VNODE_U_POS_ACCESS;
1679         vdp->u.access = &(acl->entries[i]);
1680         PrintColumns(opt, vdp, "acl");
1681     }
1682     for (i = (acl->total - 1); i >= (acl->total - acl->negative); i--) {
1683         vdp->t = VNODE_U_NEG_ACCESS;
1684         vdp->u.access = &(acl->entries[i]);
1685         PrintColumns(opt, vdp, "acl");
1686     }
1687 }
1688
1689 /**
1690  * Determine if the mode matches all the given masks.
1691  *
1692  * Returns true if the mode bits match all the given masks. A mask matches if at
1693  * least one bit in the mask is present in the mode bits.  An empty mode mask
1694  * list matches all modes (even if all the mode bits are zero.)
1695  *
1696  * param[in]  modeBits  unix mode bits of a vnode
1697  *
1698  */
1699 static int
1700 ModeMaskMatch(struct VolInfoOpt *opt, unsigned int modeBits)
1701 {
1702     int i;
1703
1704     for (i = 0; i < sizeof(opt->modeMask) / sizeof(*opt->modeMask) && opt->modeMask[i]; i++) {
1705         if ((opt->modeMask[i] & modeBits) == 0) {
1706             return 0;           /* at least one mode bit is not present */
1707         }
1708     }
1709     return 1;
1710 }
1711
1712 /**
1713  * Scan a volume index and handle each vnode
1714  *
1715  * @param[in] vp      volume object
1716  * @param[in] class   which index to scan
1717  *
1718  * @return none
1719  */
1720 static void
1721 HandleVnodes(struct VolInfoOpt *opt, Volume * vp, VnodeClass class)
1722 {
1723     afs_int32 diskSize =
1724         (class == vSmall ? SIZEOF_SMALLDISKVNODE : SIZEOF_LARGEDISKVNODE);
1725     char buf[SIZEOF_LARGEDISKVNODE];
1726     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
1727     StreamHandle_t *file = NULL;
1728     int vnodeIndex;
1729     afs_sfsize_t nVnodes;
1730     afs_foff_t offset = 0;
1731     IHandle_t *ih = vp->vnodeIndex[class].handle;
1732     FdHandle_t *fdP = NULL;
1733     afs_sfsize_t size;
1734     char *ctime, *atime, *mtime;
1735     struct opr_queue *scanList = &VnodeScanLists[class];
1736     struct opr_queue *cursor;
1737
1738     if (opr_queue_IsEmpty(scanList)) {
1739         return;
1740     }
1741
1742     for (opr_queue_Scan(scanList, cursor)) {
1743         struct VnodeScanProc *entry = (struct VnodeScanProc *)cursor;
1744         if (entry->heading) {
1745             printf("%s", entry->heading);
1746         }
1747     }
1748
1749     fdP = IH_OPEN(ih);
1750     if (fdP == NULL) {
1751         fprintf(stderr, "%s: open failed: ", progname);
1752         goto error;
1753     }
1754
1755     file = FDH_FDOPEN(fdP, "r");
1756     if (!file) {
1757         fprintf(stderr, "%s: fdopen failed\n", progname);
1758         goto error;
1759     }
1760
1761     if (GetFileInfo(fdP->fd_fd, &size, &ctime, &atime, &mtime) != 0) {
1762         goto error;
1763     }
1764     if (opt->dumpInodeTimes) {
1765         printf("ichanged : %s\nimodified: %s\niaccessed: %s\n\n", ctime,
1766                mtime, atime);
1767     }
1768
1769     nVnodes = (size / diskSize) - 1;
1770     if (nVnodes > 0) {
1771         STREAM_ASEEK(file, diskSize);
1772     } else
1773         nVnodes = 0;
1774
1775     for (vnodeIndex = 0;
1776          nVnodes && STREAM_READ(vnode, diskSize, 1, file) == 1;
1777          nVnodes--, vnodeIndex++, offset += diskSize) {
1778
1779         struct VnodeDetails vnodeDetails;
1780
1781         if (!ModeMaskMatch(opt, vnode->modeBits)) {
1782             continue;
1783         }
1784
1785         memset(&vnodeDetails, 0, sizeof(struct VnodeDetails));
1786         vnodeDetails.vp = vp;
1787         vnodeDetails.class = class;
1788         vnodeDetails.vnode = vnode;
1789         vnodeDetails.vnodeNumber = bitNumberToVnodeNumber(vnodeIndex, class);
1790         vnodeDetails.offset = offset;
1791         vnodeDetails.index = vnodeIndex;
1792
1793         for (opr_queue_Scan(scanList, cursor)) {
1794             struct VnodeScanProc *entry = (struct VnodeScanProc *)cursor;
1795             if (entry->proc) {
1796                 (*entry->proc) (opt, &vnodeDetails);
1797             }
1798         }
1799     }
1800
1801   error:
1802     if (file) {
1803         STREAM_CLOSE(file);
1804     }
1805     if (fdP) {
1806         FDH_CLOSE(fdP);
1807     }
1808 }
1809
1810 /**
1811  * Print vnode information
1812  *
1813  * @param[in] vdp          vnode details object
1814  *
1815  * @return none
1816  */
1817 void
1818 volinfo_PrintVnode(struct VolInfoOpt *opt, struct VnodeDetails *vdp)
1819 {
1820 #if defined(AFS_NAMEI_ENV)
1821     IHandle_t *ihtmpp;
1822     namei_t filename;
1823 #endif
1824     afs_foff_t offset = vdp->offset;
1825     VnodeDiskObject *vnode = vdp->vnode;
1826     afs_fsize_t fileLength;
1827     Inode ino;
1828
1829     ino = VNDISK_GET_INO(vnode);
1830     VNDISK_GET_LEN(fileLength, vnode);
1831
1832     /* The check for orphaned vnodes is currently limited to non-empty
1833      * vnodes with a parent of zero (and which are not the first entry
1834      * in the index). */
1835     if (opt->showOrphaned && (fileLength == 0 || vnode->parent || !offset))
1836         return;
1837
1838     printf
1839         ("%10lld Vnode %u.%u.%u cloned: %u, length: %llu linkCount: %d parent: %u",
1840          (long long)offset, vdp->vnodeNumber, vnode->uniquifier,
1841          vnode->dataVersion, vnode->cloned, (afs_uintmax_t) fileLength,
1842          vnode->linkCount, vnode->parent);
1843     if (opt->dumpInodeNumber)
1844         printf(" inode: %s", PrintInode(NULL, ino));
1845     if (opt->dumpDate)
1846         printf(" ServerModTime: %s", date(vnode->serverModifyTime));
1847 #if defined(AFS_NAMEI_ENV)
1848     if (opt->dumpFileNames) {
1849         IH_INIT(ihtmpp, V_device(vdp->vp), V_parentId(vdp->vp), ino);
1850         namei_HandleToName(&filename, ihtmpp);
1851 #if !defined(AFS_NT40_ENV)
1852         printf(" UFS-Filename: %s", filename.n_path);
1853 #else
1854         printf(" NTFS-Filename: %s", filename.n_path);
1855 #endif
1856     }
1857 #endif
1858     printf("\n");
1859 }
1860
1861 /**
1862  * Print the volume partition id
1863  *
1864  * @param[in]  vp  volume object
1865  *
1866  * @return none
1867  */
1868 static void
1869 PrintPartitionId(Volume * vp)
1870 {
1871     char *partition = VPartitionPath(V_partition(vp));
1872
1873     if (!strncmp(partition, "/vicep", 6)) {
1874         printf("%s", partition + 6);
1875     } else if (!strncmp(partition, "vicep", 5)) {
1876         printf("%s", partition + 5);
1877     } else {
1878         fprintf(stderr, "Invalid partition for volume id %lu\n",
1879                 afs_printable_uint32_lu(V_id(vp)));
1880         printf("%s", PLACEHOLDER);
1881     }
1882 }
1883
1884 /**
1885  * Print the vnode type description string
1886  *
1887  * @param[in]  type  vnode type
1888  *
1889  * @return none
1890  */
1891 static void
1892 volinfo_PrintVnodeType(int type)
1893 {
1894     switch (type) {
1895     case vNull:
1896         printf("null");
1897         break;
1898     case vFile:
1899         printf("file");
1900         break;
1901     case vDirectory:
1902         printf("dir");
1903         break;
1904     case vSymlink:
1905         printf("symlink");
1906         break;
1907     default:
1908         printf("unknown");
1909     }
1910 }
1911
1912 /**
1913  * Print right bits as string.
1914  *
1915  * param[in] rights  rights bitmap
1916  */
1917 static void
1918 PrintRights(int rights)
1919 {
1920     if (rights & PRSFS_READ) {
1921         printf("r");
1922     }
1923     if (rights & PRSFS_LOOKUP) {
1924         printf("l");
1925     }
1926     if (rights & PRSFS_INSERT) {
1927         printf("i");
1928     }
1929     if (rights & PRSFS_DELETE) {
1930         printf("d");
1931     }
1932     if (rights & PRSFS_WRITE) {
1933         printf("w");
1934     }
1935     if (rights & PRSFS_LOCK) {
1936         printf("k");
1937     }
1938     if (rights & PRSFS_ADMINISTER) {
1939         printf("a");
1940     }
1941     if (rights & PRSFS_USR0) {
1942         printf("A");
1943     }
1944     if (rights & PRSFS_USR1) {
1945         printf("B");
1946     }
1947     if (rights & PRSFS_USR2) {
1948         printf("C");
1949     }
1950     if (rights & PRSFS_USR3) {
1951         printf("D");
1952     }
1953     if (rights & PRSFS_USR4) {
1954         printf("E");
1955     }
1956     if (rights & PRSFS_USR5) {
1957         printf("F");
1958     }
1959     if (rights & PRSFS_USR6) {
1960         printf("G");
1961     }
1962     if (rights & PRSFS_USR7) {
1963         printf("H");
1964     }
1965 }
1966
1967 /**
1968  * Print the path to the namei file.
1969  */
1970 static void
1971 PrintNamei(Volume * vp, VnodeDiskObject * vnode)
1972 {
1973 #ifdef AFS_NAMEI_ENV
1974     namei_t name;
1975     IHandle_t *ihP = NULL;
1976     Inode ino;
1977     ino = VNDISK_GET_INO(vnode);
1978     IH_INIT(ihP, V_device(vp), V_parentId(vp), ino);
1979     namei_HandleToName(&name, ihP);
1980     printf("%s", name.n_path);
1981     IH_RELEASE(ihP);
1982 #else
1983     printf("%s", PLACEHOLDER);
1984 #endif
1985 }
1986
1987 /**
1988  * Print the column heading line.
1989  */
1990 static void
1991 PrintColumnHeading(struct VolInfoOpt *opt)
1992 {
1993     int i;
1994     const char *name;
1995
1996     for (i = 0; i < NumOutputColumns; i++) {
1997         if (i > 0) {
1998             printf("%s", opt->columnDelim);
1999         }
2000         name = ColumnName[OutputColumn[i]].name;
2001         while (*name) {
2002             putchar(toupper(*name++));
2003         }
2004     }
2005     printf("\n");
2006 }
2007
2008 /**
2009  * Print output columns for the vnode/acess entry.
2010  *
2011  * @param[in]  vdp   vnode details object
2012  * @param[in]  desc  type of line to be printed
2013  *
2014  * @return none
2015  */
2016 static void
2017 PrintColumns(struct VolInfoOpt *opt, struct VnodeDetails *vdp, const char *desc)
2018 {
2019     int i;
2020     afs_fsize_t length;
2021
2022     for (i = 0; i < NumOutputColumns; i++) {
2023         if (i > 0) {
2024             printf("%s", opt->columnDelim);
2025         }
2026         switch (OutputColumn[i]) {
2027         case col_host:
2028             printf("%s", opt->hostname);
2029             break;
2030         case col_desc:
2031             printf("%s", desc);
2032             break;
2033         case col_vid:
2034             printf("%lu", afs_printable_uint32_lu(V_id(vdp->vp)));
2035             break;
2036         case col_offset:
2037             printf("%llu", vdp->offset);
2038             break;
2039         case col_vtype:
2040             printf("%s", volumeTypeShortString(V_type(vdp->vp)));
2041             break;
2042         case col_vname:
2043             printf("%s", V_name(vdp->vp));
2044             break;
2045         case col_part:
2046             printf("%s", VPartitionPath(V_partition(vdp->vp)));
2047             break;
2048         case col_partid:
2049             PrintPartitionId(vdp->vp);
2050             break;
2051         case col_fid:
2052             printf("%lu.%lu.%lu",
2053                    afs_printable_uint32_lu(V_id(vdp->vp)),
2054                    afs_printable_uint32_lu(vdp->vnodeNumber),
2055                    afs_printable_uint32_lu(vdp->vnode->uniquifier));
2056             break;
2057         case col_path:
2058             if (!vdp->path) {
2059                 LookupPath(opt, vdp);
2060             }
2061             printf("%s", vdp->path ? vdp->path : PLACEHOLDER);
2062             break;
2063         case col_target:
2064             printf("%s",
2065                    (vdp->t == VNODE_U_SYMLINK ? vdp->u.target : PLACEHOLDER));
2066             break;
2067         case col_mount:
2068             if (vdp->t != VNODE_U_MOUNT) {
2069                 printf("%s", PLACEHOLDER);
2070             } else {
2071                 printf("%c", vdp->u.mnt.type);
2072                 if (vdp->u.mnt.cell) {
2073                     printf("%s:", vdp->u.mnt.cell);
2074                 }
2075                 printf("%s.", vdp->u.mnt.vol);
2076             }
2077             break;
2078         case col_mtype:
2079             printf("%c", (vdp->t == VNODE_U_MOUNT ? vdp->u.mnt.type : '-'));
2080             break;
2081         case col_mcell:
2082             printf("%s",
2083                    (vdp->t == VNODE_U_MOUNT && vdp->u.mnt.cell ? vdp->u.mnt.cell : PLACEHOLDER));
2084             break;
2085         case col_mvol:
2086             printf("%s",
2087                    (vdp->t == VNODE_U_MOUNT ? vdp->u.mnt.vol : PLACEHOLDER));
2088             break;
2089         case col_aid:
2090             if (vdp->t == VNODE_U_POS_ACCESS || vdp->t == VNODE_U_NEG_ACCESS) {
2091                 printf("%d", vdp->u.access->id);
2092             } else {
2093                 printf("%s", PLACEHOLDER);
2094             }
2095             break;
2096         case col_arights:
2097             if (vdp->t == VNODE_U_POS_ACCESS) {
2098                 printf("+");
2099                 PrintRights(vdp->u.access->rights);
2100             } else if (vdp->t == VNODE_U_NEG_ACCESS) {
2101                 printf("-");
2102                 PrintRights(vdp->u.access->rights);
2103             }
2104             break;
2105         case col_vntype:
2106             volinfo_PrintVnodeType(vdp->vnode->type);
2107             break;
2108         case col_cloned:
2109             printf("%c", vdp->vnode->cloned ? 'y' : 'n');
2110             break;
2111         case col_mode:
2112             printf("0%o", vdp->vnode->modeBits);
2113             break;
2114         case col_links:
2115             printf("%lu", afs_printable_uint32_lu(vdp->vnode->linkCount));
2116             break;
2117         case col_length:
2118             VNDISK_GET_LEN(length, vdp->vnode);
2119             printf("%llu", length);
2120             break;
2121         case col_uniq:
2122             printf("%lu", afs_printable_uint32_lu(vdp->vnode->uniquifier));
2123             break;
2124         case col_dv:
2125             printf("%lu", afs_printable_uint32_lu(vdp->vnode->dataVersion));
2126             break;
2127         case col_inode:
2128             printf("%" AFS_UINT64_FMT, VNDISK_GET_INO(vdp->vnode));
2129             break;
2130         case col_namei:
2131             PrintNamei(vdp->vp, vdp->vnode);
2132             break;
2133         case col_modtime:
2134             printf("%lu",
2135                    afs_printable_uint32_lu(vdp->vnode->unixModifyTime));
2136             break;
2137         case col_author:
2138             printf("%lu", afs_printable_uint32_lu(vdp->vnode->author));
2139             break;
2140         case col_owner:
2141             printf("%lu", afs_printable_uint32_lu(vdp->vnode->owner));
2142             break;
2143         case col_parent:
2144             printf("%lu", afs_printable_uint32_lu(vdp->vnode->parent));
2145             break;
2146         case col_magic:
2147             printf("0x%08X", vdp->vnode->vnodeMagic);
2148             break;
2149         case col_lock:
2150             printf("%lu.%lu",
2151                    afs_printable_uint32_lu(vdp->vnode->lock.lockCount),
2152                    afs_printable_uint32_lu(vdp->vnode->lock.lockTime));
2153             break;
2154         case col_smodtime:
2155             printf("%lu",
2156                    afs_printable_uint32_lu(vdp->vnode->serverModifyTime));
2157             break;
2158         case col_group:
2159             printf("%lu", afs_printable_uint32_lu(vdp->vnode->group));
2160             break;
2161         default:
2162             fprintf(stderr, "%s: Unknown column type: %d (%d)\n", progname,
2163                     OutputColumn[i], i);
2164             break;
2165         }
2166     }
2167     printf("\n");
2168 }