1 /* 2 * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz 3 * Copyright (c) 1980, 1989, 1993 The Regents of the University of California. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgment: 19 * This product includes software developed by the University of 20 * California, Berkeley and its contributors, as well as Christoph 21 * Herrmann and Thomas-Henning von Kamptz. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * $TSHeader: src/sbin/ffsinfo/ffsinfo.c,v 1.4 2000/12/12 19:30:55 tomsoft Exp $ 39 * 40 */ 41 42 #ifndef lint 43 static const char copyright[] = 44 "@(#) Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz\n\ 45 Copyright (c) 1980, 1989, 1993 The Regents of the University of California.\n\ 46 All rights reserved.\n"; 47 #endif /* not lint */ 48 49 #ifndef lint 50 static const char rcsid[] = 51 "$FreeBSD$"; 52 #endif /* not lint */ 53 54 /* ********************************************************** INCLUDES ***** */ 55 #include <sys/param.h> 56 #include <sys/disklabel.h> 57 #include <sys/mount.h> 58 #include <sys/stat.h> 59 60 #include <ufs/ufs/ufsmount.h> 61 #include <ufs/ufs/dinode.h> 62 #include <ufs/ffs/fs.h> 63 64 #include <ctype.h> 65 #include <err.h> 66 #include <errno.h> 67 #include <fcntl.h> 68 #include <libufs.h> 69 #include <paths.h> 70 #include <stdint.h> 71 #include <stdio.h> 72 #include <stdlib.h> 73 #include <string.h> 74 #include <unistd.h> 75 76 #include "debug.h" 77 78 /* *********************************************************** GLOBALS ***** */ 79 #ifdef FS_DEBUG 80 int _dbg_lvl_ = (DL_INFO); /* DL_TRC */ 81 #endif /* FS_DEBUG */ 82 83 static struct uufsd disk; 84 85 #define sblock disk.d_fs 86 #define acg disk.d_cg 87 88 static union { 89 struct fs fs; 90 char pad[SBLOCKSIZE]; 91 } fsun; 92 93 #define osblock fsun.fs 94 95 static char i1blk[MAXBSIZE]; 96 static char i2blk[MAXBSIZE]; 97 static char i3blk[MAXBSIZE]; 98 99 static struct csum *fscs; 100 101 /* ******************************************************** PROTOTYPES ***** */ 102 static void usage(void); 103 static void dump_whole_ufs1_inode(ino_t, int); 104 static void dump_whole_ufs2_inode(ino_t, int); 105 106 #define DUMP_WHOLE_INODE(A,B) \ 107 ( disk.d_ufs == 1 \ 108 ? dump_whole_ufs1_inode((A),(B)) : dump_whole_ufs2_inode((A),(B)) ) 109 110 /* ************************************************************** main ***** */ 111 /* 112 * ffsinfo(8) is a tool to dump all metadata of a file system. It helps to find 113 * errors is the file system much easier. You can run ffsinfo before and after 114 * an fsck(8), and compare the two ascii dumps easy with diff, and you see 115 * directly where the problem is. You can control how much detail you want to 116 * see with some command line arguments. You can also easy check the status 117 * of a file system, like is there is enough space for growing a file system, 118 * or how many active snapshots do we have. It provides much more detailed 119 * information then dumpfs. Snapshots, as they are very new, are not really 120 * supported. They are just mentioned currently, but it is planned to run 121 * also over active snapshots, to even get that output. 122 */ 123 int 124 main(int argc, char **argv) 125 { 126 DBG_FUNC("main") 127 char *device, *special; 128 int ch; 129 size_t len; 130 struct stat st; 131 struct csum *dbg_csp; 132 int dbg_csc; 133 char dbg_line[80]; 134 int cylno,i; 135 int cfg_cg, cfg_in, cfg_lv; 136 int cg_start, cg_stop; 137 ino_t in; 138 char *out_file; 139 140 DBG_ENTER; 141 142 cfg_lv = 0xff; 143 cfg_in = -2; 144 cfg_cg = -2; 145 out_file = strdup("-"); 146 147 while ((ch = getopt(argc, argv, "g:i:l:o:")) != -1) { 148 switch (ch) { 149 case 'g': 150 cfg_cg = strtol(optarg, NULL, 0); 151 if (errno == EINVAL || errno == ERANGE) 152 err(1, "%s", optarg); 153 if (cfg_cg < -1) 154 usage(); 155 break; 156 case 'i': 157 cfg_in = strtol(optarg, NULL, 0); 158 if (errno == EINVAL || errno == ERANGE) 159 err(1, "%s", optarg); 160 if (cfg_in < 0) 161 usage(); 162 break; 163 case 'l': 164 cfg_lv = strtol(optarg, NULL, 0); 165 if (errno == EINVAL||errno == ERANGE) 166 err(1, "%s", optarg); 167 if (cfg_lv < 0x1 || cfg_lv > 0x3ff) 168 usage(); 169 break; 170 case 'o': 171 free(out_file); 172 out_file = strdup(optarg); 173 if (out_file == NULL) 174 errx(1, "strdup failed"); 175 break; 176 case '?': 177 /* FALLTHROUGH */ 178 default: 179 usage(); 180 } 181 } 182 argc -= optind; 183 argv += optind; 184 185 if (argc != 1) 186 usage(); 187 device = *argv; 188 189 /* 190 * Now we try to guess the (raw)device name. 191 */ 192 if (0 == strrchr(device, '/') && stat(device, &st) == -1) { 193 /*- 194 * No path prefix was given, so try in this order: 195 * /dev/r%s 196 * /dev/%s 197 * /dev/vinum/r%s 198 * /dev/vinum/%s. 199 * 200 * FreeBSD now doesn't distinguish between raw and block 201 * devices any longer, but it should still work this way. 202 */ 203 len = strlen(device) + strlen(_PATH_DEV) + 2 + strlen("vinum/"); 204 special = (char *)malloc(len); 205 if (special == NULL) 206 errx(1, "malloc failed"); 207 snprintf(special, len, "%sr%s", _PATH_DEV, device); 208 if (stat(special, &st) == -1) { 209 snprintf(special, len, "%s%s", _PATH_DEV, device); 210 if (stat(special, &st) == -1) { 211 snprintf(special, len, "%svinum/r%s", 212 _PATH_DEV, device); 213 if (stat(special, &st) == -1) 214 /* For now this is the 'last resort' */ 215 snprintf(special, len, "%svinum/%s", 216 _PATH_DEV, device); 217 } 218 } 219 device = special; 220 } 221 222 if (ufs_disk_fillout(&disk, device) == -1) 223 err(1, "ufs_disk_fillout(%s) failed: %s", device, disk.d_error); 224 225 DBG_OPEN(out_file); /* already here we need a superblock */ 226 227 if (cfg_lv & 0x001) 228 DBG_DUMP_FS(&sblock, "primary sblock"); 229 230 /* Determine here what cylinder groups to dump */ 231 if (cfg_cg==-2) { 232 cg_start = 0; 233 cg_stop = sblock.fs_ncg; 234 } else if (cfg_cg == -1) { 235 cg_start = sblock.fs_ncg - 1; 236 cg_stop = sblock.fs_ncg; 237 } else if (cfg_cg < sblock.fs_ncg) { 238 cg_start = cfg_cg; 239 cg_stop = cfg_cg + 1; 240 } else { 241 cg_start = sblock.fs_ncg; 242 cg_stop = sblock.fs_ncg; 243 } 244 245 if (cfg_lv & 0x004) { 246 fscs = (struct csum *)calloc((size_t)1, 247 (size_t)sblock.fs_cssize); 248 if (fscs == NULL) 249 errx(1, "calloc failed"); 250 251 /* get the cylinder summary into the memory ... */ 252 for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) { 253 if (bread(&disk, fsbtodb(&sblock, 254 sblock.fs_csaddr + numfrags(&sblock, i)), 255 (void *)(((char *)fscs)+i), 256 (size_t)(sblock.fs_cssize-i < sblock.fs_bsize ? 257 sblock.fs_cssize - i : sblock.fs_bsize)) == -1) 258 err(1, "bread: %s", disk.d_error); 259 } 260 261 dbg_csp = fscs; 262 /* ... and dump it */ 263 for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) { 264 snprintf(dbg_line, sizeof(dbg_line), 265 "%d. csum in fscs", dbg_csc); 266 DBG_DUMP_CSUM(&sblock, 267 dbg_line, 268 dbg_csp++); 269 } 270 } 271 272 if (cfg_lv & 0xf8) { 273 /* for each requested cylinder group ... */ 274 for (cylno = cg_start; cylno < cg_stop; cylno++) { 275 snprintf(dbg_line, sizeof(dbg_line), "cgr %d", cylno); 276 if (cfg_lv & 0x002) { 277 /* dump the superblock copies */ 278 if (bread(&disk, fsbtodb(&sblock, 279 cgsblock(&sblock, cylno)), 280 (void *)&osblock, SBLOCKSIZE) == -1) 281 err(1, "bread: %s", disk.d_error); 282 DBG_DUMP_FS(&osblock, dbg_line); 283 } 284 285 /* 286 * Read the cylinder group and dump whatever was 287 * requested. 288 */ 289 if (bread(&disk, fsbtodb(&sblock, 290 cgtod(&sblock, cylno)), (void *)&acg, 291 (size_t)sblock.fs_cgsize) == -1) 292 err(1, "bread: %s", disk.d_error); 293 294 if (cfg_lv & 0x008) 295 DBG_DUMP_CG(&sblock, dbg_line, &acg); 296 if (cfg_lv & 0x010) 297 DBG_DUMP_INMAP(&sblock, dbg_line, &acg); 298 if (cfg_lv & 0x020) 299 DBG_DUMP_FRMAP(&sblock, dbg_line, &acg); 300 if (cfg_lv & 0x040) { 301 DBG_DUMP_CLMAP(&sblock, dbg_line, &acg); 302 DBG_DUMP_CLSUM(&sblock, dbg_line, &acg); 303 } 304 #ifdef NOT_CURRENTLY 305 /* 306 * See the comment in sbin/growfs/debug.c for why this 307 * is currently disabled, and what needs to be done to 308 * re-enable it. 309 */ 310 if (disk.d_ufs == 1 && cfg_lv & 0x080) 311 DBG_DUMP_SPTBL(&sblock, dbg_line, &acg); 312 #endif 313 } 314 } 315 316 if (cfg_lv & 0x300) { 317 /* Dump the requested inode(s) */ 318 if (cfg_in != -2) 319 DUMP_WHOLE_INODE((ino_t)cfg_in, cfg_lv); 320 else { 321 for (in = cg_start * sblock.fs_ipg; 322 in < (ino_t)cg_stop * sblock.fs_ipg; 323 in++) 324 DUMP_WHOLE_INODE(in, cfg_lv); 325 } 326 } 327 328 DBG_CLOSE; 329 DBG_LEAVE; 330 331 return 0; 332 } 333 334 /* ********************************************** dump_whole_ufs1_inode ***** */ 335 /* 336 * Here we dump a list of all blocks allocated by this inode. We follow 337 * all indirect blocks. 338 */ 339 void 340 dump_whole_ufs1_inode(ino_t inode, int level) 341 { 342 DBG_FUNC("dump_whole_ufs1_inode") 343 struct ufs1_dinode *ino; 344 int rb, mode; 345 unsigned int ind2ctr, ind3ctr; 346 ufs1_daddr_t *ind2ptr, *ind3ptr; 347 char comment[80]; 348 349 DBG_ENTER; 350 351 /* 352 * Read the inode from disk/cache. 353 */ 354 if (getino(&disk, (void **)&ino, inode, &mode) == -1) 355 err(1, "getino: %s", disk.d_error); 356 357 if(ino->di_nlink==0) { 358 DBG_LEAVE; 359 return; /* inode not in use */ 360 } 361 362 /* 363 * Dump the main inode structure. 364 */ 365 snprintf(comment, sizeof(comment), "Inode 0x%08jx", (uintmax_t)inode); 366 if (level & 0x100) { 367 DBG_DUMP_INO(&sblock, 368 comment, 369 ino); 370 } 371 372 if (!(level & 0x200)) { 373 DBG_LEAVE; 374 return; 375 } 376 377 /* 378 * Ok, now prepare for dumping all direct and indirect pointers. 379 */ 380 rb=howmany(ino->di_size, sblock.fs_bsize)-NDADDR; 381 if(rb>0) { 382 /* 383 * Dump single indirect block. 384 */ 385 if (bread(&disk, fsbtodb(&sblock, ino->di_ib[0]), (void *)&i1blk, 386 (size_t)sblock.fs_bsize) == -1) { 387 err(1, "bread: %s", disk.d_error); 388 } 389 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 0", 390 (uintmax_t)inode); 391 DBG_DUMP_IBLK(&sblock, 392 comment, 393 i1blk, 394 (size_t)rb); 395 rb-=howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t)); 396 } 397 if(rb>0) { 398 /* 399 * Dump double indirect blocks. 400 */ 401 if (bread(&disk, fsbtodb(&sblock, ino->di_ib[1]), (void *)&i2blk, 402 (size_t)sblock.fs_bsize) == -1) { 403 err(1, "bread: %s", disk.d_error); 404 } 405 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 1", 406 (uintmax_t)inode); 407 DBG_DUMP_IBLK(&sblock, 408 comment, 409 i2blk, 410 howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t)))); 411 for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize, 412 sizeof(ufs1_daddr_t))) && (rb>0)); ind2ctr++) { 413 ind2ptr=&((ufs1_daddr_t *)(void *)&i2blk)[ind2ctr]; 414 415 if (bread(&disk, fsbtodb(&sblock, *ind2ptr), (void *)&i1blk, 416 (size_t)sblock.fs_bsize) == -1) { 417 err(1, "bread: %s", disk.d_error); 418 } 419 snprintf(comment, sizeof(comment), 420 "Inode 0x%08jx: indirect 1->%d", (uintmax_t)inode, 421 ind2ctr); 422 DBG_DUMP_IBLK(&sblock, 423 comment, 424 i1blk, 425 (size_t)rb); 426 rb-=howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t)); 427 } 428 } 429 if(rb>0) { 430 /* 431 * Dump triple indirect blocks. 432 */ 433 if (bread(&disk, fsbtodb(&sblock, ino->di_ib[2]), (void *)&i3blk, 434 (size_t)sblock.fs_bsize) == -1) { 435 err(1, "bread: %s", disk.d_error); 436 } 437 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 2", 438 (uintmax_t)inode); 439 #define SQUARE(a) ((a)*(a)) 440 DBG_DUMP_IBLK(&sblock, 441 comment, 442 i3blk, 443 howmany(rb, 444 SQUARE(howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t))))); 445 #undef SQUARE 446 for(ind3ctr=0; ((ind3ctr<howmany(sblock.fs_bsize, 447 sizeof(ufs1_daddr_t)))&&(rb>0)); ind3ctr++) { 448 ind3ptr=&((ufs1_daddr_t *)(void *)&i3blk)[ind3ctr]; 449 450 if (bread(&disk, fsbtodb(&sblock, *ind3ptr), (void *)&i2blk, 451 (size_t)sblock.fs_bsize) == -1) { 452 err(1, "bread: %s", disk.d_error); 453 } 454 snprintf(comment, sizeof(comment), 455 "Inode 0x%08jx: indirect 2->%d", (uintmax_t)inode, 456 ind3ctr); 457 DBG_DUMP_IBLK(&sblock, 458 comment, 459 i2blk, 460 howmany(rb, 461 howmany(sblock.fs_bsize, sizeof(ufs1_daddr_t)))); 462 for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize, 463 sizeof(ufs1_daddr_t)))&&(rb>0)); ind2ctr++) { 464 ind2ptr=&((ufs1_daddr_t *)(void *)&i2blk) 465 [ind2ctr]; 466 if (bread(&disk, fsbtodb(&sblock, *ind2ptr), 467 (void *)&i1blk, (size_t)sblock.fs_bsize) 468 == -1) { 469 err(1, "bread: %s", disk.d_error); 470 } 471 snprintf(comment, sizeof(comment), 472 "Inode 0x%08jx: indirect 2->%d->%d", 473 (uintmax_t)inode, ind3ctr, ind3ctr); 474 DBG_DUMP_IBLK(&sblock, 475 comment, 476 i1blk, 477 (size_t)rb); 478 rb-=howmany(sblock.fs_bsize, 479 sizeof(ufs1_daddr_t)); 480 } 481 } 482 } 483 484 DBG_LEAVE; 485 return; 486 } 487 488 /* ********************************************** dump_whole_ufs2_inode ***** */ 489 /* 490 * Here we dump a list of all blocks allocated by this inode. We follow 491 * all indirect blocks. 492 */ 493 void 494 dump_whole_ufs2_inode(ino_t inode, int level) 495 { 496 DBG_FUNC("dump_whole_ufs2_inode") 497 struct ufs2_dinode *ino; 498 int rb, mode; 499 unsigned int ind2ctr, ind3ctr; 500 ufs2_daddr_t *ind2ptr, *ind3ptr; 501 char comment[80]; 502 503 DBG_ENTER; 504 505 /* 506 * Read the inode from disk/cache. 507 */ 508 if (getino(&disk, (void **)&ino, inode, &mode) == -1) 509 err(1, "getino: %s", disk.d_error); 510 511 if (ino->di_nlink == 0) { 512 DBG_LEAVE; 513 return; /* inode not in use */ 514 } 515 516 /* 517 * Dump the main inode structure. 518 */ 519 snprintf(comment, sizeof(comment), "Inode 0x%08jx", (uintmax_t)inode); 520 if (level & 0x100) { 521 DBG_DUMP_INO(&sblock, comment, ino); 522 } 523 524 if (!(level & 0x200)) { 525 DBG_LEAVE; 526 return; 527 } 528 529 /* 530 * Ok, now prepare for dumping all direct and indirect pointers. 531 */ 532 rb = howmany(ino->di_size, sblock.fs_bsize) - NDADDR; 533 if (rb > 0) { 534 /* 535 * Dump single indirect block. 536 */ 537 if (bread(&disk, fsbtodb(&sblock, ino->di_ib[0]), (void *)&i1blk, 538 (size_t)sblock.fs_bsize) == -1) { 539 err(1, "bread: %s", disk.d_error); 540 } 541 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 0", 542 (uintmax_t)inode); 543 DBG_DUMP_IBLK(&sblock, comment, i1blk, (size_t)rb); 544 rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)); 545 } 546 if (rb > 0) { 547 /* 548 * Dump double indirect blocks. 549 */ 550 if (bread(&disk, fsbtodb(&sblock, ino->di_ib[1]), (void *)&i2blk, 551 (size_t)sblock.fs_bsize) == -1) { 552 err(1, "bread: %s", disk.d_error); 553 } 554 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 1", 555 (uintmax_t)inode); 556 DBG_DUMP_IBLK(&sblock, 557 comment, 558 i2blk, 559 howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)))); 560 for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize, 561 sizeof(ufs2_daddr_t))) && (rb>0)); ind2ctr++) { 562 ind2ptr = &((ufs2_daddr_t *)(void *)&i2blk)[ind2ctr]; 563 564 if (bread(&disk, fsbtodb(&sblock, *ind2ptr), (void *)&i1blk, 565 (size_t)sblock.fs_bsize) == -1) { 566 err(1, "bread: %s", disk.d_error); 567 } 568 snprintf(comment, sizeof(comment), 569 "Inode 0x%08jx: indirect 1->%d", 570 (uintmax_t)inode, ind2ctr); 571 DBG_DUMP_IBLK(&sblock, comment, i1blk, (size_t)rb); 572 rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)); 573 } 574 } 575 if (rb > 0) { 576 /* 577 * Dump triple indirect blocks. 578 */ 579 if (bread(&disk, fsbtodb(&sblock, ino->di_ib[2]), (void *)&i3blk, 580 (size_t)sblock.fs_bsize) == -1) { 581 err(1, "bread: %s", disk.d_error); 582 } 583 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 2", 584 (uintmax_t)inode); 585 #define SQUARE(a) ((a)*(a)) 586 DBG_DUMP_IBLK(&sblock, 587 comment, 588 i3blk, 589 howmany(rb, 590 SQUARE(howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t))))); 591 #undef SQUARE 592 for (ind3ctr = 0; ((ind3ctr < howmany(sblock.fs_bsize, 593 sizeof(ufs2_daddr_t))) && (rb > 0)); ind3ctr++) { 594 ind3ptr = &((ufs2_daddr_t *)(void *)&i3blk)[ind3ctr]; 595 596 if (bread(&disk, fsbtodb(&sblock, *ind3ptr), (void *)&i2blk, 597 (size_t)sblock.fs_bsize) == -1) { 598 err(1, "bread: %s", disk.d_error); 599 } 600 snprintf(comment, sizeof(comment), 601 "Inode 0x%08jx: indirect 2->%d", 602 (uintmax_t)inode, ind3ctr); 603 DBG_DUMP_IBLK(&sblock, 604 comment, 605 i2blk, 606 howmany(rb, 607 howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)))); 608 for (ind2ctr = 0; ((ind2ctr < howmany(sblock.fs_bsize, 609 sizeof(ufs2_daddr_t))) && (rb > 0)); ind2ctr++) { 610 ind2ptr = &((ufs2_daddr_t *)(void *)&i2blk) [ind2ctr]; 611 if (bread(&disk, fsbtodb(&sblock, *ind2ptr), (void *)&i1blk, 612 (size_t)sblock.fs_bsize) == -1) { 613 err(1, "bread: %s", disk.d_error); 614 } 615 snprintf(comment, sizeof(comment), 616 "Inode 0x%08jx: indirect 2->%d->%d", 617 (uintmax_t)inode, ind3ctr, ind3ctr); 618 DBG_DUMP_IBLK(&sblock, comment, i1blk, (size_t)rb); 619 rb -= howmany(sblock.fs_bsize, sizeof(ufs2_daddr_t)); 620 } 621 } 622 } 623 624 DBG_LEAVE; 625 return; 626 } 627 628 /* ************************************************************* usage ***** */ 629 /* 630 * Dump a line of usage. 631 */ 632 void 633 usage(void) 634 { 635 DBG_FUNC("usage") 636 637 DBG_ENTER; 638 639 fprintf(stderr, 640 "usage: ffsinfo [-g cylinder_group] [-i inode] [-l level] " 641 "[-o outfile]\n" 642 " special | file\n"); 643 644 DBG_LEAVE; 645 exit(1); 646 } 647