sbin/growfs/debug.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/growfs/debug.c,v 1.3 2000/12/12 19:31:00 tomsoft Exp $
  41  *
  42  */
  43
  44 #include <sys/param.h>
  45
  46 #include <limits.h>
  47 #include <stdio.h>
  48 #include <string.h>
  49 #include <ufs/ufs/dinode.h>
  50 #include <ufs/ffs/fs.h>
  51
  52 #include "debug.h"
  53
  54 #ifdef FS_DEBUG
  55
  56 static FILE             *dbg_log = NULL;
  57 static unsigned int     indent = 0;
  58
  59 /*
  60  * prototypes are not done here, as they come with debug.h
  61  */
  62
  63 /*
  64  * Open the filehandle where all debug output has to go.
  65  */
  66 void
  67 dbg_open(const char *fn)
  68 {
  69
  70         if (strcmp(fn, "-") == 0)
  71                 dbg_log = fopen("/dev/stdout", "a");
  72         else
  73                 dbg_log = fopen(fn, "a");
  74
  75         return;
  76 }
  77
  78 /*
  79  * Close the filehandle where all debug output went to.
  80  */
  81 void
  82 dbg_close(void)
  83 {
  84
  85         if (dbg_log) {
  86                 fclose(dbg_log);
  87                 dbg_log = NULL;
  88         }
  89
  90         return;
  91 }
  92
  93 /*
  94  * Dump out a full file system block in hex.
  95  */
  96 void
  97 dbg_dump_hex(struct fs *sb, const char *comment, unsigned char *mem)
  98 {
  99         int i, j, k;
 100
 101         if (!dbg_log)
 102                 return;
 103
 104         fprintf(dbg_log, "===== START HEXDUMP =====\n");
 105         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)mem, comment);
 106         indent++;
 107         for (i = 0; i < sb->fs_bsize; i += 24) {
 108                 for (j = 0; j < 3; j++) {
 109                         for (k = 0; k < 8; k++)
 110                                 fprintf(dbg_log, "%02x ", *mem++);
 111                         fprintf(dbg_log, "  ");
 112                 }
 113                 fprintf(dbg_log, "\n");
 114         }
 115         indent--;
 116         fprintf(dbg_log, "===== END HEXDUMP =====\n");
 117
 118         return;
 119 }
 120
 121 /*
 122  * Dump the superblock.
 123  */
 124 void
 125 dbg_dump_fs(struct fs *sb, const char *comment)
 126 {
 127         int j;
 128
 129         if (!dbg_log)
 130                 return;
 131
 132         fprintf(dbg_log, "===== START SUPERBLOCK =====\n");
 133         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)sb, comment);
 134         indent++;
 135
 136         fprintf(dbg_log, "sblkno            int32_t          0x%08x\n",
 137             sb->fs_sblkno);
 138         fprintf(dbg_log, "cblkno            int32_t          0x%08x\n",
 139             sb->fs_cblkno);
 140         fprintf(dbg_log, "iblkno            int32_t          0x%08x\n",
 141             sb->fs_iblkno);
 142         fprintf(dbg_log, "dblkno            int32_t          0x%08x\n",
 143             sb->fs_dblkno);
 144
 145         fprintf(dbg_log, "old_cgoffset      int32_t          0x%08x\n",
 146             sb->fs_old_cgoffset);
 147         fprintf(dbg_log, "old_cgmask        int32_t          0x%08x\n",
 148             sb->fs_old_cgmask);
 149         fprintf(dbg_log, "old_time          int32_t          %10u\n",
 150             (unsigned int)sb->fs_old_time);
 151         fprintf(dbg_log, "old_size          int32_t          0x%08x\n",
 152             sb->fs_old_size);
 153         fprintf(dbg_log, "old_dsize         int32_t          0x%08x\n",
 154             sb->fs_old_dsize);
 155         fprintf(dbg_log, "ncg               int32_t          0x%08x\n",
 156             sb->fs_ncg);
 157         fprintf(dbg_log, "bsize             int32_t          0x%08x\n",
 158             sb->fs_bsize);
 159         fprintf(dbg_log, "fsize             int32_t          0x%08x\n",
 160             sb->fs_fsize);
 161         fprintf(dbg_log, "frag              int32_t          0x%08x\n",
 162             sb->fs_frag);
 163
 164         fprintf(dbg_log, "minfree           int32_t          0x%08x\n",
 165             sb->fs_minfree);
 166         fprintf(dbg_log, "old_rotdelay      int32_t          0x%08x\n",
 167             sb->fs_old_rotdelay);
 168         fprintf(dbg_log, "old_rps           int32_t          0x%08x\n",
 169             sb->fs_old_rps);
 170
 171         fprintf(dbg_log, "bmask             int32_t          0x%08x\n",
 172             sb->fs_bmask);
 173         fprintf(dbg_log, "fmask             int32_t          0x%08x\n",
 174             sb->fs_fmask);
 175         fprintf(dbg_log, "bshift            int32_t          0x%08x\n",
 176             sb->fs_bshift);
 177         fprintf(dbg_log, "fshift            int32_t          0x%08x\n",
 178             sb->fs_fshift);
 179
 180         fprintf(dbg_log, "maxcontig         int32_t          0x%08x\n",
 181             sb->fs_maxcontig);
 182         fprintf(dbg_log, "maxbpg            int32_t          0x%08x\n",
 183             sb->fs_maxbpg);
 184
 185         fprintf(dbg_log, "fragshift         int32_t          0x%08x\n",
 186             sb->fs_fragshift);
 187         fprintf(dbg_log, "fsbtodb           int32_t          0x%08x\n",
 188             sb->fs_fsbtodb);
 189         fprintf(dbg_log, "sbsize            int32_t          0x%08x\n",
 190             sb->fs_sbsize);
 191         fprintf(dbg_log, "spare1            int32_t[2]       0x%08x 0x%08x\n",
 192             sb->fs_spare1[0], sb->fs_spare1[1]);
 193         fprintf(dbg_log, "nindir            int32_t          0x%08x\n",
 194             sb->fs_nindir);
 195         fprintf(dbg_log, "inopb             int32_t          0x%08x\n",
 196             sb->fs_inopb);
 197         fprintf(dbg_log, "old_nspf          int32_t          0x%08x\n",
 198             sb->fs_old_nspf);
 199
 200         fprintf(dbg_log, "optim             int32_t          0x%08x\n",
 201             sb->fs_optim);
 202
 203         fprintf(dbg_log, "old_npsect        int32_t          0x%08x\n",
 204             sb->fs_old_npsect);
 205         fprintf(dbg_log, "old_interleave    int32_t          0x%08x\n",
 206             sb->fs_old_interleave);
 207         fprintf(dbg_log, "old_trackskew     int32_t          0x%08x\n",
 208             sb->fs_old_trackskew);
 209
 210         fprintf(dbg_log, "id                int32_t[2]       0x%08x 0x%08x\n",
 211             sb->fs_id[0], sb->fs_id[1]);
 212
 213         fprintf(dbg_log, "old_csaddr        int32_t          0x%08x\n",
 214             sb->fs_old_csaddr);
 215         fprintf(dbg_log, "cssize            int32_t          0x%08x\n",
 216             sb->fs_cssize);
 217         fprintf(dbg_log, "cgsize            int32_t          0x%08x\n",
 218             sb->fs_cgsize);
 219
 220         fprintf(dbg_log, "spare2            int32_t          0x%08x\n",
 221             sb->fs_spare2);
 222         fprintf(dbg_log, "old_nsect         int32_t          0x%08x\n",
 223             sb->fs_old_nsect);
 224         fprintf(dbg_log, "old_spc           int32_t          0x%08x\n",
 225             sb->fs_old_spc);
 226
 227         fprintf(dbg_log, "old_ncyl          int32_t          0x%08x\n",
 228             sb->fs_old_ncyl);
 229
 230         fprintf(dbg_log, "old_cpg           int32_t          0x%08x\n",
 231             sb->fs_old_cpg);
 232         fprintf(dbg_log, "ipg               int32_t          0x%08x\n",
 233             sb->fs_ipg);
 234         fprintf(dbg_log, "fpg               int32_t          0x%08x\n",
 235             sb->fs_fpg);
 236
 237         dbg_dump_csum("internal old_cstotal", &sb->fs_old_cstotal);
 238
 239         fprintf(dbg_log, "fmod              int8_t           0x%02x\n",
 240             sb->fs_fmod);
 241         fprintf(dbg_log, "clean             int8_t           0x%02x\n",
 242             sb->fs_clean);
 243         fprintf(dbg_log, "ronly             int8_t           0x%02x\n",
 244             sb->fs_ronly);
 245         fprintf(dbg_log, "old_flags         int8_t           0x%02x\n",
 246             sb->fs_old_flags);
 247         fprintf(dbg_log, "fsmnt             u_char[MAXMNTLEN] \"%s\"\n",
 248             sb->fs_fsmnt);
 249         fprintf(dbg_log, "volname           u_char[MAXVOLLEN] \"%s\"\n",
 250             sb->fs_volname);
 251         fprintf(dbg_log, "swuid             u_int64_t        0x%08x%08x\n",
 252             ((unsigned int *)&(sb->fs_swuid))[1],
 253                 ((unsigned int *)&(sb->fs_swuid))[0]);
 254
 255         fprintf(dbg_log, "pad               int32_t          0x%08x\n",
 256             sb->fs_pad);
 257
 258         fprintf(dbg_log, "cgrotor           int32_t          0x%08x\n",
 259             sb->fs_cgrotor);
 260 /*
 261  * struct csum[MAXCSBUFS] - is only maintained in memory
 262  */
 263 /*      fprintf(dbg_log, " int32_t\n", sb->*fs_maxcluster);*/
 264         fprintf(dbg_log, "old_cpc           int32_t          0x%08x\n",
 265             sb->fs_old_cpc);
 266 /*
 267  * int16_t fs_opostbl[16][8] - is dumped when used in dbg_dump_sptbl
 268  */
 269         fprintf(dbg_log, "maxbsize          int32_t          0x%08x\n",
 270             sb->fs_maxbsize);
 271         fprintf(dbg_log, "unrefs            int64_t          0x%08jx\n",
 272             sb->fs_unrefs);
 273         fprintf(dbg_log, "sblockloc         int64_t          0x%08x%08x\n",
 274                 ((unsigned int *)&(sb->fs_sblockloc))[1],
 275                 ((unsigned int *)&(sb->fs_sblockloc))[0]);
 276
 277         dbg_dump_csum_total("internal cstotal", &sb->fs_cstotal);
 278
 279         fprintf(dbg_log, "time              ufs_time_t       %10u\n",
 280             (unsigned int)sb->fs_time);
 281
 282         fprintf(dbg_log, "size              int64_t          0x%08x%08x\n",
 283                 ((unsigned int *)&(sb->fs_size))[1],
 284                 ((unsigned int *)&(sb->fs_size))[0]);
 285         fprintf(dbg_log, "dsize             int64_t          0x%08x%08x\n",
 286                 ((unsigned int *)&(sb->fs_dsize))[1],
 287                 ((unsigned int *)&(sb->fs_dsize))[0]);
 288         fprintf(dbg_log, "csaddr            ufs2_daddr_t     0x%08x%08x\n",
 289                 ((unsigned int *)&(sb->fs_csaddr))[1],
 290                 ((unsigned int *)&(sb->fs_csaddr))[0]);
 291         fprintf(dbg_log, "pendingblocks     int64_t          0x%08x%08x\n",
 292                 ((unsigned int *)&(sb->fs_pendingblocks))[1],
 293                 ((unsigned int *)&(sb->fs_pendingblocks))[0]);
 294         fprintf(dbg_log, "pendinginodes     int32_t          0x%08x\n",
 295             sb->fs_pendinginodes);
 296
 297         for (j = 0; j < FSMAXSNAP; j++) {
 298                 fprintf(dbg_log, "snapinum          int32_t[%2d]      0x%08x\n",
 299                     j, sb->fs_snapinum[j]);
 300                 if (!sb->fs_snapinum[j]) { /* list is dense */
 301                         break;
 302                 }
 303         }
 304         fprintf(dbg_log, "avgfilesize       int32_t          0x%08x\n",
 305             sb->fs_avgfilesize);
 306         fprintf(dbg_log, "avgfpdir          int32_t          0x%08x\n",
 307             sb->fs_avgfpdir);
 308         fprintf(dbg_log, "save_cgsize       int32_t          0x%08x\n",
 309             sb->fs_save_cgsize);
 310         fprintf(dbg_log, "flags             int32_t          0x%08x\n",
 311             sb->fs_flags);
 312         fprintf(dbg_log, "contigsumsize     int32_t          0x%08x\n",
 313             sb->fs_contigsumsize);
 314         fprintf(dbg_log, "maxsymlinklen     int32_t          0x%08x\n",
 315             sb->fs_maxsymlinklen);
 316         fprintf(dbg_log, "old_inodefmt      int32_t          0x%08x\n",
 317             sb->fs_old_inodefmt);
 318         fprintf(dbg_log, "maxfilesize       u_int64_t        0x%08x%08x\n",
 319             ((unsigned int *)&(sb->fs_maxfilesize))[1],
 320             ((unsigned int *)&(sb->fs_maxfilesize))[0]);
 321         fprintf(dbg_log, "qbmask            int64_t          0x%08x%08x\n",
 322             ((unsigned int *)&(sb->fs_qbmask))[1],
 323             ((unsigned int *)&(sb->fs_qbmask))[0]);
 324         fprintf(dbg_log, "qfmask            int64_t          0x%08x%08x\n",
 325             ((unsigned int *)&(sb->fs_qfmask))[1],
 326             ((unsigned int *)&(sb->fs_qfmask))[0]);
 327         fprintf(dbg_log, "state             int32_t          0x%08x\n",
 328             sb->fs_state);
 329         fprintf(dbg_log, "old_postblformat  int32_t          0x%08x\n",
 330             sb->fs_old_postblformat);
 331         fprintf(dbg_log, "old_nrpos         int32_t          0x%08x\n",
 332             sb->fs_old_nrpos);
 333         fprintf(dbg_log, "spare5            int32_t[2]       0x%08x 0x%08x\n",
 334             sb->fs_spare5[0], sb->fs_spare5[1]);
 335         fprintf(dbg_log, "magic             int32_t          0x%08x\n",
 336             sb->fs_magic);
 337
 338         indent--;
 339         fprintf(dbg_log, "===== END SUPERBLOCK =====\n");
 340
 341         return;
 342 }
 343
 344 /*
 345  * Dump a cylinder group.
 346  */
 347 void
 348 dbg_dump_cg(const char *comment, struct cg *cgr)
 349 {
 350         int j;
 351
 352         if (!dbg_log)
 353                 return;
 354
 355         fprintf(dbg_log, "===== START CYLINDER GROUP =====\n");
 356         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 357         indent++;
 358
 359         fprintf(dbg_log, "magic         int32_t    0x%08x\n", cgr->cg_magic);
 360         fprintf(dbg_log, "old_time      int32_t    0x%08x\n", cgr->cg_old_time);
 361         fprintf(dbg_log, "cgx           int32_t    0x%08x\n", cgr->cg_cgx);
 362         fprintf(dbg_log, "old_ncyl      int16_t    0x%04x\n", cgr->cg_old_ncyl);
 363         fprintf(dbg_log, "old_niblk     int16_t    0x%04x\n", cgr->cg_old_niblk);
 364         fprintf(dbg_log, "ndblk         int32_t    0x%08x\n", cgr->cg_ndblk);
 365         dbg_dump_csum("internal cs", &cgr->cg_cs);
 366         fprintf(dbg_log, "rotor         int32_t    0x%08x\n", cgr->cg_rotor);
 367         fprintf(dbg_log, "frotor        int32_t    0x%08x\n", cgr->cg_frotor);
 368         fprintf(dbg_log, "irotor        int32_t    0x%08x\n", cgr->cg_irotor);
 369         for (j = 0; j < MAXFRAG; j++) {
 370                 fprintf(dbg_log, "frsum         int32_t[%d] 0x%08x\n", j,
 371                     cgr->cg_frsum[j]);
 372         }
 373         fprintf(dbg_log, "old_btotoff   int32_t    0x%08x\n", cgr->cg_old_btotoff);
 374         fprintf(dbg_log, "old_boff      int32_t    0x%08x\n", cgr->cg_old_boff);
 375         fprintf(dbg_log, "iusedoff      int32_t    0x%08x\n", cgr->cg_iusedoff);
 376         fprintf(dbg_log, "freeoff       int32_t    0x%08x\n", cgr->cg_freeoff);
 377         fprintf(dbg_log, "nextfreeoff   int32_t    0x%08x\n",
 378             cgr->cg_nextfreeoff);
 379         fprintf(dbg_log, "clustersumoff int32_t    0x%08x\n",
 380             cgr->cg_clustersumoff);
 381         fprintf(dbg_log, "clusteroff    int32_t    0x%08x\n",
 382             cgr->cg_clusteroff);
 383         fprintf(dbg_log, "nclusterblks  int32_t    0x%08x\n",
 384             cgr->cg_nclusterblks);
 385         fprintf(dbg_log, "niblk         int32_t    0x%08x\n", cgr->cg_niblk);
 386         fprintf(dbg_log, "initediblk    int32_t    0x%08x\n", cgr->cg_initediblk);
 387         fprintf(dbg_log, "unrefs        int32_t    0x%08x\n", cgr->cg_unrefs);
 388         fprintf(dbg_log, "time          ufs_time_t %10u\n",
 389                 (unsigned int)cgr->cg_initediblk);
 390
 391         indent--;
 392         fprintf(dbg_log, "===== END CYLINDER GROUP =====\n");
 393
 394         return;
 395 }
 396
 397 /*
 398  * Dump a cylinder summary.
 399  */
 400 void
 401 dbg_dump_csum(const char *comment, struct csum *cs)
 402 {
 403
 404         if (!dbg_log)
 405                 return;
 406
 407         fprintf(dbg_log, "===== START CYLINDER SUMMARY =====\n");
 408         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
 409         indent++;
 410
 411         fprintf(dbg_log, "ndir   int32_t 0x%08x\n", cs->cs_ndir);
 412         fprintf(dbg_log, "nbfree int32_t 0x%08x\n", cs->cs_nbfree);
 413         fprintf(dbg_log, "nifree int32_t 0x%08x\n", cs->cs_nifree);
 414         fprintf(dbg_log, "nffree int32_t 0x%08x\n", cs->cs_nffree);
 415
 416         indent--;
 417         fprintf(dbg_log, "===== END CYLINDER SUMMARY =====\n");
 418
 419         return;
 420 }
 421
 422 /*
 423  * Dump a cylinder summary.
 424  */
 425 void
 426 dbg_dump_csum_total(const char *comment, struct csum_total *cs)
 427 {
 428
 429         if (!dbg_log)
 430                 return;
 431
 432         fprintf(dbg_log, "===== START CYLINDER SUMMARY TOTAL =====\n");
 433         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
 434         indent++;
 435
 436         fprintf(dbg_log, "ndir        int64_t 0x%08x%08x\n",
 437                 ((unsigned int *)&(cs->cs_ndir))[1],
 438                 ((unsigned int *)&(cs->cs_ndir))[0]);
 439         fprintf(dbg_log, "nbfree      int64_t 0x%08x%08x\n",
 440                 ((unsigned int *)&(cs->cs_nbfree))[1],
 441                 ((unsigned int *)&(cs->cs_nbfree))[0]);
 442         fprintf(dbg_log, "nifree      int64_t 0x%08x%08x\n",
 443                 ((unsigned int *)&(cs->cs_nifree))[1],
 444                 ((unsigned int *)&(cs->cs_nifree))[0]);
 445         fprintf(dbg_log, "nffree      int64_t 0x%08x%08x\n",
 446                 ((unsigned int *)&(cs->cs_nffree))[1],
 447                 ((unsigned int *)&(cs->cs_nffree))[0]);
 448         fprintf(dbg_log, "numclusters int64_t 0x%08x%08x\n",
 449                 ((unsigned int *)&(cs->cs_numclusters))[1],
 450                 ((unsigned int *)&(cs->cs_numclusters))[0]);
 451
 452         indent--;
 453         fprintf(dbg_log, "===== END CYLINDER SUMMARY TOTAL =====\n");
 454
 455         return;
 456 }
 457 /*
 458  * Dump the inode allocation map in one cylinder group.
 459  */
 460 void
 461 dbg_dump_inmap(struct fs *sb, const char *comment, struct cg *cgr)
 462 {
 463         int j,k,l,e;
 464         unsigned char *cp;
 465
 466         if (!dbg_log)
 467                 return;
 468
 469         fprintf(dbg_log, "===== START INODE ALLOCATION MAP =====\n");
 470         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 471         indent++;
 472
 473         cp = (unsigned char *)cg_inosused(cgr);
 474         e = sb->fs_ipg / 8;
 475         for (j = 0; j < e; j += 32) {
 476                 fprintf(dbg_log, "%08x: ", j);
 477                 for (k = 0; k < 32; k += 8) {
 478                         if (j + k + 8 < e) {
 479                                 fprintf(dbg_log,
 480                                     "%02x%02x%02x%02x%02x%02x%02x%02x ",
 481                                     cp[0], cp[1], cp[2], cp[3],
 482                                     cp[4], cp[5], cp[6], cp[7]);
 483                         } else {
 484                                 for (l = 0; (l < 8) && (j + k + l < e); l++) {
 485                                         fprintf(dbg_log, "%02x", cp[l]);
 486                                 }
 487                         }
 488                         cp += 8;
 489                 }
 490                 fprintf(dbg_log, "\n");
 491         }
 492
 493         indent--;
 494         fprintf(dbg_log, "===== END INODE ALLOCATION MAP =====\n");
 495
 496         return;
 497 }
 498
 499
 500 /*
 501  * Dump the fragment allocation map in one cylinder group.
 502  */
 503 void
 504 dbg_dump_frmap(struct fs *sb, const char *comment, struct cg *cgr)
 505 {
 506         int j,k,l,e;
 507         unsigned char *cp;
 508
 509         if (!dbg_log)
 510                 return;
 511
 512         fprintf(dbg_log, "===== START FRAGMENT ALLOCATION MAP =====\n");
 513         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 514         indent++;
 515
 516         cp = (unsigned char *)cg_blksfree(cgr);
 517         if (sb->fs_old_nspf)
 518                 e = howmany(sb->fs_old_cpg * sb->fs_old_spc / sb->fs_old_nspf,
 519                     CHAR_BIT);
 520         else
 521                 e = 0;
 522         for (j = 0; j < e; j += 32) {
 523                 fprintf(dbg_log, "%08x: ", j);
 524                 for (k = 0; k < 32; k += 8) {
 525                         if (j + k + 8 <e) {
 526                                 fprintf(dbg_log,
 527                                     "%02x%02x%02x%02x%02x%02x%02x%02x ",
 528                                     cp[0], cp[1], cp[2], cp[3],
 529                                     cp[4], cp[5], cp[6], cp[7]);
 530                         } else {
 531                                 for (l = 0; (l < 8) && (j + k + l < e); l++) {
 532                                         fprintf(dbg_log, "%02x", cp[l]);
 533                                 }
 534                         }
 535                         cp += 8;
 536                 }
 537                 fprintf(dbg_log, "\n");
 538         }
 539
 540         indent--;
 541         fprintf(dbg_log, "===== END FRAGMENT ALLOCATION MAP =====\n");
 542
 543         return;
 544 }
 545
 546 /*
 547  * Dump the cluster allocation map in one cylinder group.
 548  */
 549 void
 550 dbg_dump_clmap(struct fs *sb, const char *comment, struct cg *cgr)
 551 {
 552         int j,k,l,e;
 553         unsigned char *cp;
 554
 555         if (!dbg_log)
 556                 return;
 557
 558         fprintf(dbg_log, "===== START CLUSTER ALLOCATION MAP =====\n");
 559         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 560         indent++;
 561
 562         cp = (unsigned char *)cg_clustersfree(cgr);
 563         if (sb->fs_old_nspf)
 564                 e = howmany(sb->fs_old_cpg * sb->fs_old_spc / (sb->fs_old_nspf << sb->fs_fragshift), CHAR_BIT);
 565         else
 566                 e = 0;
 567         for (j = 0; j < e; j += 32) {
 568                 fprintf(dbg_log, "%08x: ", j);
 569                 for (k = 0; k < 32; k += 8) {
 570                         if (j + k + 8 < e) {
 571                                 fprintf(dbg_log,
 572                                     "%02x%02x%02x%02x%02x%02x%02x%02x ",
 573                                     cp[0], cp[1], cp[2], cp[3],
 574                                     cp[4], cp[5], cp[6], cp[7]);
 575                         } else {
 576                                 for (l = 0; (l < 8) && (j + k + l <e); l++) {
 577                                         fprintf(dbg_log, "%02x", cp[l]);
 578                                 }
 579                         }
 580                         cp += 8;
 581                 }
 582                 fprintf(dbg_log, "\n");
 583         }
 584
 585         indent--;
 586         fprintf(dbg_log, "===== END CLUSTER ALLOCATION MAP =====\n");
 587
 588         return;
 589 }
 590
 591 /*
 592  * Dump the cluster availability summary of one cylinder group.
 593  */
 594 void
 595 dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)
 596 {
 597         int j;
 598         int *ip;
 599
 600         if (!dbg_log)
 601                 return;
 602
 603         fprintf(dbg_log, "===== START CLUSTER SUMMARY =====\n");
 604         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 605         indent++;
 606
 607         ip = (int *)cg_clustersum(cgr);
 608         for (j = 0; j <= sb->fs_contigsumsize; j++) {
 609                 fprintf(dbg_log, "%02d: %8d\n", j, *ip++);
 610         }
 611
 612         indent--;
 613         fprintf(dbg_log, "===== END CLUSTER SUMMARY =====\n");
 614
 615         return;
 616 }
 617
 618 #ifdef NOT_CURRENTLY
 619 /*
 620  * This code dates from before the UFS2 integration, and doesn't compile
 621  * post-UFS2 due to the use of cg_blks().  I'm not sure how best to update
 622  * this for UFS2, where the rotational bits of UFS no longer apply, so
 623  * will leave it disabled for now; it should probably be re-enabled
 624  * specifically for UFS1.
 625  */
 626 /*
 627  * Dump the block summary, and the rotational layout table.
 628  */
 629 void
 630 dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)
 631 {
 632         int j,k;
 633         int *ip;
 634
 635         if (!dbg_log)
 636                 return;
 637
 638         fprintf(dbg_log,
 639             "===== START BLOCK SUMMARY AND POSITION TABLE =====\n");
 640         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 641         indent++;
 642
 643         ip = (int *)cg_blktot(cgr);
 644         for (j = 0; j < sb->fs_old_cpg; j++) {
 645                 fprintf(dbg_log, "%2d: %5d = ", j, *ip++);
 646                 for (k = 0; k < sb->fs_old_nrpos; k++) {
 647                         fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]);
 648                         if (k < sb->fs_old_nrpos - 1)
 649                                 fprintf(dbg_log, " + ");
 650                 }
 651                 fprintf(dbg_log, "\n");
 652         }
 653
 654         indent--;
 655         fprintf(dbg_log, "===== END BLOCK SUMMARY AND POSITION TABLE =====\n");
 656
 657         return;
 658 }
 659 #endif
 660
 661 /*
 662  * Dump a UFS1 inode structure.
 663  */
 664 void
 665 dbg_dump_ufs1_ino(struct fs *sb, const char *comment, struct ufs1_dinode *ino)
 666 {
 667         int ictr;
 668         int remaining_blocks;
 669
 670         if (!dbg_log)
 671                 return;
 672
 673         fprintf(dbg_log, "===== START UFS1 INODE DUMP =====\n");
 674         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
 675         indent++;
 676
 677         fprintf(dbg_log, "mode       u_int16_t      0%o\n", ino->di_mode);
 678         fprintf(dbg_log, "nlink      int16_t        0x%04x\n", ino->di_nlink);
 679         fprintf(dbg_log, "size       u_int64_t      0x%08x%08x\n",
 680             ((unsigned int *)&(ino->di_size))[1],
 681             ((unsigned int *)&(ino->di_size))[0]);
 682         fprintf(dbg_log, "atime      int32_t        0x%08x\n", ino->di_atime);
 683         fprintf(dbg_log, "atimensec  int32_t        0x%08x\n",
 684             ino->di_atimensec);
 685         fprintf(dbg_log, "mtime      int32_t        0x%08x\n",
 686             ino->di_mtime);
 687         fprintf(dbg_log, "mtimensec  int32_t        0x%08x\n",
 688             ino->di_mtimensec);
 689         fprintf(dbg_log, "ctime      int32_t        0x%08x\n", ino->di_ctime);
 690         fprintf(dbg_log, "ctimensec  int32_t        0x%08x\n",
 691             ino->di_ctimensec);
 692
 693         remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
 694         for (ictr = 0; ictr < MIN(UFS_NDADDR, remaining_blocks); ictr++) {
 695                 fprintf(dbg_log, "db         ufs_daddr_t[%x] 0x%08x\n", ictr,
 696                     ino->di_db[ictr]);
 697         }
 698         remaining_blocks -= UFS_NDADDR;
 699         if (remaining_blocks > 0) {
 700                 fprintf(dbg_log, "ib         ufs_daddr_t[0] 0x%08x\n",
 701                     ino->di_ib[0]);
 702         }
 703         remaining_blocks -= howmany(sb->fs_bsize, sizeof(ufs1_daddr_t));
 704         if (remaining_blocks > 0) {
 705                 fprintf(dbg_log, "ib         ufs_daddr_t[1] 0x%08x\n",
 706                     ino->di_ib[1]);
 707         }
 708 #define SQUARE(a) ((a) * (a))
 709         remaining_blocks -= SQUARE(howmany(sb->fs_bsize, sizeof(ufs1_daddr_t)));
 710 #undef SQUARE
 711         if (remaining_blocks > 0) {
 712                 fprintf(dbg_log, "ib         ufs_daddr_t[2] 0x%08x\n",
 713                     ino->di_ib[2]);
 714         }
 715
 716         fprintf(dbg_log, "flags      u_int32_t      0x%08x\n", ino->di_flags);
 717         fprintf(dbg_log, "blocks     int32_t        0x%08x\n", ino->di_blocks);
 718         fprintf(dbg_log, "gen        int32_t        0x%08x\n", ino->di_gen);
 719         fprintf(dbg_log, "uid        u_int32_t      0x%08x\n", ino->di_uid);
 720         fprintf(dbg_log, "gid        u_int32_t      0x%08x\n", ino->di_gid);
 721
 722         indent--;
 723         fprintf(dbg_log, "===== END UFS1 INODE DUMP =====\n");
 724
 725         return;
 726 }
 727
 728 /*
 729  * Dump a UFS2 inode structure.
 730  */
 731 void
 732 dbg_dump_ufs2_ino(struct fs *sb, const char *comment, struct ufs2_dinode *ino)
 733 {
 734         int ictr;
 735         int remaining_blocks;
 736
 737         if (!dbg_log)
 738                 return;
 739
 740         fprintf(dbg_log, "===== START UFS2 INODE DUMP =====\n");
 741         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
 742         indent++;
 743
 744         fprintf(dbg_log, "mode       u_int16_t      0%o\n", ino->di_mode);
 745         fprintf(dbg_log, "nlink      int16_t        0x%04x\n", ino->di_nlink);
 746         fprintf(dbg_log, "uid        u_int32_t      0x%08x\n", ino->di_uid);
 747         fprintf(dbg_log, "gid        u_int32_t      0x%08x\n", ino->di_gid);
 748         fprintf(dbg_log, "blksize    u_int32_t      0x%08x\n", ino->di_blksize);
 749         fprintf(dbg_log, "size       u_int64_t      0x%08x%08x\n",
 750             ((unsigned int *)&(ino->di_size))[1],
 751             ((unsigned int *)&(ino->di_size))[0]);
 752         fprintf(dbg_log, "blocks     u_int64_t      0x%08x%08x\n",
 753             ((unsigned int *)&(ino->di_blocks))[1],
 754             ((unsigned int *)&(ino->di_blocks))[0]);
 755         fprintf(dbg_log, "atime      ufs_time_t     %10jd\n", ino->di_atime);
 756         fprintf(dbg_log, "mtime      ufs_time_t     %10jd\n", ino->di_mtime);
 757         fprintf(dbg_log, "ctime      ufs_time_t     %10jd\n", ino->di_ctime);
 758         fprintf(dbg_log, "birthtime  ufs_time_t     %10jd\n", ino->di_birthtime);
 759         fprintf(dbg_log, "mtimensec  int32_t        0x%08x\n", ino->di_mtimensec);
 760         fprintf(dbg_log, "atimensec  int32_t        0x%08x\n", ino->di_atimensec);
 761         fprintf(dbg_log, "ctimensec  int32_t        0x%08x\n", ino->di_ctimensec);
 762         fprintf(dbg_log, "birthnsec  int32_t        0x%08x\n", ino->di_birthnsec);
 763         fprintf(dbg_log, "gen        int32_t        0x%08x\n", ino->di_gen);
 764         fprintf(dbg_log, "kernflags  u_int32_t      0x%08x\n", ino->di_kernflags);
 765         fprintf(dbg_log, "flags      u_int32_t      0x%08x\n", ino->di_flags);
 766         fprintf(dbg_log, "extsize    u_int32_t      0x%08x\n", ino->di_extsize);
 767
 768         /* XXX: What do we do with di_extb[UFS_NXADDR]? */
 769
 770         remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
 771         for (ictr = 0; ictr < MIN(UFS_NDADDR, remaining_blocks); ictr++) {
 772                 fprintf(dbg_log, "db         ufs2_daddr_t[%x] 0x%16jx\n", ictr,
 773                     ino->di_db[ictr]);
 774         }
 775         remaining_blocks -= UFS_NDADDR;
 776         if (remaining_blocks > 0) {
 777                 fprintf(dbg_log, "ib         ufs2_daddr_t[0] 0x%16jx\n",
 778                     ino->di_ib[0]);
 779         }
 780         remaining_blocks -= howmany(sb->fs_bsize, sizeof(ufs2_daddr_t));
 781         if (remaining_blocks > 0) {
 782                 fprintf(dbg_log, "ib         ufs2_daddr_t[1] 0x%16jx\n",
 783                     ino->di_ib[1]);
 784         }
 785 #define SQUARE(a) ((a) * (a))
 786         remaining_blocks -= SQUARE(howmany(sb->fs_bsize, sizeof(ufs2_daddr_t)));
 787 #undef SQUARE
 788         if (remaining_blocks > 0) {
 789                 fprintf(dbg_log, "ib         ufs2_daddr_t[2] 0x%16jx\n",
 790                     ino->di_ib[2]);
 791         }
 792
 793         indent--;
 794         fprintf(dbg_log, "===== END UFS2 INODE DUMP =====\n");
 795
 796         return;
 797 }
 798
 799 /*
 800  * Dump an indirect block. The iteration to dump a full file has to be
 801  * written around.
 802  */
 803 void
 804 dbg_dump_iblk(struct fs *sb, const char *comment, char *block, size_t length)
 805 {
 806         unsigned int *mem, i, j, size;
 807
 808         if (!dbg_log)
 809                 return;
 810
 811         fprintf(dbg_log, "===== START INDIRECT BLOCK DUMP =====\n");
 812         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)block,
 813             comment);
 814         indent++;
 815
 816         if (sb->fs_magic == FS_UFS1_MAGIC)
 817                 size = sizeof(ufs1_daddr_t);
 818         else
 819                 size = sizeof(ufs2_daddr_t);
 820
 821         mem = (unsigned int *)block;
 822         for (i = 0; (size_t)i < MIN(howmany(sb->fs_bsize, size), length);
 823             i += 8) {
 824                 fprintf(dbg_log, "%04x: ", i);
 825                 for (j = 0; j < 8; j++) {
 826                         if ((size_t)(i + j) < length)
 827                                 fprintf(dbg_log, "%08X ", *mem++);
 828                 }
 829                 fprintf(dbg_log, "\n");
 830         }
 831
 832         indent--;
 833         fprintf(dbg_log, "===== END INDIRECT BLOCK DUMP =====\n");
 834
 835         return;
 836 }
 837
 838 #endif /* FS_DEBUG */
 839