1 /*-
2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * %sccs.include.redist.c%
6 */
7
8 #ifndef lint
9 static char copyright[] =
10 "@(#) Copyright (c) 1991, 1993\n\
11 The Regents of the University of California. All rights reserved.\n";
12 #endif /* not lint */
13
14 #ifndef lint
15 static char sccsid[] = "@(#)dumplfs.c 8.5 (Berkeley) 05/24/95";
16 #endif /* not lint */
17
18 #include <sys/param.h>
19 #include <sys/ucred.h>
20 #include <sys/mount.h>
21 #include <sys/time.h>
22
23 #include <ufs/ufs/dinode.h>
24 #include <ufs/lfs/lfs.h>
25
26 #include <err.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <fstab.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include "extern.h"
35
36 static void addseg __P((char *));
37 static void dump_cleaner_info __P((struct lfs *, void *));
38 static void dump_dinode __P((struct dinode *));
39 static void dump_ifile __P((int, struct lfs *, int));
40 static int dump_ipage_ifile __P((int, IFILE *, int));
41 static int dump_ipage_segusage __P((struct lfs *, int, IFILE *, int));
42 static void dump_segment __P((int, int, daddr_t, struct lfs *, int));
43 static int dump_sum __P((int, struct lfs *, SEGSUM *, int, daddr_t));
44 static void dump_super __P((struct lfs *));
45 static void usage __P((void));
46
47 typedef struct seglist SEGLIST;
48 struct seglist {
49 SEGLIST *next;
50 int num;
51 };
52 SEGLIST *seglist;
53
54 int daddr_shift;
55 char *special;
56
57 /* Segment Usage formats */
58 #define print_suheader \
59 (void)printf("segnum\tflags\tnbytes\tninos\tnsums\tlastmod\n")
60
61 #define print_suentry(i, sp) \
62 (void)printf("%d\t%c%c%c\t%d\t%d\t%d\t%s", i, \
63 (((sp)->su_flags & SEGUSE_ACTIVE) ? 'A' : ' '), \
64 (((sp)->su_flags & SEGUSE_DIRTY) ? 'D' : 'C'), \
65 (((sp)->su_flags & SEGUSE_SUPERBLOCK) ? 'S' : ' '), \
66 (sp)->su_nbytes, (sp)->su_ninos, (sp)->su_nsums, \
67 ctime((time_t *)&(sp)->su_lastmod))
68
69 /* Ifile formats */
70 #define print_iheader \
71 (void)printf("inum\tstatus\tversion\tdaddr\t\tfreeptr\n")
72 #define print_ientry(i, ip) \
73 if (ip->if_daddr == LFS_UNUSED_DADDR) \
74 (void)printf("%d\tFREE\t%d\t \t\t%d\n", \
75 i, ip->if_version, ip->if_nextfree); \
76 else \
77 (void)printf("%d\tINUSE\t%d\t%8X \n", \
78 i, ip->if_version, ip->if_daddr)
79 int
main(argc,argv)80 main(argc, argv)
81 int argc;
82 char *argv[];
83 {
84 struct lfs lfs_sb1, lfs_sb2, *lfs_master;
85 daddr_t seg_addr;
86 int ch, do_allsb, do_ientries, fd, segnum;
87
88 do_allsb = 0;
89 do_ientries = 0;
90 while ((ch = getopt(argc, argv, "ais:")) != -1)
91 switch(ch) {
92 case 'a': /* Dump all superblocks */
93 do_allsb = 1;
94 break;
95 case 'i': /* Dump ifile entries */
96 do_ientries = 1;
97 break;
98 case 's': /* Dump out these segments */
99 addseg(optarg);
100 break;
101 default:
102 usage();
103 }
104 argc -= optind;
105 argv += optind;
106
107 if (argc != 1)
108 usage();
109
110 special = argv[0];
111 if ((fd = open(special, O_RDONLY, 0)) < 0)
112 err(1, "%s", special);
113
114 /* Read the first superblock */
115 get(fd, LFS_LABELPAD, &lfs_sb1, sizeof(struct lfs));
116 daddr_shift = lfs_sb1.lfs_bshift - lfs_sb1.lfs_fsbtodb;
117
118 /*
119 * Read the second superblock and figure out which check point is
120 * most up to date.
121 */
122 get(fd,
123 lfs_sb1.lfs_sboffs[1] << daddr_shift, &lfs_sb2, sizeof(struct lfs));
124
125 lfs_master = &lfs_sb1;
126 if (lfs_sb1.lfs_tstamp < lfs_sb2.lfs_tstamp)
127 lfs_master = &lfs_sb2;
128
129 (void)printf("Master Superblock:\n");
130 dump_super(lfs_master);
131
132 dump_ifile(fd, lfs_master, do_ientries);
133
134 if (seglist != NULL)
135 for (; seglist != NULL; seglist = seglist->next) {
136 seg_addr = lfs_master->lfs_sboffs[0] + seglist->num *
137 (lfs_master->lfs_ssize << lfs_master->lfs_fsbtodb);
138 dump_segment(fd,
139 seglist->num, seg_addr, lfs_master, do_allsb);
140 }
141 else
142 for (segnum = 0, seg_addr = lfs_master->lfs_sboffs[0];
143 segnum < lfs_master->lfs_nseg; segnum++, seg_addr +=
144 lfs_master->lfs_ssize << lfs_master->lfs_fsbtodb)
145 dump_segment(fd,
146 segnum, seg_addr, lfs_master, do_allsb);
147
148 (void)close(fd);
149 exit(0);
150 }
151
152 /*
153 * We are reading all the blocks of an inode and dumping out the ifile table.
154 * This code could be tighter, but this is a first pass at getting the stuff
155 * printed out rather than making this code incredibly efficient.
156 */
157 static void
dump_ifile(fd,lfsp,do_ientries)158 dump_ifile(fd, lfsp, do_ientries)
159 int fd;
160 struct lfs *lfsp;
161 int do_ientries;
162 {
163 IFILE *ipage;
164 struct dinode *dip, *dpage;
165 daddr_t addr, *addrp, *dindir, *iaddrp, *indir;
166 int block_limit, i, inum, j, nblocks, nsupb, psize;
167
168 psize = lfsp->lfs_bsize;
169 addr = lfsp->lfs_idaddr;
170
171 if (!(dpage = malloc(psize)))
172 err(1, NULL);
173 get(fd, addr << daddr_shift, dpage, psize);
174
175 for (dip = dpage + INOPB(lfsp) - 1; dip >= dpage; --dip)
176 if (dip->di_inumber == LFS_IFILE_INUM)
177 break;
178
179 if (dip < dpage)
180 errx(1, "unable to locate ifile inode");
181
182 (void)printf("\nIFILE inode\n");
183 dump_dinode(dip);
184
185 (void)printf("\nIFILE contents\n");
186 nblocks = dip->di_size >> lfsp->lfs_bshift;
187 block_limit = MIN(nblocks, NDADDR);
188
189 /* Get the direct block */
190 if ((ipage = malloc(psize)) == NULL)
191 err(1, NULL);
192 for (inum = 0, addrp = dip->di_db, i = 0; i < block_limit;
193 i++, addrp++) {
194 get(fd, *addrp << daddr_shift, ipage, psize);
195 if (i < lfsp->lfs_cleansz) {
196 dump_cleaner_info(lfsp, ipage);
197 print_suheader;
198 continue;
199 }
200
201 if (i < (lfsp->lfs_segtabsz + lfsp->lfs_cleansz)) {
202 inum = dump_ipage_segusage(lfsp, inum, ipage,
203 lfsp->lfs_sepb);
204 if (!inum)
205 if(!do_ientries)
206 goto e0;
207 else
208 print_iheader;
209 } else
210 inum = dump_ipage_ifile(inum, ipage, lfsp->lfs_ifpb);
211
212 }
213
214 if (nblocks <= NDADDR)
215 goto e0;
216
217 /* Dump out blocks off of single indirect block */
218 if (!(indir = malloc(psize)))
219 err(1, NULL);
220 get(fd, dip->di_ib[0] << daddr_shift, indir, psize);
221 block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
222 for (addrp = indir; i < block_limit; i++, addrp++) {
223 if (*addrp == LFS_UNUSED_DADDR)
224 break;
225 get(fd, *addrp << daddr_shift,ipage, psize);
226 if (i < lfsp->lfs_cleansz) {
227 dump_cleaner_info(lfsp, ipage);
228 continue;
229 } else
230 i -= lfsp->lfs_cleansz;
231
232 if (i < lfsp->lfs_segtabsz) {
233 inum = dump_ipage_segusage(lfsp, inum, ipage,
234 lfsp->lfs_sepb);
235 if (!inum)
236 if(!do_ientries)
237 goto e1;
238 else
239 print_iheader;
240 } else
241 inum = dump_ipage_ifile(inum, ipage, lfsp->lfs_ifpb);
242 }
243
244 if (nblocks <= lfsp->lfs_nindir * lfsp->lfs_ifpb)
245 goto e1;
246
247 /* Get the double indirect block */
248 if (!(dindir = malloc(psize)))
249 err(1, NULL);
250 get(fd, dip->di_ib[1] << daddr_shift, dindir, psize);
251 for (iaddrp = dindir, j = 0; j < lfsp->lfs_nindir; j++, iaddrp++) {
252 if (*iaddrp == LFS_UNUSED_DADDR)
253 break;
254 get(fd, *iaddrp << daddr_shift, indir, psize);
255 block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
256 for (addrp = indir; i < block_limit; i++, addrp++) {
257 if (*addrp == LFS_UNUSED_DADDR)
258 break;
259 get(fd, *addrp << daddr_shift, ipage, psize);
260 if (i < lfsp->lfs_cleansz) {
261 dump_cleaner_info(lfsp, ipage);
262 continue;
263 } else
264 i -= lfsp->lfs_cleansz;
265
266 if (i < lfsp->lfs_segtabsz) {
267 inum = dump_ipage_segusage(lfsp,
268 inum, ipage, lfsp->lfs_sepb);
269 if (!inum)
270 if(!do_ientries)
271 goto e2;
272 else
273 print_iheader;
274 } else
275 inum = dump_ipage_ifile(inum,
276 ipage, lfsp->lfs_ifpb);
277 }
278 }
279 e2: free(dindir);
280 e1: free(indir);
281 e0: free(dpage);
282 free(ipage);
283 }
284
285 static int
dump_ipage_ifile(i,pp,tot)286 dump_ipage_ifile(i, pp, tot)
287 int i;
288 IFILE *pp;
289 int tot;
290 {
291 IFILE *ip;
292 int cnt, max;
293
294 max = i + tot;
295
296 for (ip = pp, cnt = i; cnt < max; cnt++, ip++)
297 print_ientry(cnt, ip);
298 return (max);
299 }
300
301 static int
dump_ipage_segusage(lfsp,i,pp,tot)302 dump_ipage_segusage(lfsp, i, pp, tot)
303 struct lfs *lfsp;
304 int i;
305 IFILE *pp;
306 int tot;
307 {
308 SEGUSE *sp;
309 int cnt, max;
310
311 max = i + tot;
312 for (sp = (SEGUSE *)pp, cnt = i;
313 cnt < lfsp->lfs_nseg && cnt < max; cnt++, sp++)
314 print_suentry(cnt, sp);
315 if (max >= lfsp->lfs_nseg)
316 return (0);
317 else
318 return (max);
319 }
320
321 static void
dump_dinode(dip)322 dump_dinode(dip)
323 struct dinode *dip;
324 {
325 int i;
326
327 (void)printf("%s%d\t%s%d\t%s%d\t%s%d\t%s%d\n",
328 "mode ", dip->di_mode,
329 "nlink ", dip->di_nlink,
330 "uid ", dip->di_uid,
331 "gid ", dip->di_gid,
332 "size ", dip->di_size);
333 (void)printf("%s%s%s%s%s%s",
334 "atime ", ctime(&dip->di_atime),
335 "mtime ", ctime(&dip->di_mtime),
336 "ctime ", ctime(&dip->di_ctime));
337 (void)printf("inum %d\n", dip->di_inumber);
338 (void)printf("Direct Addresses\n");
339 for (i = 0; i < NDADDR; i++) {
340 (void)printf("\t0x%X", dip->di_db[i]);
341 if ((i % 6) == 5)
342 (void)printf("\n");
343 }
344 for (i = 0; i < NIADDR; i++)
345 (void)printf("\t0x%X", dip->di_ib[i]);
346 (void)printf("\n");
347 }
348
349 static int
dump_sum(fd,lfsp,sp,segnum,addr)350 dump_sum(fd, lfsp, sp, segnum, addr)
351 struct lfs *lfsp;
352 SEGSUM *sp;
353 int fd, segnum;
354 daddr_t addr;
355 {
356 FINFO *fp;
357 daddr_t *dp;
358 int i, j;
359 int ck;
360 int numbytes;
361 struct dinode *inop;
362
363 if (sp->ss_magic != SS_MAGIC ||
364 sp->ss_sumsum != (ck = cksum(&sp->ss_datasum,
365 LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum)))) {
366 (void)printf("dumplfs: %s %d address 0x%lx\n",
367 "corrupt summary block; segment", segnum, addr);
368 return(0);
369 }
370
371 (void)printf("Segment Summary Info at 0x%lx\tmagic no: 0x%x\n",
372 addr, sp->ss_magic);
373 (void)printf(" %s0x%X\t%s%d\t%s%d\n %s0x%X\t%s0x%X",
374 "next ", sp->ss_next,
375 "nfinfo ", sp->ss_nfinfo,
376 "ninos ", sp->ss_ninos,
377 "sumsum ", sp->ss_sumsum,
378 "datasum ", sp->ss_datasum );
379 (void)printf("\tcreate %s", ctime((time_t *)&sp->ss_create));
380
381 /* Dump out inode disk addresses */
382 dp = (daddr_t *)sp;
383 dp += LFS_SUMMARY_SIZE / sizeof(daddr_t);
384 inop = malloc(1 << lfsp->lfs_bshift);
385 printf(" Inode addresses:");
386 numbytes = 0;
387 for (dp--, i = 0; i < sp->ss_ninos; dp--) {
388 numbytes += lfsp->lfs_bsize; /* add bytes for inode block */
389 printf("\t0x%X {", *dp);
390 get(fd, *dp << (lfsp->lfs_bshift - lfsp->lfs_fsbtodb), inop,
391 (1 << lfsp->lfs_bshift));
392 for (j = 0; i < sp->ss_ninos && j < INOPB(lfsp); j++, i++) {
393 if (j > 0)
394 (void)printf(", ");
395 (void)printf("%d", inop[j].di_inumber);
396 }
397 (void)printf("}");
398 if (((i/INOPB(lfsp)) % 4) == 3)
399 (void)printf("\n");
400 }
401 free(inop);
402
403 printf("\n");
404 for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; i++) {
405 (void)printf(" FINFO for inode: %d version %d nblocks %d lastlength %d\n",
406 fp->fi_ino, fp->fi_version, fp->fi_nblocks, fp->fi_lastlength);
407 dp = &(fp->fi_blocks[0]);
408 for (j = 0; j < fp->fi_nblocks; j++, dp++) {
409 (void)printf("\t%d", *dp);
410 if ((j % 8) == 7)
411 (void)printf("\n");
412 if (j == fp->fi_nblocks - 1)
413 numbytes += fp->fi_lastlength;
414 else
415 numbytes += lfsp->lfs_bsize;
416 }
417 if ((j % 8) != 0)
418 (void)printf("\n");
419 fp = (FINFO *)dp;
420 }
421 return (numbytes);
422 }
423
424 static void
dump_segment(fd,segnum,addr,lfsp,dump_sb)425 dump_segment(fd, segnum, addr, lfsp, dump_sb)
426 int fd, segnum;
427 daddr_t addr;
428 struct lfs *lfsp;
429 int dump_sb;
430 {
431 struct lfs lfs_sb, *sbp;
432 SEGSUM *sump;
433 char sumblock[LFS_SUMMARY_SIZE];
434 int did_one, nbytes, sb;
435 off_t sum_offset, super_off;
436
437 (void)printf("\nSEGMENT %d (Disk Address 0x%X)\n",
438 addr >> (lfsp->lfs_segshift - daddr_shift), addr);
439 sum_offset = (addr << (lfsp->lfs_bshift - lfsp->lfs_fsbtodb));
440
441 sb = 0;
442 did_one = 0;
443 do {
444 get(fd, sum_offset, sumblock, LFS_SUMMARY_SIZE);
445 sump = (SEGSUM *)sumblock;
446 if (sump->ss_sumsum != cksum (&sump->ss_datasum,
447 LFS_SUMMARY_SIZE - sizeof(sump->ss_sumsum))) {
448 sbp = (struct lfs *)sump;
449 if (sb = (sbp->lfs_magic == LFS_MAGIC)) {
450 super_off = sum_offset;
451 sum_offset += LFS_SBPAD;
452 } else if (did_one)
453 break;
454 else {
455 printf("Segment at 0x%X corrupt\n", addr);
456 break;
457 }
458 } else {
459 nbytes = dump_sum(fd, lfsp, sump, segnum, sum_offset >>
460 (lfsp->lfs_bshift - lfsp->lfs_fsbtodb));
461 if (nbytes)
462 sum_offset += LFS_SUMMARY_SIZE + nbytes;
463 else
464 sum_offset = 0;
465 did_one = 1;
466 }
467 } while (sum_offset);
468
469 if (dump_sb && sb) {
470 get(fd, super_off, &lfs_sb, sizeof(struct lfs));
471 dump_super(&lfs_sb);
472 }
473 return;
474 }
475
476 static void
dump_super(lfsp)477 dump_super(lfsp)
478 struct lfs *lfsp;
479 {
480 int i;
481
482 (void)printf("%s0x%X\t%s0x%X\t%s%d\t%s%d\n",
483 "magic ", lfsp->lfs_magic,
484 "version ", lfsp->lfs_version,
485 "size ", lfsp->lfs_size,
486 "ssize ", lfsp->lfs_ssize);
487 (void)printf("%s%d\t\t%s%d\t%s%d\t%s%d\n",
488 "dsize ", lfsp->lfs_dsize,
489 "bsize ", lfsp->lfs_bsize,
490 "fsize ", lfsp->lfs_fsize,
491 "frag ", lfsp->lfs_frag);
492
493 (void)printf("%s%d\t\t%s%d\t%s%d\t%s%d\n",
494 "minfree ", lfsp->lfs_minfree,
495 "inopb ", lfsp->lfs_inopb,
496 "ifpb ", lfsp->lfs_ifpb,
497 "nindir ", lfsp->lfs_nindir);
498
499 (void)printf("%s%d\t\t%s%d\t%s%d\t%s%d\n",
500 "nseg ", lfsp->lfs_nseg,
501 "nspf ", lfsp->lfs_nspf,
502 "cleansz ", lfsp->lfs_cleansz,
503 "segtabsz ", lfsp->lfs_segtabsz);
504
505 (void)printf("%s0x%X\t%s%d\t%s0x%qX\t%s%d\n",
506 "segmask ", lfsp->lfs_segmask,
507 "segshift ", lfsp->lfs_segshift,
508 "bmask ", lfsp->lfs_bmask,
509 "bshift ", lfsp->lfs_bshift);
510
511 (void)printf("%s0x%qX\t\t%s%d\t%s0x%qX\t%s%d\n",
512 "ffmask ", lfsp->lfs_ffmask,
513 "ffshift ", lfsp->lfs_ffshift,
514 "fbmask ", lfsp->lfs_fbmask,
515 "fbshift ", lfsp->lfs_fbshift);
516
517 (void)printf("%s%d\t%s%d\t%s0x%X\t%s0x%qx\n",
518 "sushift ", lfsp->lfs_sushift,
519 "fsbtodb ", lfsp->lfs_fsbtodb,
520 "cksum ", lfsp->lfs_cksum,
521 "maxfilesize ", lfsp->lfs_maxfilesize);
522
523 (void)printf("Superblock disk addresses:\t");
524 for (i = 0; i < LFS_MAXNUMSB; i++) {
525 (void)printf(" 0x%X", lfsp->lfs_sboffs[i]);
526 if ( i == (LFS_MAXNUMSB >> 1))
527 (void)printf("\n\t\t\t\t");
528 }
529 (void)printf("\n");
530
531 (void)printf("Checkpoint Info\n");
532 (void)printf("%s%d\t%s0x%X\t%s%d\n",
533 "free ", lfsp->lfs_free,
534 "idaddr ", lfsp->lfs_idaddr,
535 "ifile ", lfsp->lfs_ifile);
536 (void)printf("%s%d\t%s%d\t%s%d\n",
537 "bfree ", lfsp->lfs_bfree,
538 "avail ", lfsp->lfs_avail,
539 "uinodes ", lfsp->lfs_uinodes);
540 (void)printf("%s%d\t%s0x%X\t%s0x%X\n%s0x%X\t%s0x%X\t",
541 "nfiles ", lfsp->lfs_nfiles,
542 "lastseg ", lfsp->lfs_lastseg,
543 "nextseg ", lfsp->lfs_nextseg,
544 "curseg ", lfsp->lfs_curseg,
545 "offset ", lfsp->lfs_offset);
546 (void)printf("tstamp %s", ctime((time_t *)&lfsp->lfs_tstamp));
547 (void)printf("\nIn-Memory Information\n");
548 (void)printf("%s%d\t%s0x%X\t%s%d%s%d\t%s%d\n",
549 "seglock ", lfsp->lfs_seglock,
550 "iocount ", lfsp->lfs_iocount,
551 "writer ", lfsp->lfs_writer,
552 "dirops ", lfsp->lfs_dirops,
553 "doifile ", lfsp->lfs_doifile);
554 (void)printf("%s%d\t%s%d\t%s0x%X\t%s%d\n",
555 "nactive ", lfsp->lfs_nactive,
556 "fmod ", lfsp->lfs_fmod,
557 "clean ", lfsp->lfs_clean,
558 "ronly ", lfsp->lfs_ronly);
559 }
560
561 static void
addseg(arg)562 addseg(arg)
563 char *arg;
564 {
565 SEGLIST *p;
566
567 if ((p = malloc(sizeof(SEGLIST))) == NULL)
568 err(1, NULL);
569 p->next = seglist;
570 p->num = atoi(arg);
571 seglist = p;
572 }
573
574 static void
dump_cleaner_info(lfsp,ipage)575 dump_cleaner_info(lfsp, ipage)
576 struct lfs *lfsp;
577 void *ipage;
578 {
579 CLEANERINFO *cip;
580
581 cip = (CLEANERINFO *)ipage;
582 (void)printf("segments clean\t%d\tsegments dirty\t%d\n\n",
583 cip->clean, cip->dirty);
584 }
585
586 static void
usage()587 usage()
588 {
589 (void)fprintf(stderr, "usage: dumplfs [-ai] [-s segnum] file\n");
590 exit(1);
591 }
592