2
* Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
3
* Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
6
* This code is derived from software contributed to Berkeley by
7
* Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt.
9
* Redistribution and use in source and binary forms, with or without
10
* modification, are permitted provided that the following conditions
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.
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
38
* $TSHeader: src/sbin/growfs/debug.c,v 1.3 2000/12/12 19:31:00 tomsoft Exp $
43
static const char rcsid[] =
47
/* ********************************************************** INCLUDES ***** */
48
#include <sys/param.h>
53
#include <ufs/ufs/dinode.h>
54
#include <ufs/ffs/fs.h>
60
/* *********************************************************** GLOBALS ***** */
61
static FILE *dbg_log=NULL;
62
static unsigned int indent=0;
65
* prototypes not done here, as they come with debug.h
68
/* ********************************************************** dbg_open ***** */
70
* Open the filehandle where all debug output has to go.
73
dbg_open(const char *fn)
76
if (strcmp(fn, "-") == 0)
77
dbg_log=fopen("/dev/stdout", "a");
79
dbg_log=fopen(fn, "a");
84
/* ********************************************************* dbg_close ***** */
86
* Close the filehandle where all debug output went to.
100
/* ****************************************************** dbg_dump_hex ***** */
102
* Dump out a full file system block in hex.
105
dbg_dump_hex(struct fs *sb, const char *comment, unsigned char *mem)
112
fprintf(dbg_log, "===== START HEXDUMP =====\n");
113
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)mem, comment);
115
for (i=0; i<sb->fs_bsize; i+=24) {
116
for (j=0; j<3; j++) {
117
for (k=0; k<8; k++) {
118
fprintf(dbg_log, "%02x ", *mem++);
120
fprintf(dbg_log, " ");
122
fprintf(dbg_log, "\n");
125
fprintf(dbg_log, "===== END HEXDUMP =====\n");
130
/* ******************************************************* dbg_dump_fs ***** */
132
* Dump the superblock.
135
dbg_dump_fs(struct fs *sb, const char *comment)
139
#endif /* FSMAXSNAP */
145
fprintf(dbg_log, "===== START SUPERBLOCK =====\n");
146
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)sb, comment);
149
fprintf(dbg_log, "sblkno int32_t 0x%08x\n",
151
fprintf(dbg_log, "cblkno int32_t 0x%08x\n",
153
fprintf(dbg_log, "iblkno int32_t 0x%08x\n",
155
fprintf(dbg_log, "dblkno int32_t 0x%08x\n",
158
fprintf(dbg_log, "old_cgoffset int32_t 0x%08x\n",
159
sb->fs_old_cgoffset);
160
fprintf(dbg_log, "old_cgmask int32_t 0x%08x\n",
162
fprintf(dbg_log, "old_time int32_t %10u\n",
163
(unsigned int)sb->fs_old_time);
164
fprintf(dbg_log, "old_size int32_t 0x%08x\n",
166
fprintf(dbg_log, "old_dsize int32_t 0x%08x\n",
168
fprintf(dbg_log, "ncg int32_t 0x%08x\n",
170
fprintf(dbg_log, "bsize int32_t 0x%08x\n",
172
fprintf(dbg_log, "fsize int32_t 0x%08x\n",
174
fprintf(dbg_log, "frag int32_t 0x%08x\n",
177
fprintf(dbg_log, "minfree int32_t 0x%08x\n",
179
fprintf(dbg_log, "old_rotdelay int32_t 0x%08x\n",
180
sb->fs_old_rotdelay);
181
fprintf(dbg_log, "old_rps int32_t 0x%08x\n",
184
fprintf(dbg_log, "bmask int32_t 0x%08x\n",
186
fprintf(dbg_log, "fmask int32_t 0x%08x\n",
188
fprintf(dbg_log, "bshift int32_t 0x%08x\n",
190
fprintf(dbg_log, "fshift int32_t 0x%08x\n",
193
fprintf(dbg_log, "maxcontig int32_t 0x%08x\n",
195
fprintf(dbg_log, "maxbpg int32_t 0x%08x\n",
198
fprintf(dbg_log, "fragshift int32_t 0x%08x\n",
200
fprintf(dbg_log, "fsbtodb int32_t 0x%08x\n",
202
fprintf(dbg_log, "sbsize int32_t 0x%08x\n",
204
fprintf(dbg_log, "spare1 int32_t[2] 0x%08x 0x%08x\n",
205
sb->fs_spare1[0], sb->fs_spare1[1]);
206
fprintf(dbg_log, "nindir int32_t 0x%08x\n",
208
fprintf(dbg_log, "inopb int32_t 0x%08x\n",
210
fprintf(dbg_log, "old_nspf int32_t 0x%08x\n",
213
fprintf(dbg_log, "optim int32_t 0x%08x\n",
216
fprintf(dbg_log, "old_npsect int32_t 0x%08x\n",
218
fprintf(dbg_log, "old_interleave int32_t 0x%08x\n",
219
sb->fs_old_interleave);
220
fprintf(dbg_log, "old_trackskew int32_t 0x%08x\n",
221
sb->fs_old_trackskew);
223
fprintf(dbg_log, "id int32_t[2] 0x%08x 0x%08x\n",
224
sb->fs_id[0], sb->fs_id[1]);
226
fprintf(dbg_log, "old_csaddr int32_t 0x%08x\n",
228
fprintf(dbg_log, "cssize int32_t 0x%08x\n",
230
fprintf(dbg_log, "cgsize int32_t 0x%08x\n",
233
fprintf(dbg_log, "spare2 int32_t 0x%08x\n",
235
fprintf(dbg_log, "old_nsect int32_t 0x%08x\n",
237
fprintf(dbg_log, "old_spc int32_t 0x%08x\n",
240
fprintf(dbg_log, "old_ncyl int32_t 0x%08x\n",
243
fprintf(dbg_log, "old_cpg int32_t 0x%08x\n",
245
fprintf(dbg_log, "ipg int32_t 0x%08x\n",
247
fprintf(dbg_log, "fpg int32_t 0x%08x\n",
250
dbg_dump_csum("internal old_cstotal", &sb->fs_old_cstotal);
252
fprintf(dbg_log, "fmod int8_t 0x%02x\n",
254
fprintf(dbg_log, "clean int8_t 0x%02x\n",
256
fprintf(dbg_log, "ronly int8_t 0x%02x\n",
258
fprintf(dbg_log, "old_flags int8_t 0x%02x\n",
260
fprintf(dbg_log, "fsmnt u_char[MAXMNTLEN] \"%s\"\n",
262
fprintf(dbg_log, "volname u_char[MAXVOLLEN] \"%s\"\n",
264
fprintf(dbg_log, "swuid u_int64_t 0x%08x%08x\n",
265
((unsigned int *)&(sb->fs_swuid))[1],
266
((unsigned int *)&(sb->fs_swuid))[0]);
268
fprintf(dbg_log, "pad int32_t 0x%08x\n",
271
fprintf(dbg_log, "cgrotor int32_t 0x%08x\n",
274
* struct csum[MAXCSBUFS] - is only maintained in memory
276
/* fprintf(dbg_log, " int32_t\n", sb->*fs_maxcluster);*/
277
fprintf(dbg_log, "old_cpc int32_t 0x%08x\n",
280
* int16_t fs_opostbl[16][8] - is dumped when used in dbg_dump_sptbl
282
fprintf(dbg_log, "maxbsize int32_t 0x%08x\n",
284
fprintf(dbg_log, "unrefs int64_t 0x%08x\n",
286
fprintf(dbg_log, "sblockloc int64_t 0x%08x%08x\n",
287
((unsigned int *)&(sb->fs_sblockloc))[1],
288
((unsigned int *)&(sb->fs_sblockloc))[0]);
290
dbg_dump_csum_total("internal cstotal", &sb->fs_cstotal);
292
fprintf(dbg_log, "time ufs_time_t %10u\n",
293
(unsigned int)sb->fs_time);
295
fprintf(dbg_log, "size int64_t 0x%08x%08x\n",
296
((unsigned int *)&(sb->fs_size))[1],
297
((unsigned int *)&(sb->fs_size))[0]);
298
fprintf(dbg_log, "dsize int64_t 0x%08x%08x\n",
299
((unsigned int *)&(sb->fs_dsize))[1],
300
((unsigned int *)&(sb->fs_dsize))[0]);
301
fprintf(dbg_log, "csaddr ufs2_daddr_t 0x%08x%08x\n",
302
((unsigned int *)&(sb->fs_csaddr))[1],
303
((unsigned int *)&(sb->fs_csaddr))[0]);
304
fprintf(dbg_log, "pendingblocks int64_t 0x%08x%08x\n",
305
((unsigned int *)&(sb->fs_pendingblocks))[1],
306
((unsigned int *)&(sb->fs_pendingblocks))[0]);
307
fprintf(dbg_log, "pendinginodes int32_t 0x%08x\n",
308
sb->fs_pendinginodes);
311
for(j=0; j<FSMAXSNAP; j++) {
312
fprintf(dbg_log, "snapinum int32_t[%2d] 0x%08x\n",
313
j, sb->fs_snapinum[j]);
314
if(!sb->fs_snapinum[j]) { /* list is dense */
318
#endif /* FSMAXSNAP */
319
fprintf(dbg_log, "avgfilesize int32_t 0x%08x\n",
321
fprintf(dbg_log, "avgfpdir int32_t 0x%08x\n",
323
fprintf(dbg_log, "save_cgsize int32_t 0x%08x\n",
325
fprintf(dbg_log, "flags int32_t 0x%08x\n",
327
fprintf(dbg_log, "contigsumsize int32_t 0x%08x\n",
328
sb->fs_contigsumsize);
329
fprintf(dbg_log, "maxsymlinklen int32_t 0x%08x\n",
330
sb->fs_maxsymlinklen);
331
fprintf(dbg_log, "old_inodefmt int32_t 0x%08x\n",
332
sb->fs_old_inodefmt);
333
fprintf(dbg_log, "maxfilesize u_int64_t 0x%08x%08x\n",
334
((unsigned int *)&(sb->fs_maxfilesize))[1],
335
((unsigned int *)&(sb->fs_maxfilesize))[0]);
336
fprintf(dbg_log, "qbmask int64_t 0x%08x%08x\n",
337
((unsigned int *)&(sb->fs_qbmask))[1],
338
((unsigned int *)&(sb->fs_qbmask))[0]);
339
fprintf(dbg_log, "qfmask int64_t 0x%08x%08x\n",
340
((unsigned int *)&(sb->fs_qfmask))[1],
341
((unsigned int *)&(sb->fs_qfmask))[0]);
342
fprintf(dbg_log, "state int32_t 0x%08x\n",
344
fprintf(dbg_log, "old_postblformat int32_t 0x%08x\n",
345
sb->fs_old_postblformat);
346
fprintf(dbg_log, "old_nrpos int32_t 0x%08x\n",
348
fprintf(dbg_log, "spare5 int32_t[2] 0x%08x 0x%08x\n",
349
sb->fs_spare5[0], sb->fs_spare5[1]);
350
fprintf(dbg_log, "magic int32_t 0x%08x\n",
354
fprintf(dbg_log, "===== END SUPERBLOCK =====\n");
359
/* ******************************************************* dbg_dump_cg ***** */
361
* Dump a cylinder group.
364
dbg_dump_cg(const char *comment, struct cg *cgr)
372
fprintf(dbg_log, "===== START CYLINDER GROUP =====\n");
373
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
376
fprintf(dbg_log, "magic int32_t 0x%08x\n", cgr->cg_magic);
377
fprintf(dbg_log, "old_time int32_t 0x%08x\n", cgr->cg_old_time);
378
fprintf(dbg_log, "cgx int32_t 0x%08x\n", cgr->cg_cgx);
379
fprintf(dbg_log, "old_ncyl int16_t 0x%04x\n", cgr->cg_old_ncyl);
380
fprintf(dbg_log, "old_niblk int16_t 0x%04x\n", cgr->cg_old_niblk);
381
fprintf(dbg_log, "ndblk int32_t 0x%08x\n", cgr->cg_ndblk);
382
dbg_dump_csum("internal cs", &cgr->cg_cs);
383
fprintf(dbg_log, "rotor int32_t 0x%08x\n", cgr->cg_rotor);
384
fprintf(dbg_log, "frotor int32_t 0x%08x\n", cgr->cg_frotor);
385
fprintf(dbg_log, "irotor int32_t 0x%08x\n", cgr->cg_irotor);
386
for(j=0; j<MAXFRAG; j++) {
387
fprintf(dbg_log, "frsum int32_t[%d] 0x%08x\n", j,
390
fprintf(dbg_log, "old_btotoff int32_t 0x%08x\n", cgr->cg_old_btotoff);
391
fprintf(dbg_log, "old_boff int32_t 0x%08x\n", cgr->cg_old_boff);
392
fprintf(dbg_log, "iusedoff int32_t 0x%08x\n", cgr->cg_iusedoff);
393
fprintf(dbg_log, "freeoff int32_t 0x%08x\n", cgr->cg_freeoff);
394
fprintf(dbg_log, "nextfreeoff int32_t 0x%08x\n",
395
cgr->cg_nextfreeoff);
396
fprintf(dbg_log, "clustersumoff int32_t 0x%08x\n",
397
cgr->cg_clustersumoff);
398
fprintf(dbg_log, "clusteroff int32_t 0x%08x\n",
400
fprintf(dbg_log, "nclusterblks int32_t 0x%08x\n",
401
cgr->cg_nclusterblks);
402
fprintf(dbg_log, "niblk int32_t 0x%08x\n", cgr->cg_niblk);
403
fprintf(dbg_log, "initediblk int32_t 0x%08x\n", cgr->cg_initediblk);
404
fprintf(dbg_log, "unrefs int32_t 0x%08x\n", cgr->cg_unrefs);
405
fprintf(dbg_log, "time ufs_time_t %10u\n",
406
(unsigned int)cgr->cg_initediblk);
409
fprintf(dbg_log, "===== END CYLINDER GROUP =====\n");
414
/* ***************************************************** dbg_dump_csum ***** */
416
* Dump a cylinder summary.
419
dbg_dump_csum(const char *comment, struct csum *cs)
426
fprintf(dbg_log, "===== START CYLINDER SUMMARY =====\n");
427
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
430
fprintf(dbg_log, "ndir int32_t 0x%08x\n", cs->cs_ndir);
431
fprintf(dbg_log, "nbfree int32_t 0x%08x\n", cs->cs_nbfree);
432
fprintf(dbg_log, "nifree int32_t 0x%08x\n", cs->cs_nifree);
433
fprintf(dbg_log, "nffree int32_t 0x%08x\n", cs->cs_nffree);
436
fprintf(dbg_log, "===== END CYLINDER SUMMARY =====\n");
441
/* ************************************************ dbg_dump_csum_total ***** */
443
* Dump a cylinder summary.
446
dbg_dump_csum_total(const char *comment, struct csum_total *cs)
453
fprintf(dbg_log, "===== START CYLINDER SUMMARY TOTAL =====\n");
454
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
457
fprintf(dbg_log, "ndir int64_t 0x%08x%08x\n",
458
((unsigned int *)&(cs->cs_ndir))[1],
459
((unsigned int *)&(cs->cs_ndir))[0]);
460
fprintf(dbg_log, "nbfree int64_t 0x%08x%08x\n",
461
((unsigned int *)&(cs->cs_nbfree))[1],
462
((unsigned int *)&(cs->cs_nbfree))[0]);
463
fprintf(dbg_log, "nifree int64_t 0x%08x%08x\n",
464
((unsigned int *)&(cs->cs_nifree))[1],
465
((unsigned int *)&(cs->cs_nifree))[0]);
466
fprintf(dbg_log, "nffree int64_t 0x%08x%08x\n",
467
((unsigned int *)&(cs->cs_nffree))[1],
468
((unsigned int *)&(cs->cs_nffree))[0]);
469
fprintf(dbg_log, "numclusters int64_t 0x%08x%08x\n",
470
((unsigned int *)&(cs->cs_numclusters))[1],
471
((unsigned int *)&(cs->cs_numclusters))[0]);
474
fprintf(dbg_log, "===== END CYLINDER SUMMARY TOTAL =====\n");
478
/* **************************************************** dbg_dump_inmap ***** */
480
* Dump the inode allocation map in one cylinder group.
483
dbg_dump_inmap(struct fs *sb, const char *comment, struct cg *cgr)
492
fprintf(dbg_log, "===== START INODE ALLOCATION MAP =====\n");
493
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
496
cp=(unsigned char *)cg_inosused(cgr);
498
for(j=0; j<e; j+=32) {
499
fprintf(dbg_log, "%08x: ", j);
500
for(k=0; k<32; k+=8) {
503
"%02x%02x%02x%02x%02x%02x%02x%02x ",
504
cp[0], cp[1], cp[2], cp[3],
505
cp[4], cp[5], cp[6], cp[7]);
507
for(l=0; (l<8)&&(j+k+l<e); l++) {
508
fprintf(dbg_log, "%02x", cp[l]);
513
fprintf(dbg_log, "\n");
517
fprintf(dbg_log, "===== END INODE ALLOCATION MAP =====\n");
523
/* **************************************************** dbg_dump_frmap ***** */
525
* Dump the fragment allocation map in one cylinder group.
528
dbg_dump_frmap(struct fs *sb, const char *comment, struct cg *cgr)
537
fprintf(dbg_log, "===== START FRAGMENT ALLOCATION MAP =====\n");
538
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
541
cp=(unsigned char *)cg_blksfree(cgr);
543
e=howmany((sb->fs_old_cpg * sb->fs_old_spc / sb->fs_old_nspf), CHAR_BIT);
546
for(j=0; j<e; j+=32) {
547
fprintf(dbg_log, "%08x: ", j);
548
for(k=0; k<32; k+=8) {
551
"%02x%02x%02x%02x%02x%02x%02x%02x ",
552
cp[0], cp[1], cp[2], cp[3],
553
cp[4], cp[5], cp[6], cp[7]);
555
for(l=0; (l<8)&&(j+k+l<e); l++) {
556
fprintf(dbg_log, "%02x", cp[l]);
561
fprintf(dbg_log, "\n");
565
fprintf(dbg_log, "===== END FRAGMENT ALLOCATION MAP =====\n");
570
/* **************************************************** dbg_dump_clmap ***** */
572
* Dump the cluster allocation map in one cylinder group.
575
dbg_dump_clmap(struct fs *sb, const char *comment, struct cg *cgr)
584
fprintf(dbg_log, "===== START CLUSTER ALLOCATION MAP =====\n");
585
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
588
cp=(unsigned char *)cg_clustersfree(cgr);
590
e=howmany(sb->fs_old_cpg * sb->fs_old_spc / (sb->fs_old_nspf << sb->fs_fragshift), CHAR_BIT);
593
for(j=0; j<e; j+=32) {
594
fprintf(dbg_log, "%08x: ", j);
595
for(k=0; k<32; k+=8) {
598
"%02x%02x%02x%02x%02x%02x%02x%02x ",
599
cp[0], cp[1], cp[2], cp[3],
600
cp[4], cp[5], cp[6], cp[7]);
602
for(l=0; (l<8)&&(j+k+l<e); l++) {
603
fprintf(dbg_log, "%02x", cp[l]);
608
fprintf(dbg_log, "\n");
612
fprintf(dbg_log, "===== END CLUSTER ALLOCATION MAP =====\n");
617
/* **************************************************** dbg_dump_clsum ***** */
619
* Dump the cluster availability summary of one cylinder group.
622
dbg_dump_clsum(struct fs *sb, const char *comment, struct cg *cgr)
631
fprintf(dbg_log, "===== START CLUSTER SUMMARY =====\n");
632
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
635
ip=(int *)cg_clustersum(cgr);
636
for(j=0; j<=sb->fs_contigsumsize; j++) {
637
fprintf(dbg_log, "%02d: %8d\n", j, *ip++);
641
fprintf(dbg_log, "===== END CLUSTER SUMMARY =====\n");
648
* This code dates from before the UFS2 integration, and doesn't compile
649
* post-UFS2 due to the use of cg_blks(). I'm not sure how best to update
650
* this for UFS2, where the rotational bits of UFS no longer apply, so
651
* will leave it disabled for now; it should probably be re-enabled
652
* specifically for UFS1.
654
/* **************************************************** dbg_dump_sptbl ***** */
656
* Dump the block summary, and the rotational layout table.
659
dbg_dump_sptbl(struct fs *sb, const char *comment, struct cg *cgr)
669
"===== START BLOCK SUMMARY AND POSITION TABLE =====\n");
670
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
673
ip=(int *)cg_blktot(cgr);
674
for(j=0; j<sb->fs_old_cpg; j++) {
675
fprintf(dbg_log, "%2d: %5d = ", j, *ip++);
676
for(k=0; k<sb->fs_old_nrpos; k++) {
677
fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]);
678
if(k<sb->fs_old_nrpos-1) {
679
fprintf(dbg_log, " + ");
682
fprintf(dbg_log, "\n");
686
fprintf(dbg_log, "===== END BLOCK SUMMARY AND POSITION TABLE =====\n");
692
/* ************************************************** dbg_dump_ufs1_ino ***** */
694
* Dump a UFS1 inode structure.
697
dbg_dump_ufs1_ino(struct fs *sb, const char *comment, struct ufs1_dinode *ino)
700
int remaining_blocks;
706
fprintf(dbg_log, "===== START UFS1 INODE DUMP =====\n");
707
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
710
fprintf(dbg_log, "mode u_int16_t 0%o\n", ino->di_mode);
711
fprintf(dbg_log, "nlink int16_t 0x%04x\n", ino->di_nlink);
712
fprintf(dbg_log, "size u_int64_t 0x%08x%08x\n",
713
((unsigned int *)&(ino->di_size))[1],
714
((unsigned int *)&(ino->di_size))[0]);
715
fprintf(dbg_log, "atime int32_t 0x%08x\n", ino->di_atime);
716
fprintf(dbg_log, "atimensec int32_t 0x%08x\n",
718
fprintf(dbg_log, "mtime int32_t 0x%08x\n",
720
fprintf(dbg_log, "mtimensec int32_t 0x%08x\n",
722
fprintf(dbg_log, "ctime int32_t 0x%08x\n", ino->di_ctime);
723
fprintf(dbg_log, "ctimensec int32_t 0x%08x\n",
726
remaining_blocks=howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
727
for(ictr=0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
728
fprintf(dbg_log, "db ufs_daddr_t[%x] 0x%08x\n", ictr,
731
remaining_blocks-=NDADDR;
732
if(remaining_blocks>0) {
733
fprintf(dbg_log, "ib ufs_daddr_t[0] 0x%08x\n",
736
remaining_blocks-=howmany(sb->fs_bsize, sizeof(ufs1_daddr_t));
737
if(remaining_blocks>0) {
738
fprintf(dbg_log, "ib ufs_daddr_t[1] 0x%08x\n",
741
#define SQUARE(a) ((a)*(a))
742
remaining_blocks-=SQUARE(howmany(sb->fs_bsize, sizeof(ufs1_daddr_t)));
744
if(remaining_blocks>0) {
745
fprintf(dbg_log, "ib ufs_daddr_t[2] 0x%08x\n",
749
fprintf(dbg_log, "flags u_int32_t 0x%08x\n", ino->di_flags);
750
fprintf(dbg_log, "blocks int32_t 0x%08x\n", ino->di_blocks);
751
fprintf(dbg_log, "gen int32_t 0x%08x\n", ino->di_gen);
752
fprintf(dbg_log, "uid u_int32_t 0x%08x\n", ino->di_uid);
753
fprintf(dbg_log, "gid u_int32_t 0x%08x\n", ino->di_gid);
756
fprintf(dbg_log, "===== END UFS1 INODE DUMP =====\n");
761
/* ************************************************** dbg_dump_ufs2_ino ***** */
763
* Dump a UFS2 inode structure.
766
dbg_dump_ufs2_ino(struct fs *sb, const char *comment, struct ufs2_dinode *ino)
769
int remaining_blocks;
775
fprintf(dbg_log, "===== START UFS2 INODE DUMP =====\n");
776
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
779
fprintf(dbg_log, "mode u_int16_t 0%o\n", ino->di_mode);
780
fprintf(dbg_log, "nlink int16_t 0x%04x\n", ino->di_nlink);
781
fprintf(dbg_log, "uid u_int32_t 0x%08x\n", ino->di_uid);
782
fprintf(dbg_log, "gid u_int32_t 0x%08x\n", ino->di_gid);
783
fprintf(dbg_log, "blksize u_int32_t 0x%08x\n", ino->di_blksize);
784
fprintf(dbg_log, "size u_int64_t 0x%08x%08x\n",
785
((unsigned int *)&(ino->di_size))[1],
786
((unsigned int *)&(ino->di_size))[0]);
787
fprintf(dbg_log, "blocks u_int64_t 0x%08x%08x\n",
788
((unsigned int *)&(ino->di_blocks))[1],
789
((unsigned int *)&(ino->di_blocks))[0]);
790
fprintf(dbg_log, "atime ufs_time_t %10jd\n", ino->di_atime);
791
fprintf(dbg_log, "mtime ufs_time_t %10jd\n", ino->di_mtime);
792
fprintf(dbg_log, "ctime ufs_time_t %10jd\n", ino->di_ctime);
793
fprintf(dbg_log, "birthtime ufs_time_t %10jd\n", ino->di_birthtime);
794
fprintf(dbg_log, "mtimensec int32_t 0x%08x\n", ino->di_mtimensec);
795
fprintf(dbg_log, "atimensec int32_t 0x%08x\n", ino->di_atimensec);
796
fprintf(dbg_log, "ctimensec int32_t 0x%08x\n", ino->di_ctimensec);
797
fprintf(dbg_log, "birthnsec int32_t 0x%08x\n", ino->di_birthnsec);
798
fprintf(dbg_log, "gen int32_t 0x%08x\n", ino->di_gen);
799
fprintf(dbg_log, "kernflags u_int32_t 0x%08x\n", ino->di_kernflags);
800
fprintf(dbg_log, "flags u_int32_t 0x%08x\n", ino->di_flags);
801
fprintf(dbg_log, "extsize int32_t 0x%08x\n", ino->di_extsize);
803
/* XXX: What do we do with di_extb[NXADDR]? */
805
remaining_blocks=howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
806
for(ictr=0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
807
fprintf(dbg_log, "db ufs2_daddr_t[%x] 0x%16jx\n", ictr,
810
remaining_blocks-=NDADDR;
811
if(remaining_blocks>0) {
812
fprintf(dbg_log, "ib ufs2_daddr_t[0] 0x%16jx\n",
815
remaining_blocks-=howmany(sb->fs_bsize, sizeof(ufs2_daddr_t));
816
if(remaining_blocks>0) {
817
fprintf(dbg_log, "ib ufs2_daddr_t[1] 0x%16jx\n",
820
#define SQUARE(a) ((a)*(a))
821
remaining_blocks-=SQUARE(howmany(sb->fs_bsize, sizeof(ufs2_daddr_t)));
823
if(remaining_blocks>0) {
824
fprintf(dbg_log, "ib ufs2_daddr_t[2] 0x%16jx\n",
829
fprintf(dbg_log, "===== END UFS2 INODE DUMP =====\n");
834
/* ***************************************************** dbg_dump_iblk ***** */
836
* Dump an indirect block. The iteration to dump a full file has to be
840
dbg_dump_iblk(struct fs *sb, const char *comment, char *block, size_t length)
842
unsigned int *mem, i, j, size;
848
fprintf(dbg_log, "===== START INDIRECT BLOCK DUMP =====\n");
849
fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)block,
853
if (sb->fs_magic == FS_UFS1_MAGIC)
854
size = sizeof(ufs1_daddr_t);
856
size = sizeof(ufs2_daddr_t);
858
mem=(unsigned int *)block;
859
for (i=0; (size_t)i<MIN(howmany(sb->fs_bsize, size),
861
fprintf(dbg_log, "%04x: ", i);
862
for (j=0; j<8; j++) {
863
if((size_t)(i+j)<length) {
864
fprintf(dbg_log, "%08X ", *mem++);
867
fprintf(dbg_log, "\n");
871
fprintf(dbg_log, "===== END INDIRECT BLOCK DUMP =====\n");
876
#endif /* FS_DEBUG */