Remove DUX/OSF code
[openafs.git] / src / vol / test / listVicepx.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 **      Lists all files in a /vicepX partition. This started as an
12 **      exercise to know the layout of AFS data in a fileserver
13 **      partition. Later on, it proved useful in debugging problems 
14 **      at customer sites too. 
15 **
16 */
17 #include <afsconfig.h>
18 #include <afs/param.h>
19
20
21 #include <rx/xdr.h>
22 #include <afs/afsint.h>
23 #include <ctype.h>
24 #include <sys/param.h>
25 #if !defined(AFS_SGI_ENV)
26 #ifdef AFS_VFSINCL_ENV
27 #define VFS
28 #ifdef  AFS_SUN5_ENV
29 #include <sys/fs/ufs_fs.h>
30 #else
31 #include <ufs/fs.h>
32 #endif
33 #else /* AFS_VFSINCL_ENV */
34 #ifndef AFS_AIX_ENV
35 #include <sys/fs.h>
36 #endif
37 #endif /* AFS_VFSINCL_ENV */
38 #endif /* AFS_SGI_ENV */
39 #include <sys/errno.h>
40 #include <sys/stat.h>
41 #include <stdio.h>
42 #include <sys/file.h>
43 #if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_BSD_ENV))
44 #include <dirent.h>
45 #else
46 #include <sys/dir.h>
47 #endif
48 #ifdef  AFS_AIX_ENV
49 #include <sys/vfs.h>
50 #include <fcntl.h>
51 #else
52 #ifdef  AFS_HPUX_ENV
53 #include <fcntl.h>
54 #include <mntent.h>
55 #else
56 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
57 #ifdef  AFS_SUN5_ENV
58 #include <sys/mnttab.h>
59 #include <sys/mntent.h>
60 #else
61 #include <mntent.h>
62 #endif
63 #else
64 #if defined(AFS_SGI_ENV)
65 #include <fcntl.h>
66 #include <mntent.h>
67
68 /*
69 #include <sys/fs/efs.h>
70 */
71 #include "efs.h"                /* until 5.1 release */
72
73 #define ROOTINO EFS_ROOTINO
74 #else
75 #include <fstab.h>
76 #endif
77 #endif /* AFS_SGI_ENV */
78 #endif /* AFS_HPUX_ENV */
79 #endif
80 #include <netdb.h>
81 #include <netinet/in.h>
82 #include <sys/wait.h>
83 #include <setjmp.h>
84 #ifndef ITIMER_REAL
85 #include <sys/time.h>
86 #endif /* ITIMER_REAL */
87
88 #include "nfs.h"
89 #include <afs/errors.h>
90 #include "lock.h"
91 #include "lwp.h"
92 #include "vnode.h"
93 #include "volume.h"
94 #include "vldb.h"
95 #include "partition.h"
96 #include "filesignal.h"
97 #include "vutils.h"
98 #include "daemon_com.h"
99 #include "fssync.h"
100 #include <afs/auxinode.h>
101 #include <afs/dir.h>
102 #include <unistd.h>
103
104 #include "salvage.h"
105 int volumeId;
106 int VolumeChanged;              /* to satisfy library libdir use */
107
108 #include "listVicepx.h"
109 char *orphan_NoVnode = "ORPHANED_NoVnode";
110 char *orphan_NoUnique = "ORPHANED_NoUnique";
111
112 #define allNull         0x00
113 #define allFiles        0x01    /* equivalent to /bin/ls */
114 #define lFlag           0x02    /* equivalent to /bin/ls -l */
115 #define allDirs         0x04    /* equivalent to /bin/ls -ld */
116 #define contentsDInode  0x08    /* list contents of dir inode */
117 #define volInfo         0x10    /* list info from vol header */
118
119 extern DirEnt *lookup();
120 extern char *getFileName(), *getDirName(), *printStack();
121 extern DirEnt *hash[];
122
123 int
124 Usage(name)
125      char *name;
126 {
127     assert(name);
128     printf
129         ("Usage is %s -p <partition name> -v <volume name> [-ls | -lsl | -ld] [-volInfo] [-dir <directory inode>] \n",
130          name);
131     printf("-ls  : lists all files\n");
132     printf("-lsl : lists all files along with its properties\n");
133     printf("-ld :  lists all directories\n");
134     printf("-volInfo : lists volume header \n");
135     printf("-dir <inode number>: prints contents of directory inode\n");
136     exit(1);
137 }
138
139
140 main(argc, argv)
141      int argc;
142      char *argv[];
143 {
144     char fullName[32 + VNAMESIZE + sizeof(VHDREXT) + 4];
145     char partition[32], volume[VNAMESIZE];
146     struct stat statBuf;
147     struct VolumeHeader volumeHeader;
148     int fd, i, sawPart = 0, sawVolume = 0, sawDirContents = 0;
149     char option = allNull;      /* no default options */
150     Inode dirInode;             /* list contents of this dir Inode */
151
152     for (i = 1; i < argc; i++) {
153         if (!strcmp(argv[i], "-p")) {
154             if ((i + 1) >= argc)
155                 Usage(argv[0]);
156             assert(strlen(argv[i + 1]) < 32);
157             strcpy(partition, argv[++i]);
158             sawPart = 1;
159         } else if (!strcmp(argv[i], "-v")) {
160             if ((i + 1) >= argc)
161                 Usage(argv[0]);
162             assert(strlen(argv[i + 1]) < VNAMESIZE);
163             strcpy(volume, argv[++i]);
164             sawVolume = 1;
165         } else if (!strcmp(argv[i], "-dir")) {
166             if ((i + 1) >= argc)
167                 Usage(argv[0]);
168             dirInode = atoi(argv[++i]);
169             option |= contentsDInode;
170             sawDirContents = 1;
171         } else if (!strcmp(argv[i], "-ls"))
172             option |= allFiles;
173         else if (!strcmp(argv[i], "-lsl"))
174             option |= (allFiles | lFlag);
175         else if (!strcmp(argv[i], "-ld"))
176             option |= allDirs;
177         else if (!strcmp(argv[i], "-volInfo"))
178             option |= volInfo;
179         else
180             Usage(argv[0]);
181     }
182     /* check input parameters */
183     if (!sawPart || !sawVolume)
184         Usage(argv[0]);
185
186     /* extract volume id */
187     volumeId = atoi(volume);
188
189     /* construct  unix file name */
190     strcpy(fullName, partition);
191     strcat(fullName, "/V");
192     strcat(fullName, volume);
193     strcat(fullName, VHDREXT);
194
195     /* check to see that volume exists */
196     if (stat(fullName, &statBuf) < 0) {
197         printf("Error in stat(%s) : %d\n", fullName, errno);
198         exit(2);
199     }
200
201     /* read volume header */
202     if ((fd = open(fullName, O_RDONLY)) < 0) {
203         printf("Error in open(%s) : %d\n", fullName, errno);
204         exit(3);
205     }
206     if (read(fd, &volumeHeader, sizeof(struct VolumeHeader)) <
207         sizeof(struct VolumeHeader)) {
208         printf("Error in reading Volume Header : %d\n", errno);
209         exit(4);
210     }
211
212     switch (option) {
213     case volInfo:               /* volume header info */
214         printf
215             ("VolId:%d VolInfo:%d mag:%x vers:%d smallVnodeIndex:%d largeVnodeIndex:%d VoAcl:%d volMntTab:%d\n",
216              volumeHeader.id, volumeHeader.volumeInfo,
217              volumeHeader.stamp.magic, volumeHeader.stamp.version,
218              volumeHeader.smallVnodeIndex, volumeHeader.largeVnodeIndex,
219              volumeHeader.volumeAcl, volumeHeader.volumeMountTable);
220         break;
221
222     case contentsDInode:        /* list directory entries */
223         printContentsOfDirInode(statBuf.st_dev, dirInode, fullName, option);
224         break;
225     }
226
227     scanLargeVnode(statBuf.st_dev, volumeHeader.largeVnodeIndex, fullName,
228                    option);
229     if (option & allDirs)
230         printDirs(fullName);
231
232     if (option & allFiles)
233         scanSmallVnode(statBuf.st_dev, volumeHeader.smallVnodeIndex, fullName,
234                        option);
235     close(fd);
236 }
237
238 int
239 scanLargeVnode(dev, node, partitionName, option)
240      dev_t dev;
241      Inode node;
242      char *partitionName;
243      char option;               /* user options */
244 {
245     afs_int32 diskSize = SIZEOF_LARGEDISKVNODE;
246     int nVnodes, fdi, vnodeIndex, offset = 0;
247     char buf[SIZEOF_LARGEDISKVNODE];
248     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
249     FILE *file;
250     struct stat statBuf;
251
252     /* open this largeVodeIndex */
253     if ((fdi = iopen(dev, node, O_RDONLY)) < 0) {
254         printf("Error in reading node : %d\n", errno);
255         exit(5);
256     }
257
258     /* get a FILE pointer */
259     if ((file = fdopen(fdi, "r")) == 0) {
260         printf("fdopen failed : %d\n", errno);
261         exit(6);
262     }
263
264     /*find out how many directories are there in this volume */
265     if (fstat(fdi, &statBuf) < 0) {
266         printf("Error in stat(fd=%d): %d\n", fdi, errno);
267         exit(6);
268     }
269     nVnodes = (statBuf.st_size / diskSize) - 1;
270     if (nVnodes > 0)
271         fseek(file, diskSize, 0);
272     else
273         nVnodes = 0;
274
275     /* scan all entries in this volume */
276     DInit(10);                  /* initialise directory buffer */
277
278     for (vnodeIndex = 0; nVnodes && fread(vnode, diskSize, 1, file) == 1;
279          nVnodes--, vnodeIndex++, offset += diskSize) {
280         /* scan this directory */
281         int createDirEnt();
282         if ((vnode->type == vDirectory) && (vnode->inodeNumber)) {
283             DirHandle dir;
284             DirEnt *dirEntry;
285
286             dir.volume = volumeId;
287             dir.device = dev;
288             dir.cacheCheck = 0;
289             dir.inode = vnode->inodeNumber;
290 #ifdef  DEBUG
291             printf
292                 ("Directory inode %d (parent vnode = %d) contains the entries :\n",
293                  vnode->inodeNumber, vnode->parent);
294 #endif
295
296             assert(dirEntry = malloc(sizeof(DirEnt)));
297             dirEntry->inode = vnode->inodeNumber;
298             dirEntry->numEntries = 0;
299             dirEntry->vnodeName = NULL;
300             EnumerateDir(&dir, &createDirEnt, dirEntry);
301             insertHash(dirEntry);       /* insert in hash table */
302         }
303     }
304     fclose(file);
305 #ifdef DEBUG
306     printHash();
307 #endif
308 }
309
310
311
312 int
313 createDirEnt(dirEntry, fileName, vnode, unique)
314      DirEnt *dirEntry;
315      char *fileName;
316      afs_int32 vnode;
317      afs_int32 unique;
318 {
319     int fdi;
320     FILE *file;
321     struct stat statBuf;
322
323     /* fil up special fields for itself and parent */
324     if (strcmp(fileName, ".") == 0) {
325         dirEntry->vnode = vnode;
326         return;
327     }
328     if (strcmp(fileName, "..") == 0) {
329         dirEntry->vnodeParent = vnode;
330         return;
331     }
332
333     (dirEntry->numEntries)++;
334     assert(dirEntry->vnodeName =
335            realloc(dirEntry->vnodeName,
336                    dirEntry->numEntries * sizeof(VnodeName)));
337     dirEntry->vnodeName[dirEntry->numEntries - 1].vnode = vnode;
338     dirEntry->vnodeName[dirEntry->numEntries - 1].vunique = unique;
339     dirEntry->vnodeName[dirEntry->numEntries - 1].name = strdup(fileName);
340     assert(dirEntry->vnodeName[dirEntry->numEntries - 1].name);
341 }
342
343
344 int
345 scanSmallVnode(dev, node, partitionName, option)
346      dev_t dev;
347      Inode node;
348      char *partitionName;
349      char option;               /* user options */
350 {
351     afs_int32 diskSize = SIZEOF_SMALLDISKVNODE;
352     int nVnodes, fdi, vnodeIndex, offset = 0;
353     char buf[SIZEOF_LARGEDISKVNODE];
354     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
355     FILE *file;
356     struct stat statBuf;
357
358     /* open this smallVodeIndex */
359     if ((fdi = iopen(dev, node, O_RDONLY)) < 0) {
360         printf("Error in reading node : %d\n", errno);
361         exit(5);
362     }
363
364     /* get a FILE pointer */
365     if ((file = fdopen(fdi, "r")) == 0) {
366         printf("fdopen failed : %d\n", errno);
367         exit(6);
368     }
369
370     /*find out how many files are there in this volume */
371     if (fstat(fdi, &statBuf) < 0) {
372         printf("Error in stat(fd=%d): %d\n", fdi, errno);
373         exit(6);
374     }
375     nVnodes = (statBuf.st_size / diskSize) - 1;
376     if (nVnodes > 0)
377         fseek(file, diskSize, 0);
378     else
379         nVnodes = 0;
380
381     /* scan all entries in this volume */
382     for (vnodeIndex = 0; nVnodes && fread(vnode, diskSize, 1, file) == 1;
383          nVnodes--, vnodeIndex++, offset += 1)
384         if ((vnode->type == vFile) || (vnode->type == vSymlink)) {
385             char *name, *fullPathName;
386             int pNode, nNode, orphan = 0;
387             DirEnt *dir;
388 #ifdef FILE_DEBUG
389             printf(" File Inode = %d parent vnode=%d ", vnode->inodeNumber,
390                    vnode->parent);
391 #endif
392
393             if ((dir = lookup(vnode->parent)) == 0)     /* orphaned */
394                 orphan = 1, pushStack(orphan_NoVnode);
395             if (!orphan) {
396                 name = getFileName(dir, vnode->uniquifier);
397                 if (name == 0)
398                     orphan = 1, pushStack(orphan_NoUnique);
399             }
400             if (!orphan) {
401                 /* push the file name on stack */
402                 pushStack(name);
403                 pNode = vnode->parent;
404                 nNode = dir->vnodeParent;
405             }
406             while (!orphan && (pNode != nNode)) {
407                 if ((dir = lookup(nNode)) == 0) {
408                     orphan = 1, pushStack(orphan_NoVnode);
409                     break;
410                 }
411                 if ((name = getDirName(dir, pNode)) == 0) {
412                     orphan = 1, pushStack(orphan_NoVnode);
413                     break;
414                 }
415                 pushStack(name);
416                 pNode = nNode;
417                 nNode = dir->vnodeParent;
418             }
419             fullPathName = printStack();        /* full name of file or symLink */
420             if (vnode->type == vSymlink) {      /* check if mount point */
421                 /* read contents of link */
422                 struct stat statLink;
423                 int fdLink;
424                 char *symLink;
425                 if ((fdLink = iopen(dev, vnode->inodeNumber, O_RDONLY)) < 0) {
426                     printf("Error in opening symbolic link : %d\n", errno);
427                     exit(10);
428                 }
429                 if (fstat(fdLink, &statLink) < 0) {
430                     printf("Error in symLink stat(fd=%d): %d\n", fdLink,
431                            errno);
432                     exit(12);
433                 }
434                 assert(symLink = malloc(statLink.st_size + 1));
435                 if (read(fdLink, symLink, statLink.st_size) < 0) {
436                     printf("Error in reading symbolic link : %d\n", errno);
437                     exit(11);
438                 }
439                 symLink[statLink.st_size] = 0;  /* null termination */
440                 if (symLink[0] == '#')  /* this is a mount point */
441                     printf("Volume %s mounted on %s%s\n", symLink,
442                            partitionName, fullPathName);
443                 free(symLink);
444                 close(fdLink);
445             }
446             if (option & allFiles) {
447                 if (option & lFlag) {
448                     switch (vnode->type) {
449                     case vFile:
450                         printf("F ");
451                         break;
452                     case vDirectory:
453                         printf("D ");
454                         break;
455                     case vSymlink:
456                         printf("S ");
457                         break;
458                     default:
459                         printf("U ");
460                         break;
461                     }
462                     printf("Ind:%d ", vnode->inodeNumber);
463                     printf("Mod:%x ", vnode->modeBits);
464                     printf("Lnk:%d ", vnode->linkCount);
465                     printf("Own:%d ", vnode->owner);
466                     printf("Grp:%d ", vnode->group);
467                     printf("Siz:%d ", vnode->length);
468                 }
469                 printf("~%s\n", fullPathName);
470             }
471         }
472
473     fclose(file);
474 }
475
476 /* Lists all directories in the volume */
477 printDirs(partitionName)
478      char *partitionName;
479 {
480     int i, j, vnode, inode;
481     DirEnt *ptr, *dir, *tmpDir;
482
483     /* The root level vnode for this volume */
484     tmpDir = lookup(1);         /* root vnode is 1 */
485     if (tmpDir == 0)
486         printf("Root vnode(1) does not exists :%s\n", partitionName);
487     else
488         printf("D Ind:%d Vnd:1 ~\n", tmpDir->inode);
489
490     for (i = 0; i < MAX_HASH_SIZE; i++)
491         for (ptr = (DirEnt *) hash[i]; ptr; ptr = ptr->next)
492             for (j = 0; j < ptr->numEntries; j++) {
493                 int nVnode, pVnode;
494                 char *fullPathName, *name;
495
496                 pVnode = ptr->vnodeParent;      /* parent vnode */
497                 nVnode = ptr->vnode;    /* this dir vnode */
498                 vnode = ptr->vnodeName[j].vnode;        /* my Vnode */
499
500                 /* directory vnode numbers are odd */
501                 if ((vnode % 2) == 0)
502                     continue;
503
504                 tmpDir = lookup(vnode);
505                 if (!tmpDir) {  /* orphaned directory */
506                     printf("%s : vnode:%d \n", orphan_NoVnode, vnode);
507                     continue;
508                 }
509                 inode = tmpDir->inode;  /* the inode for this vnode */
510
511                 pushStack(ptr->vnodeName[j].name);
512
513                 while (pVnode != 1) {
514                     dir = lookup(pVnode);
515                     if (dir == 0) {     /* orphan */
516                         pushStack(orphan_NoVnode);
517                         break;
518                     }
519                     name = getDirName(dir, nVnode);
520                     if (name == 0) {
521                         pushStack(orphan_NoVnode);
522                         break;
523                     }
524                     pushStack(name);
525                     nVnode = pVnode;
526                     pVnode = dir->vnodeParent;
527                 }
528                 fullPathName = printStack();    /* full path name of directory */
529                 printf("D Ind:%d Vnd:%d ~%s\n", inode, vnode, fullPathName);
530             }
531 }
532
533 /* figure out how many pages in use in a directory, given ptr to its (locked) he
534 ader */
535 static
536 ComputeUsedPages(dhp)
537      struct DirHeader *dhp;
538 {
539     afs_int32 usedPages, i;
540
541     if (dhp->header.pgcount != 0) {
542         /* new style */
543         usedPages = ntohs(dhp->header.pgcount);
544     } else {
545         /* old style */
546         usedPages = 0;
547         for (i = 0; i < MAXPAGES; i++) {
548             if (dhp->alloMap[i] == EPP) {
549                 usedPages = i;
550                 break;
551             }
552         }
553         if (usedPages == 0)
554             usedPages = MAXPAGES;
555     }
556     return usedPages;
557 }
558
559 printContentsOfDirInode(device, dirInode, fullName, options)
560      dev_t device;
561      Inode dirInode;
562      char *fullName;
563      char options;
564 {
565     int fd, i, j, usedPages, pages;
566     FILE *file;
567     struct stat statBuf;
568     char dirPage[2048];
569     struct DirHeader *dhp = (struct DirHeader *)&dirPage[0];
570     struct DirEntry *de;
571     struct PageHeader *pg;
572
573     fd = iopen(device, dirInode, O_RDONLY);
574     if (fd <= 0) {
575         printf("Cannot open direcory inode %d\n", dirInode);
576         return -1;
577     }
578     if ((file = fdopen(fd, "r")) == 0) {        /* for buffered read */
579         printf("fdopen failed : %d\n", errno);
580         close(fd);
581         return -1;
582     }
583     if (fstat(fd, &statBuf) < 0) {
584         printf("Error in stat(fd=%d): %d\n", fd, errno);
585         return -1;
586     }
587     /* read first page */
588     if (fread(&dirPage, sizeof(dirPage), 1, file) != 1) {
589         printf("Cannot read dir header from inode %d(errno %d)\n", dirInode,
590                errno);
591         fclose(file);
592         return -1;
593     }
594     usedPages = ComputeUsedPages(dhp);
595
596     printf("Alloc map: ");
597     for (i = 0; i < MAXPAGES; i++) {
598         if ((i % 16) == 0)
599             printf("\n");
600         printf("%.2x ", (unsigned char)dhp->alloMap[i]);
601     }
602     printf("\nHash table:");
603     for (i = 0; i < NHASHENT; i++) {
604         if ((i % 16) == 0)
605             printf("\n");
606         printf("%.2d ", dhp->hashTable[i]);
607     }
608     printf("\n");
609
610     /* print header of first page */
611     printf("--------------- Page 0 ---------------\n");
612     printf("pgcnt      :%d\n", usedPages);
613     printf("tag        :%d\n", dhp->header.tag);
614     printf("freecnt    :%d(not used)\n", dhp->header.freecount);
615     printf("freebitmap :");
616     for (i = 0; i < EPP / 8; i++)
617         printf("%.2x ", (unsigned char)(dhp->header.freebitmap[i]));
618     printf("\n");
619
620     /* print slots in the first page of this directory */
621     de = ((struct DirPage0 *)dirPage)->entry;
622     for (i = DHE + 1; i < EPP; i++, de = (struct DirEntry *)((char *)de + 32))
623         printf("ent %d: f=%d l=%d n=%d vn=%d vu=%d name:%s\n", i, de->flag,
624                de->length, de->next, de->fid.vnode, de->fid.vunique,
625                de->name);
626
627     /* read all succeeding pages of this directory */
628     for (pages = 1; pages < usedPages; pages++) {
629         if (fread(&dirPage, sizeof(dirPage), 1, file) != 1) {
630             printf("Cannot read %s page  from inode %d(errno %d)\n", pages,
631                    dirInode, errno);
632             fclose(file);
633             return -1;
634         }
635         pg = &((struct DirPage1 *)dirPage)->header;     /* page header */
636         de = ((struct DirPage1 *)dirPage)->entry;
637
638         /* print page header info */
639         printf("--------------- Page %d ---------------\n", pages);
640         printf("pgcnt      :%d\n", pg->pgcount);
641         printf("tag        :%d\n", pg->tag);
642         printf("freecnt    :%d(not used)\n", pg->freecount);
643         printf("freebitmap :");
644         for (i = 0; i < EPP / 8; i++)
645             printf("%.2x ", (unsigned char)(pg->freebitmap[i]));
646         printf("\n");
647
648         /* print slots in this page */
649         for (i = 1; i < EPP; i++, de = (struct DirEntry *)((char *)de + 32))
650             printf("ent %d: f=%d l=%d n=%d vn=%d vu=%d name:%s\n", i,
651                    de->flag, de->length, de->next, de->fid.vnode,
652                    de->fid.vunique, de->name);
653     }
654
655     fclose(file);
656     return 0;
657 }