sbin/growfs/debug.c

   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/growfs/debug.c,v 1.3 2000/12/12 19:31:00 tomsoft Exp $
  39  * $FreeBSD: src/sbin/growfs/debug.c,v 1.3.2.1 2001/07/16 15:02:13 tomsoft Exp $
  40  * $DragonFly: src/sbin/growfs/debug.c,v 1.5 2007/05/20 23:21:36 dillon Exp $
  41  *
  42  * $FreeBSD: src/sbin/growfs/debug.c,v 1.3.2.1 2001/07/16 15:02:13 tomsoft Exp $
  43  */
  44
  45 /* ********************************************************** INCLUDES ***** */
  46 #include <sys/param.h>
  47
  48 #include <stdio.h>
  49 #include <vfs/ufs/dinode.h>
  50 #include <vfs/ufs/fs.h>
  51
  52 #include "debug.h"
  53
  54 #ifdef FS_DEBUG
  55
  56 /* *********************************************************** GLOBALS ***** */
  57 static FILE     *dbg_log;
  58 static unsigned int     indent;
  59 static unsigned int dbg_log_isstdout;
  60
  61 /*
  62  * prototypes not done here, as they come with debug.h
  63  */
  64
  65 /* ********************************************************** dbg_open ***** */
  66 /*
  67  * Open the filehandle where all debug output has to go.
  68  */
  69 void
  70 dbg_open(const char *fn)
  71 {
  72         if (fn) {
  73                 dbg_log=fopen(fn, "a");
  74         } else {
  75                 dbg_log_isstdout = 1;
  76                 dbg_log=stdout;
  77         }
  78
  79         return;
  80 }
  81
  82 /* ********************************************************* dbg_close ***** */
  83 /*
  84  * Close the filehandle where all debug output went to.
  85  */
  86 void
  87 dbg_close(void)
  88 {
  89         if (dbg_log && dbg_log_isstdout == 0) {
  90                 fclose(dbg_log);
  91         }
  92         dbg_log = NULL;
  93         dbg_log_isstdout = 0;
  94
  95         return;
  96 }
  97
  98 /* ****************************************************** dbg_dump_hex ***** */
  99 /*
 100  * Dump out a full filesystem block in hex.
 101  */
 102 void
 103 dbg_dump_hex(struct fs *sb, const char *comment, unsigned char *mem)
 104 {
 105         int i, j, k;
 106
 107         if(!dbg_log) {
 108                 return;
 109         }
 110         fprintf(dbg_log, "===== START HEXDUMP =====\n");
 111         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)mem, comment);
 112         indent++;
 113         for (i=0; i<sb->fs_bsize; i+=24) {
 114                 for (j=0; j<3; j++) {
 115                         for (k=0; k<8; k++) {
 116                                 fprintf(dbg_log, "%02x ", *mem++);
 117                         }
 118                         fprintf(dbg_log, "  ");
 119                 }
 120                 fprintf(dbg_log, "\n");
 121         }
 122         indent--;
 123         fprintf(dbg_log, "===== END HEXDUMP =====\n");
 124
 125         return;
 126 }
 127
 128 /* ******************************************************* dbg_dump_fs ***** */
 129 /*
 130  * Dump the superblock.
 131  */
 132 void
 133 dbg_dump_fs(struct fs *sb, const char *comment)
 134 {
 135 #ifdef FSMAXSNAP
 136         int     j;
 137 #endif /* FSMAXSNAP */
 138
 139         if(!dbg_log) {
 140                 return;
 141         }
 142
 143         fprintf(dbg_log, "===== START SUPERBLOCK =====\n");
 144         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)sb, comment);
 145         indent++;
 146
 147         fprintf(dbg_log, "sblkno        ufs_daddr_t       0x%08x\n",
 148             sb->fs_sblkno);
 149         fprintf(dbg_log, "cblkno        ufs_daddr_t       0x%08x\n",
 150             sb->fs_cblkno);
 151         fprintf(dbg_log, "iblkno        ufs_daddr_t       0x%08x\n",
 152             sb->fs_iblkno);
 153         fprintf(dbg_log, "dblkno        ufs_daddr_t       0x%08x\n",
 154             sb->fs_dblkno);
 155
 156         fprintf(dbg_log, "cgoffset      int32_t           0x%08x\n",
 157             sb->fs_cgoffset);
 158         fprintf(dbg_log, "cgmask        int32_t           0x%08x\n",
 159             sb->fs_cgmask);
 160         fprintf(dbg_log, "time          time_t            %10u\n",
 161             (unsigned int)sb->fs_time);
 162         fprintf(dbg_log, "size          int32_t           0x%08x\n",
 163             sb->fs_size);
 164         fprintf(dbg_log, "dsize         int32_t           0x%08x\n",
 165             sb->fs_dsize);
 166         fprintf(dbg_log, "ncg           int32_t           0x%08x\n",
 167             sb->fs_ncg);
 168         fprintf(dbg_log, "bsize         int32_t           0x%08x\n",
 169             sb->fs_bsize);
 170         fprintf(dbg_log, "fsize         int32_t           0x%08x\n",
 171             sb->fs_fsize);
 172         fprintf(dbg_log, "frag          int32_t           0x%08x\n",
 173             sb->fs_frag);
 174
 175         fprintf(dbg_log, "minfree       int32_t           0x%08x\n",
 176             sb->fs_minfree);
 177         fprintf(dbg_log, "rotdelay      int32_t           0x%08x\n",
 178             sb->fs_rotdelay);
 179         fprintf(dbg_log, "rps           int32_t           0x%08x\n",
 180             sb->fs_rps);
 181
 182         fprintf(dbg_log, "bmask         int32_t           0x%08x\n",
 183             sb->fs_bmask);
 184         fprintf(dbg_log, "fmask         int32_t           0x%08x\n",
 185             sb->fs_fmask);
 186         fprintf(dbg_log, "bshift        int32_t           0x%08x\n",
 187             sb->fs_bshift);
 188         fprintf(dbg_log, "fshift        int32_t           0x%08x\n",
 189             sb->fs_fshift);
 190
 191         fprintf(dbg_log, "maxcontig     int32_t           0x%08x\n",
 192             sb->fs_maxcontig);
 193         fprintf(dbg_log, "maxbpg        int32_t           0x%08x\n",
 194             sb->fs_maxbpg);
 195
 196         fprintf(dbg_log, "fragshift     int32_t           0x%08x\n",
 197             sb->fs_fragshift);
 198         fprintf(dbg_log, "fsbtodb       int32_t           0x%08x\n",
 199             sb->fs_fsbtodb);
 200         fprintf(dbg_log, "sbsize        int32_t           0x%08x\n",
 201             sb->fs_sbsize);
 202         fprintf(dbg_log, "csmask        int32_t           0x%08x\n",
 203             sb->fs_csmask);
 204         fprintf(dbg_log, "csshift       int32_t           0x%08x\n",
 205             sb->fs_csshift);
 206         fprintf(dbg_log, "nindir        int32_t           0x%08x\n",
 207             sb->fs_nindir);
 208         fprintf(dbg_log, "inopb         int32_t           0x%08x\n",
 209             sb->fs_inopb);
 210         fprintf(dbg_log, "nspf          int32_t           0x%08x\n",
 211             sb->fs_nspf);
 212
 213         fprintf(dbg_log, "optim         int32_t           0x%08x\n",
 214             sb->fs_optim);
 215
 216         fprintf(dbg_log, "npsect        int32_t           0x%08x\n",
 217             sb->fs_npsect);
 218         fprintf(dbg_log, "interleave    int32_t           0x%08x\n",
 219             sb->fs_interleave);
 220         fprintf(dbg_log, "trackskew     int32_t           0x%08x\n",
 221             sb->fs_trackskew);
 222
 223         fprintf(dbg_log, "id            int32_t[2]        %08x %08x\n",
 224             sb->fs_id[0], sb->fs_id[1]);
 225
 226         fprintf(dbg_log, "csaddr        ufs_daddr_t       0x%08x\n",
 227             sb->fs_csaddr);
 228         fprintf(dbg_log, "cssize        int32_t           0x%08x\n",
 229             sb->fs_cssize);
 230         fprintf(dbg_log, "cgsize        int32_t           0x%08x\n",
 231             sb->fs_cgsize);
 232
 233         fprintf(dbg_log, "ntrak         int32_t           0x%08x\n",
 234             sb->fs_ntrak);
 235         fprintf(dbg_log, "nsect         int32_t           0x%08x\n",
 236             sb->fs_nsect);
 237         fprintf(dbg_log, "spc           int32_t           0x%08x\n",
 238             sb->fs_spc);
 239
 240         fprintf(dbg_log, "ncyl          int32_t           0x%08x\n",
 241             sb->fs_ncyl);
 242
 243         fprintf(dbg_log, "cpg           int32_t           0x%08x\n",
 244             sb->fs_cpg);
 245         fprintf(dbg_log, "ipg           int32_t           0x%08x\n",
 246             sb->fs_ipg);
 247         fprintf(dbg_log, "fpg           int32_t           0x%08x\n",
 248             sb->fs_fpg);
 249
 250         dbg_dump_csum("internal cstotal", &sb->fs_cstotal);
 251
 252         fprintf(dbg_log, "fmod          int8_t            0x%02x\n",
 253             sb->fs_fmod);
 254         fprintf(dbg_log, "clean         int8_t            0x%02x\n",
 255             sb->fs_clean);
 256         fprintf(dbg_log, "ronly         int8_t            0x%02x\n",
 257             sb->fs_ronly);
 258         fprintf(dbg_log, "flags         int8_t            0x%02x\n",
 259             sb->fs_flags);
 260         fprintf(dbg_log, "fsmnt         u_char[MAXMNTLEN] \"%s\"\n",
 261             sb->fs_fsmnt);
 262
 263         fprintf(dbg_log, "cgrotor       int32_t           0x%08x\n",
 264             sb->fs_cgrotor);
 265 /*
 266  * struct csum[MAXCSBUFS] - is only maintained in memory
 267  */
 268 /*      fprintf(dbg_log, " int32_t\n", sb->*fs_maxcluster);*/
 269         fprintf(dbg_log, "cpc           int32_t           0x%08x\n",
 270             sb->fs_cpc);
 271 /*
 272  * int16_t fs_opostbl[16][8] - is dumped when used in dbg_dump_sptbl
 273  */
 274 #ifdef FSMAXSNAP
 275         for(j=0; j<FSMAXSNAP; j++) {
 276                 fprintf(dbg_log, "snapinum      int32_t[%2d]       0x%08x\n",
 277                     j, sb->fs_snapinum[j]);
 278                 if(!sb->fs_snapinum[j]) { /* list is dense */
 279                         break;
 280                 }
 281         }
 282 #endif /* FSMAXSNAP */
 283         fprintf(dbg_log, "contigsumsize int32_t           0x%08x\n",
 284             sb->fs_contigsumsize);
 285         fprintf(dbg_log, "maxsymlinklen int32_t           0x%08x\n",
 286             sb->fs_maxsymlinklen);
 287         fprintf(dbg_log, "inodefmt      int32_t           0x%08x\n",
 288             sb->fs_inodefmt);
 289         fprintf(dbg_log, "maxfilesize   u_int64_t         0x%08x%08x\n",
 290             ((unsigned int *)&(sb->fs_maxfilesize))[1],
 291             ((unsigned int *)&(sb->fs_maxfilesize))[0]);
 292         fprintf(dbg_log, "qbmask        int64_t           0x%08x%08x\n",
 293             ((unsigned int *)&(sb->fs_qbmask))[1],
 294             ((unsigned int *)&(sb->fs_qbmask))[0]);
 295         fprintf(dbg_log, "qfmask        int64_t           0x%08x%08x\n",
 296             ((unsigned int *)&(sb->fs_qfmask))[1],
 297             ((unsigned int *)&(sb->fs_qfmask))[0]);
 298         fprintf(dbg_log, "state         int32_t           0x%08x\n",
 299             sb->fs_state);
 300         fprintf(dbg_log, "postblformat  int32_t           0x%08x\n",
 301             sb->fs_postblformat);
 302         fprintf(dbg_log, "nrpos         int32_t           0x%08x\n",
 303             sb->fs_nrpos);
 304         fprintf(dbg_log, "postbloff     int32_t           0x%08x\n",
 305             sb->fs_postbloff);
 306         fprintf(dbg_log, "rotbloff      int32_t           0x%08x\n",
 307             sb->fs_rotbloff);
 308         fprintf(dbg_log, "magic         int32_t           0x%08x\n",
 309             sb->fs_magic);
 310
 311         indent--;
 312         fprintf(dbg_log, "===== END SUPERBLOCK =====\n");
 313
 314         return;
 315 }
 316
 317 /* ******************************************************* dbg_dump_cg ***** */
 318 /*
 319  * Dump a cylinder group.
 320  */
 321 void
 322 dbg_dump_cg(const char *comment, struct cg *cgr)
 323 {
 324         int j;
 325
 326         if(!dbg_log) {
 327                 return;
 328         }
 329
 330         fprintf(dbg_log, "===== START CYLINDER GROUP =====\n");
 331         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 332         indent++;
 333
 334         fprintf(dbg_log, "magic         int32_t    0x%08x\n", cgr->cg_magic);
 335         fprintf(dbg_log, "time          time_t     %10u\n", (unsigned int)
 336             cgr->cg_time);
 337         fprintf(dbg_log, "cgx           int32_t    0x%08x\n", cgr->cg_cgx);
 338         fprintf(dbg_log, "ncyl          int16_t    0x%04x\n", cgr->cg_ncyl);
 339         fprintf(dbg_log, "niblk         int16_t    0x%04x\n", cgr->cg_niblk);
 340         fprintf(dbg_log, "ndblk         int32_t    0x%08x\n", cgr->cg_ndblk);
 341         dbg_dump_csum("internal cs", &cgr->cg_cs);
 342         fprintf(dbg_log, "rotor         int32_t    0x%08x\n", cgr->cg_rotor);
 343         fprintf(dbg_log, "frotor        int32_t    0x%08x\n", cgr->cg_frotor);
 344         fprintf(dbg_log, "irotor        int32_t    0x%08x\n", cgr->cg_irotor);
 345         for(j=0; j<MAXFRAG; j++) {
 346                 fprintf(dbg_log, "frsum         int32_t[%d] 0x%08x\n", j,
 347                     cgr->cg_frsum[j]);
 348         }
 349         fprintf(dbg_log, "btotoff       int32_t    0x%08x\n", cgr->cg_btotoff);
 350         fprintf(dbg_log, "boff          int32_t    0x%08x\n", cgr->cg_boff);
 351         fprintf(dbg_log, "iusedoff      int32_t    0x%08x\n", cgr->cg_iusedoff);
 352         fprintf(dbg_log, "freeoff       int32_t    0x%08x\n", cgr->cg_freeoff);
 353         fprintf(dbg_log, "nextfreeoff   int32_t    0x%08x\n",
 354             cgr->cg_nextfreeoff);
 355         fprintf(dbg_log, "clustersumoff int32_t    0x%08x\n",
 356             cgr->cg_clustersumoff);
 357         fprintf(dbg_log, "clusterof     int32_t    0x%08x\n",
 358             cgr->cg_clusteroff);
 359         fprintf(dbg_log, "nclusterblks  int32_t    0x%08x\n",
 360             cgr->cg_nclusterblks);
 361
 362         indent--;
 363         fprintf(dbg_log, "===== END CYLINDER GROUP =====\n");
 364
 365         return;
 366 }
 367
 368 /* ***************************************************** dbg_dump_csum ***** */
 369 /*
 370  * Dump a cylinder summary.
 371  */
 372 void
 373 dbg_dump_csum(const char *comment, struct csum *cs)
 374 {
 375
 376         if(!dbg_log) {
 377                 return;
 378         }
 379
 380         fprintf(dbg_log, "===== START CYLINDER SUMMARY =====\n");
 381         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
 382         indent++;
 383
 384         fprintf(dbg_log, "ndir   int32_t 0x%08x\n", cs->cs_ndir);
 385         fprintf(dbg_log, "nbfree int32_t 0x%08x\n", cs->cs_nbfree);
 386         fprintf(dbg_log, "nifree int32_t 0x%08x\n", cs->cs_nifree);
 387         fprintf(dbg_log, "nffree int32_t 0x%08x\n", cs->cs_nffree);
 388
 389         indent--;
 390         fprintf(dbg_log, "===== END CYLINDER SUMMARY =====\n");
 391
 392         return;
 393 }
 394
 395 /* **************************************************** dbg_dump_inmap ***** */
 396 /*
 397  * Dump the inode allocation map in one cylinder group.
 398  */
 399 void
 400 dbg_dump_inmap(struct fs *sb, const char *comment, struct cg *cgr)
 401 {
 402         int j,k,l,e;
 403         unsigned char *cp;
 404
 405         if(!dbg_log) {
 406                 return;
 407         }
 408
 409         fprintf(dbg_log, "===== START INODE ALLOCATION MAP =====\n");
 410         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 411         indent++;
 412
 413         cp=(unsigned char *)cg_inosused(cgr);
 414         e=sb->fs_ipg/8;
 415         for(j=0; j<e; j+=32) {
 416                 fprintf(dbg_log, "%08x: ", j);
 417                 for(k=0; k<32; k+=8) {
 418                         if(j+k+8<e) {
 419                                 fprintf(dbg_log,
 420                                     "%02x%02x%02x%02x%02x%02x%02x%02x ",
 421                                     cp[0], cp[1], cp[2], cp[3],
 422                                     cp[4], cp[5], cp[6], cp[7]);
 423                         } else {
 424                                 for(l=0; (l<8)&&(j+k+l<e); l++) {
 425                                         fprintf(dbg_log, "%02x", cp[l]);
 426                                 }
 427                         }
 428                         cp+=8;
 429                 }
 430                 fprintf(dbg_log, "\n");
 431         }
 432
 433         indent--;
 434         fprintf(dbg_log, "===== END INODE ALLOCATION MAP =====\n");
 435
 436         return;
 437 }
 438
 439
 440 /* **************************************************** dbg_dump_frmap ***** */
 441 /*
 442  * Dump the fragment allocation map in one cylinder group.
 443  */
 444 void
 445 dbg_dump_frmap(struct fs *sb, const char *comment, struct cg *cgr)
 446 {
 447         int j,k,l,e;
 448         unsigned char *cp;
 449
 450         if(!dbg_log) {
 451                 return;
 452         }
 453
 454         fprintf(dbg_log, "===== START FRAGMENT ALLOCATION MAP =====\n");
 455         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 456         indent++;
 457
 458         cp=(unsigned char *)cg_blksfree(cgr);
 459         e=howmany((sb->fs_cpg * sb->fs_spc / NSPF(sb)), NBBY);
 460         for(j=0; j<e; j+=32) {
 461                 fprintf(dbg_log, "%08x: ", j);
 462                 for(k=0; k<32; k+=8) {
 463                         if(j+k+8<e) {
 464                                 fprintf(dbg_log,
 465                                     "%02x%02x%02x%02x%02x%02x%02x%02x ",
 466                                     cp[0], cp[1], cp[2], cp[3],
 467                                     cp[4], cp[5], cp[6], cp[7]);
 468                         } else {
 469                                 for(l=0; (l<8)&&(j+k+l<e); l++) {
 470                                         fprintf(dbg_log, "%02x", cp[l]);
 471                                 }
 472                         }
 473                         cp+=8;
 474                 }
 475                 fprintf(dbg_log, "\n");
 476         }
 477
 478         indent--;
 479         fprintf(dbg_log, "===== END FRAGMENT ALLOCATION MAP =====\n");
 480
 481         return;
 482 }
 483
 484 /* **************************************************** dbg_dump_clmap ***** */
 485 /*
 486  * Dump the cluster allocation map in one cylinder group.
 487  */
 488 void
 489 dbg_dump_clmap(struct fs *sb, const char *comment, struct cg *cgr)
 490 {
 491         int j,k,l,e;
 492         unsigned char *cp;
 493
 494         if(!dbg_log) {
 495                 return;
 496         }
 497
 498         fprintf(dbg_log, "===== START CLUSTER ALLOCATION MAP =====\n");
 499         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 500         indent++;
 501
 502         cp=(unsigned char *)cg_clustersfree(cgr);
 503         e=howmany(sb->fs_cpg * sb->fs_spc / NSPB(sb), NBBY);
 504         for(j=0; j<e; j+=32) {
 505                 fprintf(dbg_log, "%08x: ", j);
 506                 for(k=0; k<32; k+=8) {
 507                         if(j+k+8<e) {
 508                                 fprintf(dbg_log,
 509                                     "%02x%02x%02x%02x%02x%02x%02x%02x ",
 510                                     cp[0], cp[1], cp[2], cp[3],
 511                                     cp[4], cp[5], cp[6], cp[7]);
 512                         } else {
 513                                 for(l=0; (l<8)&&(j+k+l<e); l++) {
 514                                         fprintf(dbg_log, "%02x", cp[l]);
 515                                 }
 516                         }
 517                         cp+=8;
 518                 }
 519                 fprintf(dbg_log, "\n");
 520         }
 521
 522         indent--;
 523         fprintf(dbg_log, "===== END CLUSTER ALLOCATION MAP =====\n");
 524
 525         return;
 526 }
 527
 528 /* **************************************************** dbg_dump_clsum ***** */
 529 /*
 530  * Dump the cluster availability summary of one cylinder group.
 531  */
 532 void
 533 dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)
 534 {
 535         int j;
 536         int *ip;
 537
 538         if(!dbg_log) {
 539                 return;
 540         }
 541
 542         fprintf(dbg_log, "===== START CLUSTER SUMMARY =====\n");
 543         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 544         indent++;
 545
 546         ip=(int *)cg_clustersum(cgr);
 547         for(j=0; j<=sb->fs_contigsumsize; j++) {
 548                 fprintf(dbg_log, "%02d: %8d\n", j, *ip++);
 549         }
 550
 551         indent--;
 552         fprintf(dbg_log, "===== END CLUSTER SUMMARY =====\n");
 553
 554         return;
 555 }
 556
 557 /* **************************************************** dbg_dump_sptbl ***** */
 558 /*
 559  * Dump the block summary, and the rotational layout table.
 560  */
 561 void
 562 dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)
 563 {
 564         int j,k;
 565         int *ip;
 566
 567         if(!dbg_log) {
 568                 return;
 569         }
 570
 571         fprintf(dbg_log,
 572             "===== START BLOCK SUMMARY AND POSITION TABLE =====\n");
 573         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
 574         indent++;
 575
 576         ip=(int *)cg_blktot(cgr);
 577         for(j=0; j<sb->fs_cpg; j++) {
 578                 fprintf(dbg_log, "%2d: %5d = ", j, *ip++);
 579                 for(k=0; k<sb->fs_nrpos; k++) {
 580                         fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]);
 581                         if(k<sb->fs_nrpos-1) {
 582                                 fprintf(dbg_log, " + ");
 583                         }
 584                 }
 585                 fprintf(dbg_log, "\n");
 586         }
 587
 588         indent--;
 589         fprintf(dbg_log, "===== END BLOCK SUMMARY AND POSITION TABLE =====\n");
 590
 591         return;
 592 }
 593
 594 /* ****************************************************** dbg_dump_ino ***** */
 595 /*
 596  * Dump an inode structure.
 597  */
 598 void
 599 dbg_dump_ino(struct fs *sb, const char *comment, struct ufs1_dinode *ino)
 600 {
 601         int ictr;
 602         int remaining_blocks;
 603
 604         if(!dbg_log) {
 605                 return;
 606         }
 607
 608         fprintf(dbg_log, "===== START INODE DUMP =====\n");
 609         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
 610         indent++;
 611
 612         fprintf(dbg_log, "mode       u_int16_t      0%o\n", ino->di_mode);
 613         fprintf(dbg_log, "nlink      int16_t        0x%04x\n", ino->di_nlink);
 614         fprintf(dbg_log, "size       u_int64_t      0x%08x%08x\n",
 615             ((unsigned int *)&(ino->di_size))[1],
 616             ((unsigned int *)&(ino->di_size))[0]);
 617         fprintf(dbg_log, "atime      int32_t        0x%08x\n", ino->di_atime);
 618         fprintf(dbg_log, "atimensec  int32_t        0x%08x\n",
 619             ino->di_atimensec);
 620         fprintf(dbg_log, "mtime      int32_t        0x%08x\n",
 621             ino->di_mtime);
 622         fprintf(dbg_log, "mtimensec  int32_t        0x%08x\n",
 623             ino->di_mtimensec);
 624         fprintf(dbg_log, "ctime      int32_t        0x%08x\n", ino->di_ctime);
 625         fprintf(dbg_log, "ctimensec  int32_t        0x%08x\n",
 626             ino->di_ctimensec);
 627
 628         remaining_blocks=howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
 629         for(ictr=0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
 630                 fprintf(dbg_log, "db         ufs_daddr_t[%x] 0x%08x\n", ictr,
 631                     ino->di_db[ictr]);
 632         }
 633         remaining_blocks-=NDADDR;
 634         if(remaining_blocks>0) {
 635                 fprintf(dbg_log, "ib         ufs_daddr_t[0] 0x%08x\n",
 636                     ino->di_ib[0]);
 637         }
 638         remaining_blocks-=howmany(sb->fs_bsize, sizeof(ufs_daddr_t));
 639         if(remaining_blocks>0) {
 640                 fprintf(dbg_log, "ib         ufs_daddr_t[1] 0x%08x\n",
 641                     ino->di_ib[1]);
 642         }
 643 #define SQUARE(a) ((a)*(a))
 644         remaining_blocks-=SQUARE(howmany(sb->fs_bsize, sizeof(ufs_daddr_t)));
 645 #undef SQUARE
 646         if(remaining_blocks>0) {
 647                 fprintf(dbg_log, "ib         ufs_daddr_t[2] 0x%08x\n",
 648                     ino->di_ib[2]);
 649         }
 650
 651         fprintf(dbg_log, "flags      u_int32_t      0x%08x\n", ino->di_flags);
 652         fprintf(dbg_log, "blocks     int32_t        0x%08x\n", ino->di_blocks);
 653         fprintf(dbg_log, "gen        int32_t        0x%08x\n", ino->di_gen);
 654         fprintf(dbg_log, "uid        u_int32_t      0x%08x\n", ino->di_uid);
 655         fprintf(dbg_log, "gid        u_int32_t      0x%08x\n", ino->di_gid);
 656
 657         indent--;
 658         fprintf(dbg_log, "===== END INODE DUMP =====\n");
 659
 660         return;
 661 }
 662
 663 /* ***************************************************** dbg_dump_iblk ***** */
 664 /*
 665  * Dump an indirect block. The iteration to dump a full file has to be
 666  * written around.
 667  */
 668 void
 669 dbg_dump_iblk(struct fs *sb, const char *comment, char *block, size_t length)
 670 {
 671         unsigned int *mem;
 672         int i, j;
 673
 674         if(!dbg_log) {
 675                 return;
 676         }
 677
 678         fprintf(dbg_log, "===== START INDIRECT BLOCK DUMP =====\n");
 679         fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)block,
 680             comment);
 681         indent++;
 682
 683         mem=(unsigned int *)block;
 684         for (i=0; (size_t)i<MIN(howmany(sb->fs_bsize, sizeof(ufs_daddr_t)),
 685             length); i+=8) {
 686                 fprintf(dbg_log, "%04x: ", i);
 687                 for (j=0; j<8; j++) {
 688                         if((size_t)(i+j)<length) {
 689                                 fprintf(dbg_log, "%08X ", *mem++);
 690                         }
 691                 }
 692                 fprintf(dbg_log, "\n");
 693         }
 694
 695         indent--;
 696         fprintf(dbg_log, "===== END INDIRECT BLOCK DUMP =====\n");
 697
 698         return;
 699 }
 700
 701 #endif /* FS_DEBUG */
 702