GC !__DragonFly__ section.
[dragonfly.git] / sbin / growfs / debug.c
CommitLineData
984263bc
MD
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 $
38a690d7 40 * $DragonFly: src/sbin/growfs/debug.c,v 1.3 2003/08/08 04:18:38 dillon Exp $
984263bc 41 *
1de703da 42 * $FreeBSD: src/sbin/growfs/debug.c,v 1.3.2.1 2001/07/16 15:02:13 tomsoft Exp $
984263bc
MD
43 */
44
984263bc
MD
45/* ********************************************************** INCLUDES ***** */
46#include <sys/param.h>
47
48#include <stdio.h>
38a690d7
MD
49#include <vfs/ufs/dinode.h>
50#include <vfs/ufs/fs.h>
984263bc
MD
51
52#include "debug.h"
53
54#ifdef FS_DEBUG
55
56/* *********************************************************** GLOBALS ***** */
57static FILE *dbg_log=NULL;
58static 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 */
68void
69dbg_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 */
81void
82dbg_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 */
97void
98dbg_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 */
127void
128dbg_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 */
316void
317dbg_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 */
367void
368dbg_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 */
394void
395dbg_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 */
439void
440dbg_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 */
483void
484dbg_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 */
527void
528dbg_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 */
556void
557dbg_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 */
593void
594dbg_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 */
663void
664dbg_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