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