?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fsck_msdosfs: check next cluster index for validity before using it
[dragonfly.git] / sbin / growfs / debug.c
bloba58bce094965e3bed6765581854afc1f6cd7b873
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
DragonFly BSD