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