← Back to branch summary

~vorlon/ubuntu/natty/e2fsprogs/multiarch

« back to all changes in this revision

Viewing changes to debugfs/debugfs.c

  • Committer: Bazaar Package Importer
  • Author(s): Scott James Remnant
  • Date: 2009-08-25 18:34:46 UTC
  • mfrom: (8.2.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090825183446-p2iuz63g8g4ytlf4
Tags: 1.41.9-1ubuntu1
https://launchpad.net/bugs/416648
* Merge from Debian, remaining changes:
  - Do not build-depend on dietlibc-dev, which is universe.
  - Do now allow pkg-create-dbgsym to operate on this package.
  - Use external libblkid and libuuid from util-linux, rather than
    building our own.
  - Do not include /etc/e2fsck.conf and remove on upgrade.

* Included a couple of extra revisions from GIT maint:
  - (ffd8078) e2freefrag: Update manpage to include e2fsprogs version
    and release date
  - (31b5a2b) mke2fs.conf: Use the feature name "extent" instead of
    "extents"
  - (8bafedb) tune2fs: Fix "tune2fs -j <dev>" for extent-enabled
     filesystems.  LP: #416648.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debugfs/debugfs.c
551
551
        fprintf(f,"\n");
552
552
}
553
553
 
 
554
static int int_log10(unsigned long long arg)
 
555
{
 
556
        int     l = 0;
 
557
 
 
558
        arg = arg / 10;
 
559
        while (arg) {
 
560
                l++;
 
561
                arg = arg / 10;
 
562
        }
 
563
        return l;
 
564
}
 
565
 
 
566
#define DUMP_LEAF_EXTENTS       0x01
 
567
#define DUMP_NODE_EXTENTS       0x02
 
568
#define DUMP_EXTENT_TABLE       0x04
 
569
 
 
570
static void dump_extents(FILE *f, const char *prefix, ext2_ino_t ino,
 
571
                         int flags, int logical_width, int physical_width)
 
572
{
 
573
        ext2_extent_handle_t    handle;
 
574
        struct ext2fs_extent    extent;
 
575
        struct ext2_extent_info info;
 
576
        int                     op = EXT2_EXTENT_ROOT;
 
577
        unsigned int            printed = 0;
 
578
        errcode_t               errcode;
 
579
 
 
580
        errcode = ext2fs_extent_open(current_fs, ino, &handle);
 
581
        if (errcode)
 
582
                return;
 
583
 
 
584
        if (flags & DUMP_EXTENT_TABLE)
 
585
                fprintf(f, "Level Entries %*s %*s Length Flags\n",
 
586
                        (logical_width*2)+3, "Logical",
 
587
                        (physical_width*2)+3, "Physical");
 
588
        else
 
589
                fprintf(f, "%sEXTENTS:\n%s", prefix, prefix);
 
590
 
 
591
        while (1) {
 
592
                errcode = ext2fs_extent_get(handle, op, &extent);
 
593
 
 
594
                if (errcode)
 
595
                        break;
 
596
 
 
597
                op = EXT2_EXTENT_NEXT;
 
598
 
 
599
                if (extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)
 
600
                        continue;
 
601
 
 
602
                if (extent.e_flags & EXT2_EXTENT_FLAGS_LEAF) {
 
603
                        if ((flags & DUMP_LEAF_EXTENTS) == 0)
 
604
                                continue;
 
605
                } else {
 
606
                        if ((flags & DUMP_NODE_EXTENTS) == 0)
 
607
                                continue;
 
608
                }
 
609
 
 
610
                errcode = ext2fs_extent_get_info(handle, &info);
 
611
                if (errcode)
 
612
                        continue;
 
613
 
 
614
                if (!(extent.e_flags & EXT2_EXTENT_FLAGS_LEAF)) {
 
615
                        if (extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)
 
616
                                continue;
 
617
 
 
618
                        if (flags & DUMP_EXTENT_TABLE) {
 
619
                                fprintf(f, "%2d/%2d %3d/%3d %*llu - %*llu "
 
620
                                        "%*llu%*s %6u\n",
 
621
                                        info.curr_level, info.max_depth,
 
622
                                        info.curr_entry, info.num_entries,
 
623
                                        logical_width,
 
624
                                        extent.e_lblk,
 
625
                                        logical_width,
 
626
                                        extent.e_lblk + (extent.e_len - 1),
 
627
                                        physical_width,
 
628
                                        extent.e_pblk,
 
629
                                        physical_width+3, "", extent.e_len);
 
630
                                continue;
 
631
                        }
 
632
 
 
633
                        fprintf(f, "%s(NODE #%d, %lld-%lld, blk %lld)",
 
634
                                printed ? ", " : "",
 
635
                                info.curr_entry,
 
636
                                extent.e_lblk,
 
637
                                extent.e_lblk + (extent.e_len - 1),
 
638
                                extent.e_pblk);
 
639
                        printed = 1;
 
640
                        continue;
 
641
                }
 
642
 
 
643
                if (flags & DUMP_EXTENT_TABLE) {
 
644
                        fprintf(f, "%2d/%2d %3d/%3d %*llu - %*llu "
 
645
                                "%*llu - %*llu %6u %s\n",
 
646
                                info.curr_level, info.max_depth,
 
647
                                info.curr_entry, info.num_entries,
 
648
                                logical_width,
 
649
                                extent.e_lblk,
 
650
                                logical_width,
 
651
                                extent.e_lblk + (extent.e_len - 1),
 
652
                                physical_width,
 
653
                                extent.e_pblk,
 
654
                                physical_width,
 
655
                                extent.e_pblk + (extent.e_len - 1),
 
656
                                extent.e_len,
 
657
                                extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT ?
 
658
                                        "Uninit" : "");
 
659
                        continue;
 
660
                }
 
661
 
 
662
                if (extent.e_len == 0)
 
663
                        continue;
 
664
                else if (extent.e_len == 1)
 
665
                        fprintf(f,
 
666
                                "%s(%lld%s): %lld",
 
667
                                printed ? ", " : "",
 
668
                                extent.e_lblk,
 
669
                                extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT ?
 
670
                                " [uninit]" : "",
 
671
                                extent.e_pblk);
 
672
                else
 
673
                        fprintf(f,
 
674
                                "%s(%lld-%lld%s): %lld-%lld",
 
675
                                printed ? ", " : "",
 
676
                                extent.e_lblk,
 
677
                                extent.e_lblk + (extent.e_len - 1),
 
678
                                extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT ?
 
679
                                        " [uninit]" : "",
 
680
                                extent.e_pblk,
 
681
                                extent.e_pblk + (extent.e_len - 1));
 
682
                printed = 1;
 
683
        }
 
684
        if (printed)
 
685
                fprintf(f, "\n");
 
686
}
554
687
 
555
688
void internal_dump_inode(FILE *out, const char *prefix,
556
689
                         ext2_ino_t inode_num, struct ext2_inode *inode,
671
804
                }
672
805
                fprintf(out, "%sDevice major/minor number: %02d:%02d (hex %02x:%02x)\n",
673
806
                        devnote, major, minor, major, minor);
 
807
        } else if (do_dump_blocks) {
 
808
                if (inode->i_flags & EXT4_EXTENTS_FL)
 
809
                        dump_extents(out, prefix, inode_num,
 
810
                                     DUMP_LEAF_EXTENTS, 0, 0);
 
811
                else
 
812
                        dump_blocks(out, prefix, inode_num);
674
813
        }
675
 
        else if (do_dump_blocks)
676
 
                dump_blocks(out, prefix, inode_num);
677
814
}
678
815
 
679
816
static void dump_inode(ext2_ino_t inode_num, struct ext2_inode *inode)
716
853
        return;
717
854
}
718
855
 
 
856
void do_dump_extents(int argc, char *argv[])
 
857
{
 
858
        struct ext2_inode inode;
 
859
        ext2_ino_t      ino;
 
860
        FILE            *out;
 
861
        int             c, flags = 0;
 
862
        int             logical_width;
 
863
        int             physical_width;
 
864
 
 
865
        reset_getopt();
 
866
        while ((c = getopt(argc, argv, "nl")) != EOF) {
 
867
                switch (c) {
 
868
                case 'n':
 
869
                        flags |= DUMP_NODE_EXTENTS;
 
870
                        break;
 
871
                case 'l':
 
872
                        flags |= DUMP_LEAF_EXTENTS;
 
873
                        break;
 
874
                }
 
875
        }
 
876
 
 
877
        if (argc != optind+1) {
 
878
        print_usage:
 
879
                com_err(0, 0, "Usage: dump_extents [-n] [-l] file");
 
880
                return;
 
881
        }
 
882
 
 
883
        if (flags == 0)
 
884
                flags = DUMP_NODE_EXTENTS | DUMP_LEAF_EXTENTS;
 
885
        flags |= DUMP_EXTENT_TABLE;
 
886
 
 
887
        if (check_fs_open(argv[0]))
 
888
                return;
 
889
 
 
890
        ino = string_to_inode(argv[optind]);
 
891
        if (ino == 0)
 
892
                return;
 
893
 
 
894
        if (debugfs_read_inode(ino, &inode, argv[0]))
 
895
                return;
 
896
 
 
897
        if ((inode.i_flags & EXT4_EXTENTS_FL) == 0) {
 
898
                fprintf(stderr, "%s: does not uses extent block maps\n",
 
899
                        argv[optind]);
 
900
                return;
 
901
        }
 
902
 
 
903
        logical_width = int_log10(((inode.i_size |
 
904
                                    (__u64) inode.i_size_high << 32) +
 
905
                                   current_fs->blocksize - 1) /
 
906
                                  current_fs->blocksize) + 1;
 
907
        if (logical_width < 5)
 
908
                logical_width = 5;
 
909
        physical_width = int_log10(current_fs->super->s_blocks_count) + 1;
 
910
        if (physical_width < 5)
 
911
                physical_width = 5;
 
912
 
 
913
        out = open_pager();
 
914
        dump_extents(out, "", ino, flags, logical_width, physical_width);
 
915
        close_pager(out);
 
916
        return;
 
917
}
 
918
 
719
919
void do_chroot(int argc, char *argv[])
720
920
{
721
921
        ext2_ino_t inode;
1871
2071
 
1872
2072
void do_supported_features(int argc, char *argv[])
1873
2073
{
1874
 
        int     i, j, ret;
 
2074
        int     ret;
1875
2075
        __u32   supp[3] = { EXT2_LIB_FEATURE_COMPAT_SUPP,
1876
2076
                            EXT2_LIB_FEATURE_INCOMPAT_SUPP,
1877
2077
                            EXT2_LIB_FEATURE_RO_COMPAT_SUPP };