sbin/ffsinfo/ffsinfo.c

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