← Back to branch summary

~ubuntu-branches/debian/jessie/ufsutils/jessie

« back to all changes in this revision

Viewing changes to sbin/growfs/debug.c

  • Committer: Package Import Robot
  • Author(s): Robert Millan
  • Date: 2013-11-29 14:21:12 UTC
  • mfrom: (11.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20131129142112-5tz5g7a4b6prb0dt
Tags: 9.2-2
* Avoid kfreebsd-kernel-headers versions prior to ino_t fix.
* Remove gratuitous dependency on libtermcap / libtinfo.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sbin/growfs/debug.c
44
44
  "$FreeBSD$";
45
45
#endif /* not lint */
46
46
 
47
 
/* ********************************************************** INCLUDES ***** */
48
47
#include <sys/param.h>
49
48
 
50
49
#include <limits.h>
57
56
 
58
57
#ifdef FS_DEBUG
59
58
 
60
 
/* *********************************************************** GLOBALS ***** */
61
 
static FILE     *dbg_log=NULL;
62
 
static unsigned int     indent=0;
 
59
static FILE             *dbg_log = NULL;
 
60
static unsigned int     indent = 0;
63
61
 
64
62
/*
65
63
 * prototypes not done here, as they come with debug.h
66
64
 */
67
65
 
68
 
/* ********************************************************** dbg_open ***** */
69
66
/*
70
67
 * Open the filehandle where all debug output has to go.
71
68
 */
74
71
{
75
72
 
76
73
        if (strcmp(fn, "-") == 0)
77
 
                dbg_log=fopen("/dev/stdout", "a");
 
74
                dbg_log = fopen("/dev/stdout", "a");
78
75
        else
79
 
                dbg_log=fopen(fn, "a");
 
76
                dbg_log = fopen(fn, "a");
80
77
 
81
78
        return;
82
79
}
83
80
 
84
 
/* ********************************************************* dbg_close ***** */
85
81
/*
86
82
 * Close the filehandle where all debug output went to.
87
83
 */
89
85
dbg_close(void)
90
86
{
91
87
 
92
 
        if(dbg_log) {
 
88
        if (dbg_log) {
93
89
                fclose(dbg_log);
94
 
                dbg_log=NULL;
 
90
                dbg_log = NULL;
95
91
        }
96
92
 
97
93
        return;
98
94
}
99
95
 
100
 
/* ****************************************************** dbg_dump_hex ***** */
101
96
/*
102
97
 * Dump out a full file system block in hex.
103
98
 */
106
101
{
107
102
        int i, j, k;
108
103
 
109
 
        if(!dbg_log) {
 
104
        if (!dbg_log)
110
105
                return;
111
 
        }
 
106
 
112
107
        fprintf(dbg_log, "===== START HEXDUMP =====\n");
113
108
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)mem, comment);
114
109
        indent++;
115
 
        for (i=0; i<sb->fs_bsize; i+=24) {
116
 
                for (j=0; j<3; j++) {
117
 
                        for (k=0; k<8; k++) {
 
110
        for (i = 0; i < sb->fs_bsize; i += 24) {
 
111
                for (j = 0; j < 3; j++) {
 
112
                        for (k = 0; k < 8; k++)
118
113
                                fprintf(dbg_log, "%02x ", *mem++);
119
 
                        }
120
114
                        fprintf(dbg_log, "  ");
121
115
                }
122
116
                fprintf(dbg_log, "\n");
127
121
        return;
128
122
}
129
123
 
130
 
/* ******************************************************* dbg_dump_fs ***** */
131
124
/*
132
125
 * Dump the superblock.
133
126
 */
134
127
void
135
128
dbg_dump_fs(struct fs *sb, const char *comment)
136
129
{
137
 
#ifdef FSMAXSNAP
138
 
        int     j;
139
 
#endif /* FSMAXSNAP */
 
130
        int j;
140
131
 
141
 
        if(!dbg_log) {
 
132
        if (!dbg_log)
142
133
                return;
143
 
        }
144
134
 
145
135
        fprintf(dbg_log, "===== START SUPERBLOCK =====\n");
146
136
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)sb, comment);
281
271
 */
282
272
        fprintf(dbg_log, "maxbsize          int32_t          0x%08x\n",
283
273
            sb->fs_maxbsize);
284
 
        fprintf(dbg_log, "unrefs            int64_t          0x%08x\n",
 
274
        fprintf(dbg_log, "unrefs            int64_t          0x%08jx\n",
285
275
            sb->fs_unrefs);
286
276
        fprintf(dbg_log, "sblockloc         int64_t          0x%08x%08x\n",
287
277
                ((unsigned int *)&(sb->fs_sblockloc))[1],
307
297
        fprintf(dbg_log, "pendinginodes     int32_t          0x%08x\n",
308
298
            sb->fs_pendinginodes);
309
299
 
310
 
#ifdef FSMAXSNAP
311
 
        for(j=0; j<FSMAXSNAP; j++) {
 
300
        for (j = 0; j < FSMAXSNAP; j++) {
312
301
                fprintf(dbg_log, "snapinum          int32_t[%2d]      0x%08x\n",
313
302
                    j, sb->fs_snapinum[j]);
314
 
                if(!sb->fs_snapinum[j]) { /* list is dense */
 
303
                if (!sb->fs_snapinum[j]) { /* list is dense */
315
304
                        break;
316
305
                }
317
306
        }
318
 
#endif /* FSMAXSNAP */
319
307
        fprintf(dbg_log, "avgfilesize       int32_t          0x%08x\n",
320
308
            sb->fs_avgfilesize);
321
309
        fprintf(dbg_log, "avgfpdir          int32_t          0x%08x\n",
356
344
        return;
357
345
}
358
346
 
359
 
/* ******************************************************* dbg_dump_cg ***** */
360
347
/*
361
348
 * Dump a cylinder group.
362
349
 */
365
352
{
366
353
        int j;
367
354
 
368
 
        if(!dbg_log) {
 
355
        if (!dbg_log)
369
356
                return;
370
 
        }
371
357
 
372
358
        fprintf(dbg_log, "===== START CYLINDER GROUP =====\n");
373
359
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
383
369
        fprintf(dbg_log, "rotor         int32_t    0x%08x\n", cgr->cg_rotor);
384
370
        fprintf(dbg_log, "frotor        int32_t    0x%08x\n", cgr->cg_frotor);
385
371
        fprintf(dbg_log, "irotor        int32_t    0x%08x\n", cgr->cg_irotor);
386
 
        for(j=0; j<MAXFRAG; j++) {
 
372
        for (j = 0; j < MAXFRAG; j++) {
387
373
                fprintf(dbg_log, "frsum         int32_t[%d] 0x%08x\n", j,
388
374
                    cgr->cg_frsum[j]);
389
375
        }
411
397
        return;
412
398
}
413
399
 
414
 
/* ***************************************************** dbg_dump_csum ***** */
415
400
/*
416
401
 * Dump a cylinder summary.
417
402
 */
419
404
dbg_dump_csum(const char *comment, struct csum *cs)
420
405
{
421
406
 
422
 
        if(!dbg_log) {
 
407
        if (!dbg_log)
423
408
                return;
424
 
        }
425
409
 
426
410
        fprintf(dbg_log, "===== START CYLINDER SUMMARY =====\n");
427
411
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
438
422
        return;
439
423
}
440
424
 
441
 
/* ************************************************ dbg_dump_csum_total ***** */
442
425
/*
443
426
 * Dump a cylinder summary.
444
427
 */
446
429
dbg_dump_csum_total(const char *comment, struct csum_total *cs)
447
430
{
448
431
 
449
 
        if(!dbg_log) {
 
432
        if (!dbg_log)
450
433
                return;
451
 
        }
452
434
 
453
435
        fprintf(dbg_log, "===== START CYLINDER SUMMARY TOTAL =====\n");
454
436
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cs, comment);
475
457
 
476
458
        return;
477
459
}
478
 
/* **************************************************** dbg_dump_inmap ***** */
479
460
/*
480
461
 * Dump the inode allocation map in one cylinder group.
481
462
 */
485
466
        int j,k,l,e;
486
467
        unsigned char *cp;
487
468
 
488
 
        if(!dbg_log) {
 
469
        if (!dbg_log)
489
470
                return;
490
 
        }
491
471
 
492
472
        fprintf(dbg_log, "===== START INODE ALLOCATION MAP =====\n");
493
473
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
494
474
        indent++;
495
475
 
496
 
        cp=(unsigned char *)cg_inosused(cgr);
497
 
        e=sb->fs_ipg/8;
498
 
        for(j=0; j<e; j+=32) {
 
476
        cp = (unsigned char *)cg_inosused(cgr);
 
477
        e = sb->fs_ipg / 8;
 
478
        for (j = 0; j < e; j += 32) {
499
479
                fprintf(dbg_log, "%08x: ", j);
500
 
                for(k=0; k<32; k+=8) {
501
 
                        if(j+k+8<e) {
 
480
                for (k = 0; k < 32; k += 8) {
 
481
                        if (j + k + 8 < e) {
502
482
                                fprintf(dbg_log,
503
483
                                    "%02x%02x%02x%02x%02x%02x%02x%02x ", 
504
484
                                    cp[0], cp[1], cp[2], cp[3],
505
485
                                    cp[4], cp[5], cp[6], cp[7]);
506
486
                        } else {
507
 
                                for(l=0; (l<8)&&(j+k+l<e); l++) {
 
487
                                for (l = 0; (l < 8) && (j + k + l < e); l++) {
508
488
                                        fprintf(dbg_log, "%02x", cp[l]);
509
489
                                }
510
490
                        }
511
 
                        cp+=8;
 
491
                        cp += 8;
512
492
                }
513
493
                fprintf(dbg_log, "\n");
514
494
        }
520
500
}
521
501
 
522
502
 
523
 
/* **************************************************** dbg_dump_frmap ***** */
524
503
/*
525
504
 * Dump the fragment allocation map in one cylinder group.
526
505
 */
530
509
        int j,k,l,e;
531
510
        unsigned char *cp;
532
511
 
533
 
        if(!dbg_log) {
 
512
        if (!dbg_log)
534
513
                return;
535
 
        }
536
514
 
537
515
        fprintf(dbg_log, "===== START FRAGMENT ALLOCATION MAP =====\n");
538
516
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
539
517
        indent++;
540
518
 
541
 
        cp=(unsigned char *)cg_blksfree(cgr);
 
519
        cp = (unsigned char *)cg_blksfree(cgr);
542
520
        if (sb->fs_old_nspf)
543
 
                e=howmany((sb->fs_old_cpg * sb->fs_old_spc / sb->fs_old_nspf), CHAR_BIT);
 
521
                e = howmany((sb->fs_old_cpg * sb->fs_old_spc / sb->fs_old_nspf), CHAR_BIT);
544
522
        else
545
523
                e = 0;
546
 
        for(j=0; j<e; j+=32) {
 
524
        for (j = 0; j < e; j += 32) {
547
525
                fprintf(dbg_log, "%08x: ", j);
548
 
                for(k=0; k<32; k+=8) {
549
 
                        if(j+k+8<e) {
 
526
                for (k = 0; k < 32; k += 8) {
 
527
                        if (j + k + 8 <e) {
550
528
                                fprintf(dbg_log,
551
529
                                    "%02x%02x%02x%02x%02x%02x%02x%02x ", 
552
530
                                    cp[0], cp[1], cp[2], cp[3],
553
531
                                    cp[4], cp[5], cp[6], cp[7]);
554
532
                        } else {
555
 
                                for(l=0; (l<8)&&(j+k+l<e); l++) {
 
533
                                for (l = 0; (l < 8) && (j + k + l < e); l++) {
556
534
                                        fprintf(dbg_log, "%02x", cp[l]);
557
535
                                }
558
536
                        }
559
 
                        cp+=8;
 
537
                        cp += 8;
560
538
                }
561
539
                fprintf(dbg_log, "\n");
562
540
        }
567
545
        return;
568
546
}
569
547
 
570
 
/* **************************************************** dbg_dump_clmap ***** */
571
548
/*
572
549
 * Dump the cluster allocation map in one cylinder group.
573
550
 */
577
554
        int j,k,l,e;
578
555
        unsigned char *cp;
579
556
 
580
 
        if(!dbg_log) {
 
557
        if (!dbg_log)
581
558
                return;
582
 
        }
583
559
 
584
560
        fprintf(dbg_log, "===== START CLUSTER ALLOCATION MAP =====\n");
585
561
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
586
562
        indent++;
587
563
 
588
 
        cp=(unsigned char *)cg_clustersfree(cgr);
 
564
        cp = (unsigned char *)cg_clustersfree(cgr);
589
565
        if (sb->fs_old_nspf)
590
 
                e=howmany(sb->fs_old_cpg * sb->fs_old_spc / (sb->fs_old_nspf << sb->fs_fragshift), CHAR_BIT);
 
566
                e = howmany(sb->fs_old_cpg * sb->fs_old_spc / (sb->fs_old_nspf << sb->fs_fragshift), CHAR_BIT);
591
567
        else
592
568
                e = 0;
593
 
        for(j=0; j<e; j+=32) {
 
569
        for (j = 0; j < e; j += 32) {
594
570
                fprintf(dbg_log, "%08x: ", j);
595
 
                for(k=0; k<32; k+=8) {
596
 
                        if(j+k+8<e) {
 
571
                for (k = 0; k < 32; k += 8) {
 
572
                        if (j + k + 8 < e) {
597
573
                                fprintf(dbg_log,
598
574
                                    "%02x%02x%02x%02x%02x%02x%02x%02x ", 
599
575
                                    cp[0], cp[1], cp[2], cp[3],
600
576
                                    cp[4], cp[5], cp[6], cp[7]);
601
577
                        } else {
602
 
                                for(l=0; (l<8)&&(j+k+l<e); l++) {
 
578
                                for (l = 0; (l < 8) && (j + k + l <e); l++) {
603
579
                                        fprintf(dbg_log, "%02x", cp[l]);
604
580
                                }
605
581
                        }
606
 
                        cp+=8;
 
582
                        cp += 8;
607
583
                }
608
584
                fprintf(dbg_log, "\n");
609
585
        }
614
590
        return;
615
591
}
616
592
 
617
 
/* **************************************************** dbg_dump_clsum ***** */
618
593
/*
619
594
 * Dump the cluster availability summary of one cylinder group.
620
595
 */
624
599
        int j;
625
600
        int *ip;
626
601
 
627
 
        if(!dbg_log) {
 
602
        if (!dbg_log)
628
603
                return;
629
 
        }
630
604
 
631
605
        fprintf(dbg_log, "===== START CLUSTER SUMMARY =====\n");
632
606
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
633
607
        indent++;
634
608
 
635
 
        ip=(int *)cg_clustersum(cgr);
636
 
        for(j=0; j<=sb->fs_contigsumsize; j++) {
 
609
        ip = (int *)cg_clustersum(cgr);
 
610
        for (j = 0; j <= sb->fs_contigsumsize; j++) {
637
611
                fprintf(dbg_log, "%02d: %8d\n", j, *ip++);
638
612
        }
639
613
 
651
625
 * will leave it disabled for now; it should probably be re-enabled
652
626
 * specifically for UFS1.
653
627
 */
654
 
/* **************************************************** dbg_dump_sptbl ***** */
655
628
/*
656
629
 * Dump the block summary, and the rotational layout table.
657
630
 */
661
634
        int j,k;
662
635
        int *ip;
663
636
 
664
 
        if(!dbg_log) {
 
637
        if (!dbg_log)
665
638
                return;
666
 
        }
667
639
 
668
640
        fprintf(dbg_log,
669
641
            "===== START BLOCK SUMMARY AND POSITION TABLE =====\n");
670
642
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)cgr, comment);
671
643
        indent++;
672
644
 
673
 
        ip=(int *)cg_blktot(cgr);
674
 
        for(j=0; j<sb->fs_old_cpg; j++) {
 
645
        ip = (int *)cg_blktot(cgr);
 
646
        for (j = 0; j < sb->fs_old_cpg; j++) {
675
647
                fprintf(dbg_log, "%2d: %5d = ", j, *ip++);
676
 
                for(k=0; k<sb->fs_old_nrpos; k++) {
 
648
                for (k = 0; k < sb->fs_old_nrpos; k++) {
677
649
                        fprintf(dbg_log, "%4d", cg_blks(sb, cgr, j)[k]);
678
 
                        if(k<sb->fs_old_nrpos-1) {
 
650
                        if (k < sb->fs_old_nrpos - 1)
679
651
                                fprintf(dbg_log, " + ");
680
 
                        }
681
652
                }
682
653
                fprintf(dbg_log, "\n");
683
654
        }
689
660
}
690
661
#endif
691
662
 
692
 
/* ************************************************** dbg_dump_ufs1_ino ***** */
693
663
/*
694
664
 * Dump a UFS1 inode structure.
695
665
 */
699
669
        int ictr;
700
670
        int remaining_blocks;
701
671
        
702
 
        if(!dbg_log) {
 
672
        if (!dbg_log)
703
673
                return;
704
 
        }
705
674
 
706
675
        fprintf(dbg_log, "===== START UFS1 INODE DUMP =====\n");
707
676
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
723
692
        fprintf(dbg_log, "ctimensec  int32_t        0x%08x\n",
724
693
            ino->di_ctimensec);
725
694
 
726
 
        remaining_blocks=howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
727
 
        for(ictr=0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
 
695
        remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
 
696
        for (ictr = 0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
728
697
                fprintf(dbg_log, "db         ufs_daddr_t[%x] 0x%08x\n", ictr,
729
698
                    ino->di_db[ictr]);
730
699
        }
731
 
        remaining_blocks-=NDADDR;
732
 
        if(remaining_blocks>0) {
 
700
        remaining_blocks -= NDADDR;
 
701
        if (remaining_blocks > 0) {
733
702
                fprintf(dbg_log, "ib         ufs_daddr_t[0] 0x%08x\n",
734
703
                    ino->di_ib[0]);
735
704
        }
736
 
        remaining_blocks-=howmany(sb->fs_bsize, sizeof(ufs1_daddr_t));
737
 
        if(remaining_blocks>0) {
 
705
        remaining_blocks -= howmany(sb->fs_bsize, sizeof(ufs1_daddr_t));
 
706
        if (remaining_blocks > 0) {
738
707
                fprintf(dbg_log, "ib         ufs_daddr_t[1] 0x%08x\n",
739
708
                    ino->di_ib[1]);
740
709
        }
741
 
#define SQUARE(a) ((a)*(a))
742
 
        remaining_blocks-=SQUARE(howmany(sb->fs_bsize, sizeof(ufs1_daddr_t)));
 
710
#define SQUARE(a) ((a) * (a))
 
711
        remaining_blocks -= SQUARE(howmany(sb->fs_bsize, sizeof(ufs1_daddr_t)));
743
712
#undef SQUARE
744
 
        if(remaining_blocks>0) {
 
713
        if (remaining_blocks > 0) {
745
714
                fprintf(dbg_log, "ib         ufs_daddr_t[2] 0x%08x\n",
746
715
                    ino->di_ib[2]);
747
716
        }
758
727
        return;
759
728
}
760
729
 
761
 
/* ************************************************** dbg_dump_ufs2_ino ***** */
762
730
/*
763
731
 * Dump a UFS2 inode structure.
764
732
 */
768
736
        int ictr;
769
737
        int remaining_blocks;
770
738
        
771
 
        if(!dbg_log) {
 
739
        if (!dbg_log)
772
740
                return;
773
 
        }
774
741
 
775
742
        fprintf(dbg_log, "===== START UFS2 INODE DUMP =====\n");
776
743
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)ino, comment);
785
752
            ((unsigned int *)&(ino->di_size))[1],
786
753
            ((unsigned int *)&(ino->di_size))[0]);
787
754
        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]);
 
755
            ((unsigned int *)&(ino->di_blocks))[1],
 
756
            ((unsigned int *)&(ino->di_blocks))[0]);
790
757
        fprintf(dbg_log, "atime      ufs_time_t     %10jd\n", ino->di_atime);
791
758
        fprintf(dbg_log, "mtime      ufs_time_t     %10jd\n", ino->di_mtime);
792
759
        fprintf(dbg_log, "ctime      ufs_time_t     %10jd\n", ino->di_ctime);
802
769
 
803
770
        /* XXX: What do we do with di_extb[NXADDR]? */
804
771
 
805
 
        remaining_blocks=howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
806
 
        for(ictr=0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
 
772
        remaining_blocks = howmany(ino->di_size, sb->fs_bsize); /* XXX ts - +1? */
 
773
        for (ictr = 0; ictr < MIN(NDADDR, remaining_blocks); ictr++) {
807
774
                fprintf(dbg_log, "db         ufs2_daddr_t[%x] 0x%16jx\n", ictr,
808
775
                    ino->di_db[ictr]);
809
776
        }
810
 
        remaining_blocks-=NDADDR;
811
 
        if(remaining_blocks>0) {
 
777
        remaining_blocks -= NDADDR;
 
778
        if (remaining_blocks > 0) {
812
779
                fprintf(dbg_log, "ib         ufs2_daddr_t[0] 0x%16jx\n",
813
780
                    ino->di_ib[0]);
814
781
        }
815
 
        remaining_blocks-=howmany(sb->fs_bsize, sizeof(ufs2_daddr_t));
816
 
        if(remaining_blocks>0) {
 
782
        remaining_blocks -= howmany(sb->fs_bsize, sizeof(ufs2_daddr_t));
 
783
        if (remaining_blocks > 0) {
817
784
                fprintf(dbg_log, "ib         ufs2_daddr_t[1] 0x%16jx\n",
818
785
                    ino->di_ib[1]);
819
786
        }
820
 
#define SQUARE(a) ((a)*(a))
821
 
        remaining_blocks-=SQUARE(howmany(sb->fs_bsize, sizeof(ufs2_daddr_t)));
 
787
#define SQUARE(a) ((a) * (a))
 
788
        remaining_blocks -= SQUARE(howmany(sb->fs_bsize, sizeof(ufs2_daddr_t)));
822
789
#undef SQUARE
823
 
        if(remaining_blocks>0) {
 
790
        if (remaining_blocks > 0) {
824
791
                fprintf(dbg_log, "ib         ufs2_daddr_t[2] 0x%16jx\n",
825
792
                    ino->di_ib[2]);
826
793
        }
831
798
        return;
832
799
}
833
800
 
834
 
/* ***************************************************** dbg_dump_iblk ***** */
835
801
/*
836
802
 * Dump an indirect block. The iteration to dump a full file has to be
837
803
 * written around.
841
807
{
842
808
        unsigned int *mem, i, j, size;
843
809
 
844
 
        if(!dbg_log) {
 
810
        if (!dbg_log)
845
811
                return;
846
 
        }
847
812
 
848
813
        fprintf(dbg_log, "===== START INDIRECT BLOCK DUMP =====\n");
849
814
        fprintf(dbg_log, "# %d@%lx: %s\n", indent, (unsigned long)block,
855
820
        else
856
821
                size = sizeof(ufs2_daddr_t);
857
822
 
858
 
        mem=(unsigned int *)block;
859
 
        for (i=0; (size_t)i<MIN(howmany(sb->fs_bsize, size),
860
 
            length); i+=8) {
 
823
        mem = (unsigned int *)block;
 
824
        for (i = 0; (size_t)i < MIN(howmany(sb->fs_bsize, size), length);
 
825
            i += 8) {
861
826
                fprintf(dbg_log, "%04x: ", i);
862
 
                for (j=0; j<8; j++) {
863
 
                        if((size_t)(i+j)<length) {
 
827
                for (j = 0; j < 8; j++) {
 
828
                        if ((size_t)(i + j) < length)
864
829
                                fprintf(dbg_log, "%08X ", *mem++);
865
 
                        }
866
830
                }
867
831
                fprintf(dbg_log, "\n");
868
832
        }