2 * Copyright 2000, International Business Machines Corporation and others.
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
13 Institution: The Information Technology Center, Carnegie-Mellon University
17 #include <afsconfig.h>
18 #include <afs/param.h>
33 #include <sys/param.h>
40 #include <afs/afsint.h>
42 #include <afs/errors.h>
45 #include <afs/afssyscalls.h>
49 #include "partition.h"
50 #include "viceinode.h"
51 #include "volinodes.h"
52 #include <afs/afssyscalls.h>
61 #define afs_stat stat64
62 #define afs_fstat fstat64
63 #define afs_open open64
64 #else /* !O_LARGEFILE */
66 #define afs_fstat fstat
68 #endif /* !O_LARGEFILE */
70 int DumpVnodes = 0; /* Dump everything, i.e. summary of all vnodes */
71 int DumpInodeNumber = 0; /* Dump inode numbers with vnodes */
72 int DumpDate = 0; /* Dump vnode date (server modify date) with vnode */
73 int InodeTimes = 0; /* Dump some of the dates associated with inodes */
74 #if defined(AFS_NAMEI_ENV)
75 int PrintFileNames = 0;
79 int dsizeOnly = 0, totvolsize = 0, Vauxsize = 0, Vdiskused = 0, Vvnodesize =
81 int Totvolsize = 0, TVauxsize = 0, TVdiskused = 0, TVvnodesize = 0;
82 int Stotvolsize = 0, SVauxsize = 0, SVdiskused = 0, SVvnodesize = 0;
83 int fixheader = 0, saveinodes = 0, orphaned = 0;
86 /* Forward Declarations */
87 void PrintHeader(register Volume * vp);
88 void HandleAllPart(void);
89 void HandlePart(struct DiskPartition *partP);
90 void HandleVolume(struct DiskPartition *partP, char *name);
91 struct DiskPartition *FindCurrentPartition(void);
92 Volume *AttachVolume(struct DiskPartition *dp, char *volname,
93 register struct VolumeHeader *header);
94 #if defined(AFS_NAMEI_ENV)
95 void PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
96 Inode ino, Volume * vp);
98 void PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
101 void PrintVnodes(Volume * vp, VnodeClass class);
106 #define MAX_DATE_RESULT 100
107 static char results[8][MAX_DATE_RESULT];
109 struct tm *tm = localtime(&date);
112 (void)strftime(buf, 32, "%Y/%m/%d.%H:%M:%S", tm); /* NT does not have %T */
113 (void)afs_snprintf(results[next = (next + 1) & 7], MAX_DATE_RESULT,
114 "%lu (%s)", (unsigned long)date, buf);
115 return results[next];
119 #include "AFS_component_version_number.c"
122 char name[VMAXPATHLEN];
127 ReadHdr1(IHandle_t * ih, char *to, int size, u_int magic, u_int version)
129 struct versionStamp *vsn;
133 vsn = (struct versionStamp *)to;
135 code = IH_IREAD(ih, 0, to, size);
139 if (vsn->magic != magic) {
141 printf("Inode %s: Bad magic %x (%x): IGNORED\n",
142 PrintInode(NULL, ih->ih_ino), vsn->magic, magic);
145 /* Check is conditional, in case caller wants to inspect version himself */
146 if (version && vsn->version != version) {
148 printf("Inode %s: Bad version %x (%x): IGNORED\n",
149 PrintInode(NULL, ih->ih_ino), vsn->version, version);
151 if (bad && fixheader) {
153 vsn->version = version;
154 printf("Special index inode %s has a bad header. Reconstructing...\n",
155 PrintInode(NULL, ih->ih_ino));
156 code = IH_IWRITE(ih, 0, to, size);
158 printf("Write failed; header left in damaged state\n");
161 if (!dsizeOnly && !saveinodes) {
162 printf("Inode %s: Good magic %x and version %x\n",
163 PrintInode(NULL, ih->ih_ino), magic, version);
171 AttachVolume(struct DiskPartition * dp, char *volname,
172 register struct VolumeHeader * header)
177 vp = (Volume *) calloc(1, sizeof(Volume));
178 vp->specialStatus = 0;
179 vp->device = dp->device;
181 IH_INIT(vp->vnodeIndex[vLarge].handle, dp->device, header->parent,
182 header->largeVnodeIndex);
183 IH_INIT(vp->vnodeIndex[vSmall].handle, dp->device, header->parent,
184 header->smallVnodeIndex);
185 IH_INIT(vp->diskDataHandle, dp->device, header->parent,
187 IH_INIT(V_linkHandle(vp), dp->device, header->parent, header->linkTable);
188 vp->cacheCheck = 0; /* XXXX */
189 vp->shuttingDown = 0;
190 vp->goingOffline = 0;
192 vp->header = (struct volHeader *)calloc(1, sizeof(*vp->header));
193 ec = ReadHdr1(V_diskDataHandle(vp), (char *)&V_disk(vp),
194 sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
196 struct IndexFileHeader iHead;
197 ec = ReadHdr1(vp->vnodeIndex[vSmall].handle, (char *)&iHead,
198 sizeof(iHead), SMALLINDEXMAGIC, SMALLINDEXVERSION);
201 struct IndexFileHeader iHead;
202 ec = ReadHdr1(vp->vnodeIndex[vLarge].handle, (char *)&iHead,
203 sizeof(iHead), LARGEINDEXMAGIC, LARGEINDEXVERSION);
207 struct versionStamp stamp;
208 ec = ReadHdr1(V_linkHandle(vp), (char *)&stamp, sizeof(stamp),
209 LINKTABLEMAGIC, LINKTABLEVERSION);
219 handleit(struct cmd_syndesc *as)
221 register struct cmd_item *ti;
225 struct DiskPartition *partP = NULL;
229 if (geteuid() != 0) {
230 printf("vol-info must be run as root; sorry\n");
235 if (as->parms[0].items)
239 if (as->parms[1].items)
243 if (as->parms[2].items)
247 if (as->parms[3].items)
251 if (as->parms[4].items)
255 if ((ti = as->parms[5].items))
257 if ((ti = as->parms[6].items))
258 volumeId = atoi(ti->data);
259 if (as->parms[7].items)
263 if (as->parms[8].items) {
269 if (as->parms[9].items) {
273 if (as->parms[10].items) {
279 if (as->parms[11].items) {
283 #if defined(AFS_NAMEI_ENV)
284 if (as->parms[12].items) {
293 err = VAttachPartitions();
295 printf("%d partitions had errors during attach.\n", err);
299 partP = VGetPartition(partName, 0);
301 printf("%s is not an AFS partition name on this server.\n",
317 partP = FindCurrentPartition();
319 printf("Current partition is not a vice partition.\n");
323 (void)afs_snprintf(name1, sizeof name1, VFORMAT,
324 (unsigned long)volumeId);
325 if (dsizeOnly && !saveinodes)
327 ("Volume-Id\t Volsize Auxsize Inodesize AVolsize SizeDiff (VolName)\n");
328 HandleVolume(partP, name1);
335 struct DiskPartition *
336 FindCurrentPartition()
338 int dr = _getdrive();
339 struct DiskPartition *dp;
342 for (dp = DiskPartitionList; dp; dp = dp->next) {
343 if (*dp->devName - 'A' == dr)
347 printf("Current drive is not a valid vice partition.\n");
352 struct DiskPartition *
353 FindCurrentPartition()
358 struct DiskPartition *dp;
360 if (!getcwd(partName, 1023)) {
364 p = strchr(&partName[1], '/');
369 if (!(dp = VGetPartition(partName, 0))) {
372 printf("%s is not a valid vice partition.\n", partName);
382 struct DiskPartition *partP;
385 for (partP = DiskPartitionList; partP; partP = partP->next) {
386 printf("Processing Partition %s:\n", partP->name);
388 Stotvolsize += Totvolsize;
389 SVauxsize += TVauxsize;
390 SVvnodesize += TVvnodesize;
391 SVdiskused += TVdiskused;
395 printf("\nServer Totals%12d%9d%10d%10d%9d\n", SVdiskused, SVauxsize,
396 SVvnodesize, Stotvolsize, Stotvolsize - SVdiskused);
402 HandlePart(struct DiskPartition *partP)
410 (void)sprintf(pname, "%s\\", VPartitionPath(partP));
412 char *p = VPartitionPath(partP);
415 if (chdir(p) == -1) {
416 printf("Can't chdir to partition %s; giving up\n", p);
419 if ((dirp = opendir(".")) == NULL) {
420 printf("Can't read directory %s; giving up\n", p);
423 if (dsizeOnly && !saveinodes)
425 ("Volume-Id\t Volsize Auxsize Inodesize AVolsize SizeDiff (VolName)\n");
426 while ((dp = readdir(dirp))) {
427 p = (char *)strrchr(dp->d_name, '.');
428 if (p != NULL && strcmp(p, VHDREXT) == 0) {
429 HandleVolume(partP, dp->d_name);
430 Totvolsize += totvolsize;
431 TVauxsize += Vauxsize;
432 TVvnodesize += Vvnodesize;
433 TVdiskused += Vdiskused;
439 printf("\nPart Totals %12d%9d%10d%10d%9d (%d volumes)\n\n",
440 TVdiskused, TVauxsize, TVvnodesize, Totvolsize,
441 Totvolsize - TVdiskused, nvols);
447 HandleVolume(struct DiskPartition *dp, char *name)
449 struct VolumeHeader header;
450 struct VolumeDiskHeader diskHeader;
451 struct afs_stat status, stat;
455 char headerName[1024];
458 printf("volinfo: -online not supported\n");
463 (void)afs_snprintf(headerName, sizeof headerName, "%s/%s",
464 VPartitionPath(dp), name);
465 if ((fd = afs_open(headerName, O_RDONLY)) == -1
466 || afs_fstat(fd, &status) == -1) {
467 printf("Volinfo: Cannot read volume header %s\n", name);
471 n = read(fd, &diskHeader, sizeof(diskHeader));
473 if (n != sizeof(diskHeader)
474 || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
475 printf("Volinfo: Error reading volume header %s\n", name);
478 if (diskHeader.stamp.version != VOLUMEHEADERVERSION) {
480 ("Volinfo: Volume %s, version number is incorrect; volume needs salvage\n",
484 DiskToVolumeHeader(&header, &diskHeader);
491 if (afs_fstat(fd, &stat) == -1) {
495 if (!dsizeOnly && !saveinodes) {
496 printf("Volume header (size = %d):\n", size = stat.st_size);
497 printf("\tstamp\t= 0x%x\n", header.stamp.version);
498 printf("\tVolId\t= %u\n", header.id);
501 IH_INIT(ih, dp->device, header.id, header.volumeInfo);
504 perror("opening volume info");
507 code = FDH_SIZE(fdP);
512 FDH_REALLYCLOSE(fdP);
515 if (!dsizeOnly && !saveinodes) {
516 printf("\tparent\t= %u\n", header.parent);
517 printf("\tInfo inode\t= %s (size = %d)\n",
518 PrintInode(NULL, header.volumeInfo), code);
521 IH_INIT(ih, dp->device, header.id, header.smallVnodeIndex);
524 perror("opening small vnode index");
527 code = FDH_SIZE(fdP);
532 FDH_REALLYCLOSE(fdP);
535 if (!dsizeOnly && !saveinodes) {
536 printf("\tSmall inode\t= %s (size = %d)\n",
537 PrintInode(NULL, header.smallVnodeIndex), code);
540 IH_INIT(ih, dp->device, header.id, header.largeVnodeIndex);
543 perror("opening large vnode index");
546 code = FDH_SIZE(fdP);
551 FDH_REALLYCLOSE(fdP);
554 if (!dsizeOnly && !saveinodes) {
555 printf("\tLarge inode\t= %s (size = %d)\n",
556 PrintInode(NULL, header.largeVnodeIndex), code);
558 printf("Total aux volume size = %d\n\n", size);
562 IH_INIT(ih, dp->device, header.id, header.linkTable);
565 perror("opening link table index");
568 code = FDH_SIZE(fdP);
573 FDH_REALLYCLOSE(fdP);
576 if (!dsizeOnly && !saveinodes) {
577 printf("\tLink inode\t= %s (size = %d)\n",
578 PrintInode(NULL, header.linkTable), code);
579 printf("Total aux volume size = %d\n\n", size);
585 vp = AttachVolume(dp, name, &header);
587 printf("Volinfo: Error attaching volume header %s\n", name);
593 if (!dsizeOnly && !saveinodes)
594 printf("\nLarge vnodes (directories)\n");
595 PrintVnodes(vp, vLarge);
596 if (!dsizeOnly && !saveinodes) {
597 printf("\nSmall vnodes(files, symbolic links)\n");
601 printf("Saving all volume files to current directory ...\n");
602 PrintVnodes(vp, vSmall);
605 Vauxsize = Vauxsize / 1024;
606 Vvnodesize = Vvnodesize / 1024;
607 totvolsize = Vauxsize + Vvnodesize;
610 ("Volume-Id\t Volsize Auxsize Inodesize AVolsize SizeDiff (VolName)\n");
612 printf("%u\t%9d%9d%10d%10d%9d\t%24s\n", V_id(vp), Vdiskused, Vauxsize,
613 Vvnodesize, totvolsize, totvolsize - Vdiskused, V_name(vp));
618 main(int argc, char **argv)
620 register struct cmd_syndesc *ts;
623 ts = cmd_CreateSyntax(NULL, handleit, 0, "Dump volume's internal state");
624 cmd_AddParm(ts, "-online", CMD_FLAG, CMD_OPTIONAL,
625 "Get info from running fileserver");
626 cmd_AddParm(ts, "-vnode", CMD_FLAG, CMD_OPTIONAL, "Dump vnode info");
627 cmd_AddParm(ts, "-date", CMD_FLAG, CMD_OPTIONAL,
628 "Also dump vnode's mod date");
629 cmd_AddParm(ts, "-inode", CMD_FLAG, CMD_OPTIONAL,
630 "Dump vnode's inode number");
631 cmd_AddParm(ts, "-itime", CMD_FLAG, CMD_OPTIONAL,
632 "Dump special inode's mod times");
633 cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL,
634 "AFS partition name (default current partition)");
635 cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
636 cmd_AddParm(ts, "-header", CMD_FLAG, CMD_OPTIONAL,
637 "Dump volume's header info");
638 cmd_AddParm(ts, "-sizeOnly", CMD_FLAG, CMD_OPTIONAL,
639 "Dump volume's size");
640 cmd_AddParm(ts, "-fixheader", CMD_FLAG, CMD_OPTIONAL,
641 "Try to fix header");
642 cmd_AddParm(ts, "-saveinodes", CMD_FLAG, CMD_OPTIONAL,
643 "Try to save all inodes");
644 cmd_AddParm(ts, "-orphaned", CMD_FLAG, CMD_OPTIONAL,
645 "List all dir/files without a parent");
646 #if defined(AFS_NAMEI_ENV)
647 cmd_AddParm(ts, "-filenames", CMD_FLAG, CMD_OPTIONAL, "Print filenames");
649 code = cmd_Dispatch(argc, argv);
653 #define typestring(type) (type == RWVOL? "read/write": type == ROVOL? "readonly": type == BACKVOL? "backup": "unknown")
656 PrintHeader(register Volume * vp)
658 Vdiskused = V_diskused(vp);
659 if (dsizeOnly || saveinodes)
661 printf("Volume header for volume %u (%s)\n", V_id(vp), V_name(vp));
662 printf("stamp.magic = %x, stamp.version = %u\n", V_stamp(vp).magic,
663 V_stamp(vp).version);
665 ("inUse = %d, inService = %d, blessed = %d, needsSalvaged = %d, dontSalvage = %d\n",
666 V_inUse(vp), V_inService(vp), V_blessed(vp), V_needsSalvaged(vp),
669 ("type = %d (%s), uniquifier = %u, needsCallback = %d, destroyMe = %x\n",
670 V_type(vp), typestring(V_type(vp)), V_uniquifier(vp),
671 V_needsCallback(vp), V_destroyMe(vp));
673 ("id = %u, parentId = %u, cloneId = %u, backupId = %u, restoredFromId = %u\n",
674 V_id(vp), V_parentId(vp), V_cloneId(vp), V_backupId(vp),
675 V_restoredFromId(vp));
677 ("maxquota = %d, minquota = %d, maxfiles = %d, filecount = %d, diskused = %d\n",
678 V_maxquota(vp), V_minquota(vp), V_maxfiles(vp), V_filecount(vp),
680 printf("creationDate = %s, copyDate = %s\n", date(V_creationDate(vp)),
681 date(V_copyDate(vp)));
682 printf("backupDate = %s, expirationDate = %s\n", date(V_backupDate(vp)),
683 date(V_expirationDate(vp)));
684 printf("accessDate = %s, updateDate = %s\n", date(V_accessDate(vp)),
685 date(V_updateDate(vp)));
686 printf("owner = %u, accountNumber = %u\n", V_owner(vp),
687 V_accountNumber(vp));
689 ("dayUse = %u; week = (%u, %u, %u, %u, %u, %u, %u), dayUseDate = %s\n",
690 V_dayUse(vp), V_weekUse(vp)[0], V_weekUse(vp)[1], V_weekUse(vp)[2],
691 V_weekUse(vp)[3], V_weekUse(vp)[4], V_weekUse(vp)[5],
692 V_weekUse(vp)[6], date(V_dayUseDate(vp)));
696 * OS independent file info. Die on failure.
700 NT_date(FILETIME * ft)
702 static char result[8][64];
707 if (!FileTimeToLocalFileTime(ft, &lft)
708 || !FileTimeToSystemTime(&lft, &st)) {
709 printf("Time conversion failed.\n");
712 sprintf(result[next = ((next + 1) & 7)], "%4d/%02d/%02d.%2d:%2d:%2d",
713 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
719 GetFileInfo(FD_t fd, int *size, char **ctime, char **mtime, char **atime)
722 BY_HANDLE_FILE_INFORMATION fi;
723 if (!GetFileInformationByHandle(fd, &fi)) {
724 printf("GetFileInformationByHandle failed, exiting\n");
727 *size = (int)fi.nFileSizeLow;
729 *mtime = NT_date(&fi.ftLastWriteTime);
730 *atime = NT_date(&fi.ftLastAccessTime);
732 struct afs_stat status;
733 if (afs_fstat(fd, &status) == -1) {
734 printf("fstat failed %d\n", errno);
737 *size = (int)status.st_size;
738 *ctime = date(status.st_ctime);
739 *mtime = date(status.st_mtime);
740 *atime = date(status.st_atime);
745 PrintVnodes(Volume * vp, VnodeClass class)
748 (class == vSmall ? SIZEOF_SMALLDISKVNODE : SIZEOF_LARGEDISKVNODE);
749 char buf[SIZEOF_LARGEDISKVNODE];
750 struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
751 StreamHandle_t *file;
752 register int vnodeIndex, nVnodes, offset = 0;
754 IHandle_t *ih = vp->vnodeIndex[class].handle;
757 char *ctime, *atime, *mtime;
758 char nfile[50], buffer[256];
759 int total, ofd, len, code, bad = 0;
763 printf("open failed\n");
767 file = FDH_FDOPEN(fdP, "r");
769 printf("fdopen failed\n");
773 GetFileInfo(fdP->fd_fd, &size, &ctime, &atime, &mtime);
774 if (InodeTimes && !dsizeOnly) {
775 printf("ichanged : %s\nimodified: %s\niaccessed: %s\n\n", ctime,
779 nVnodes = (size / diskSize) - 1;
781 STREAM_SEEK(file, diskSize, 0);
786 nVnodes && STREAM_READ(vnode, diskSize, 1, file) == 1;
787 nVnodes--, vnodeIndex++, offset += diskSize) {
789 ino = VNDISK_GET_INO(vnode);
791 if (VALID_INO(ino) && (class == vSmall)) {
794 IH_INIT(ih1, V_device(vp), V_parentId(vp), ino);
797 printf("Can't open inode %s error %d (ignored)\n",
798 PrintInode(NULL, ino), errno);
801 (void)afs_snprintf(nfile, sizeof nfile, "TmpInode.%s",
802 PrintInode(NULL, ino));
803 ofd = afs_open(nfile, O_CREAT | O_RDWR | O_TRUNC, 0600);
805 printf("Can't create file %s; error %d (ignored)\n",
811 len = FDH_READ(fdP1, buffer, sizeof(buffer));
813 FDH_REALLYCLOSE(fdP1);
818 ("Error while reading from inode %s (%d - ignored)\n",
819 PrintInode(NULL, ino), errno);
824 break; /* No more input */
825 code = write(ofd, buffer, len);
827 FDH_REALLYCLOSE(fdP1);
832 ("Error while writing to \"%s\" (%d - ignored)\n",
841 FDH_REALLYCLOSE(fdP1);
844 printf("... Copied inode %s to file %s (%d bytes)\n",
845 PrintInode(NULL, ino), nfile, total);
848 #if defined(AFS_NAMEI_ENV)
849 PrintVnode(offset, vnode,
850 bitNumberToVnodeNumber(vnodeIndex, class), ino, vp);
852 PrintVnode(offset, vnode,
853 bitNumberToVnodeNumber(vnodeIndex, class), ino);
861 #if defined(AFS_NAMEI_ENV)
863 PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
864 Inode ino, Volume * vp)
867 PrintVnode(int offset, VnodeDiskObject * vnode, VnodeId vnodeNumber,
871 #if defined(AFS_NAMEI_ENV)
873 #if !defined(AFS_NT40_ENV)
876 char filename[MAX_PATH];
879 afs_fsize_t fileLength;
881 VNDISK_GET_LEN(fileLength, vnode);
882 Vvnodesize += fileLength;
885 if (orphaned && (fileLength == 0 || vnode->parent || !offset))
888 ("%10d Vnode %u.%u.%u cloned: %u, length: %llu linkCount: %d parent: %u",
889 offset, vnodeNumber, vnode->uniquifier, vnode->dataVersion,
890 vnode->cloned, (afs_uintmax_t) fileLength, vnode->linkCount,
893 printf(" inode: %s", PrintInode(NULL, ino));
895 printf(" ServerModTime: %s", date(vnode->serverModifyTime));
896 #if defined(AFS_NAMEI_ENV)
897 if (PrintFileNames) {
898 IH_INIT(ihtmpp, V_device(vp), V_parentId(vp), ino);
899 #if !defined(AFS_NT40_ENV)
900 namei_HandleToName(&filename, ihtmpp);
901 printf(" UFS-Filename: %s", filename.n_path);
903 nt_HandleToName(filename, ihtmpp);
904 printf(" NTFS-Filename: %s", filename);