X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=debugfs%2Fdebugfs.c;h=179dd9a56652978aafd3558aaa4d9d16458d2a24;hb=2ffccc82c4b9ed935e45118e325896b70e9e3eb0;hp=3bb309fd6f620432cb3d56b002d4c8c0d88476aa;hpb=048786d7e87a6de698936b0cf25f1ab70d5c15bc;p=tools%2Fe2fsprogs.git diff --git a/debugfs/debugfs.c b/debugfs/debugfs.c index 3bb309f..179dd9a 100644 --- a/debugfs/debugfs.c +++ b/debugfs/debugfs.c @@ -8,6 +8,7 @@ * Modifications by Robert Sanders */ +#include "config.h" #include #include #include @@ -27,8 +28,6 @@ extern char *optarg; #include #include -#include "et/com_err.h" -#include "ss/ss.h" #include "debugfs.h" #include "uuid/uuid.h" #include "e2p/e2p.h" @@ -38,9 +37,23 @@ extern char *optarg; #include "../version.h" #include "jfs_user.h" -extern ss_request_table debug_cmds; +#ifndef BUFSIZ +#define BUFSIZ 8192 +#endif + +/* 64KiB is the minimium blksize to best minimize system call overhead. */ +#ifndef IO_BUFSIZE +#define IO_BUFSIZE 64*1024 +#endif + +/* Block size for `st_blocks' */ +#ifndef S_BLKSIZE +#define S_BLKSIZE 512 +#endif + ss_request_table *extra_cmds; const char *debug_prog_name; +int sci_idx; ext2_filsys current_fs = NULL; ext2_ino_t root, cwd; @@ -78,6 +91,8 @@ static void open_filesystem(char *device, int open_flags, blk64_t superblock, "opening read-only because of catastrophic mode"); open_flags &= ~EXT2_FLAG_RW; } + if (catastrophic) + open_flags |= EXT2_FLAG_SKIP_MMP; retval = ext2fs_open(device, open_flags, superblock, blocksize, unix_io_manager, ¤t_fs); @@ -86,6 +101,7 @@ static void open_filesystem(char *device, int open_flags, blk64_t superblock, current_fs = NULL; return; } + current_fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE; if (catastrophic) com_err(device, 0, "catastrophic mode - not reading inode or group bitmaps"); @@ -127,17 +143,21 @@ void do_open_filesys(int argc, char **argv) int catastrophic = 0; blk64_t superblock = 0; blk64_t blocksize = 0; - int open_flags = EXT2_FLAG_SOFTSUPP_FEATURES; + int open_flags = EXT2_FLAG_SOFTSUPP_FEATURES | EXT2_FLAG_64BITS; char *data_filename = 0; reset_getopt(); - while ((c = getopt (argc, argv, "iwfecb:s:d:")) != EOF) { + while ((c = getopt (argc, argv, "iwfecb:s:d:D")) != EOF) { switch (c) { case 'i': open_flags |= EXT2_FLAG_IMAGE_FILE; break; case 'w': +#ifdef READ_ONLY + goto print_usage; +#else open_flags |= EXT2_FLAG_RW; +#endif /* READ_ONLY */ break; case 'f': open_flags |= EXT2_FLAG_FORCE; @@ -151,6 +171,9 @@ void do_open_filesys(int argc, char **argv) case 'd': data_filename = optarg; break; + case 'D': + open_flags |= EXT2_FLAG_DIRECT_IO; + break; case 'b': blocksize = parse_ulong(optarg, argv[0], "block size", &err); @@ -158,8 +181,7 @@ void do_open_filesys(int argc, char **argv) return; break; case 's': - superblock = parse_ulong(optarg, argv[0], - "superblock number", &err); + err = strtoblk(argv[0], optarg, &superblock); if (err) return; break; @@ -179,7 +201,11 @@ void do_open_filesys(int argc, char **argv) print_usage: fprintf(stderr, "%s: Usage: open [-s superblock] [-b blocksize] " - "[-c] [-w] \n", argv[0]); + "[-d image_filename] [-c] [-i] [-f] [-e] [-D] " +#ifndef READ_ONLY + "[-w] " +#endif + "\n", argv[0]); } void do_lcd(int argc, char **argv) @@ -245,19 +271,23 @@ void do_close_filesys(int argc, char **argv) close_filesystem(); } +#ifndef READ_ONLY void do_init_filesys(int argc, char **argv) { struct ext2_super_block param; errcode_t retval; int err; + blk64_t blocks; if (common_args_process(argc, argv, 3, 3, "initialize", - " ", CHECK_FS_NOTOPEN)) + " ", CHECK_FS_NOTOPEN)) return; memset(¶m, 0, sizeof(struct ext2_super_block)); - ext2fs_blocks_count_set(¶m, parse_ulong(argv[2], argv[0], - "blocks count", &err)); + err = strtoblk(argv[0], argv[2], &blocks); + if (err) + return; + ext2fs_blocks_count_set(¶m, blocks); if (err) return; retval = ext2fs_initialize(argv[1], 0, ¶m, @@ -289,11 +319,12 @@ static void print_features(struct ext2_super_block * s, FILE *f) fputs("(none)", f); fputs("\n", f); } +#endif /* READ_ONLY */ static void print_bg_opts(ext2_filsys fs, dgrp_t group, int mask, const char *str, int *first, FILE *f) { - if (ext2fs_bg_flag_test(fs, group, mask)) { + if (ext2fs_bg_flags_test(fs, group, mask)) { if (*first) { fputs(" [", f); *first = 0; @@ -305,6 +336,7 @@ static void print_bg_opts(ext2_filsys fs, dgrp_t group, int mask, void do_show_super_stats(int argc, char *argv[]) { + const char *units ="block"; dgrp_t i; FILE *out; int c, header_only = 0; @@ -327,6 +359,10 @@ void do_show_super_stats(int argc, char *argv[]) return; out = open_pager(); + if (EXT2_HAS_RO_COMPAT_FEATURE(current_fs->super, + EXT4_FEATURE_RO_COMPAT_BIGALLOC)) + units = "cluster"; + list_super2(current_fs->super, out); for (i=0; i < current_fs->group_desc_count; i++) numdirs += ext2fs_bg_used_dirs_count(current_fs, i); @@ -337,21 +373,20 @@ void do_show_super_stats(int argc, char *argv[]) return; } - gdt_csum = EXT2_HAS_RO_COMPAT_FEATURE(current_fs->super, - EXT4_FEATURE_RO_COMPAT_GDT_CSUM); + gdt_csum = ext2fs_has_group_desc_csum(current_fs); for (i = 0; i < current_fs->group_desc_count; i++) { fprintf(out, " Group %2d: block bitmap at %llu, " "inode bitmap at %llu, " "inode table at %llu\n" - " %u free %s, " + " %u free %s%s, " "%u free %s, " "%u used %s%s", i, ext2fs_block_bitmap_loc(current_fs, i), ext2fs_inode_bitmap_loc(current_fs, i), ext2fs_inode_table_loc(current_fs, i), - ext2fs_bg_free_blocks_count(current_fs, i), + ext2fs_bg_free_blocks_count(current_fs, i), units, ext2fs_bg_free_blocks_count(current_fs, i) != 1 ? - "blocks" : "block", + "s" : "", ext2fs_bg_free_inodes_count(current_fs, i), ext2fs_bg_free_inodes_count(current_fs, i) != 1 ? "inodes" : "inode", @@ -382,6 +417,7 @@ print_usage: fprintf(stderr, "%s: Usage: show_super [-h]\n", argv[0]); } +#ifndef READ_ONLY void do_dirty_filesys(int argc EXT2FS_ATTR((unused)), char **argv EXT2FS_ATTR((unused))) { @@ -396,6 +432,7 @@ void do_dirty_filesys(int argc EXT2FS_ATTR((unused)), current_fs->super->s_state &= ~EXT2_VALID_FS; ext2fs_mark_super_dirty(current_fs); } +#endif /* READ_ONLY */ struct list_blocks_struct { FILE *f; @@ -632,11 +669,8 @@ static void dump_extents(FILE *f, const char *prefix, ext2_ino_t ino, continue; } - fprintf(f, "%s(NODE #%d, %lld-%lld, blk %lld)", - printed ? ", " : "", - info.curr_entry, - extent.e_lblk, - extent.e_lblk + (extent.e_len - 1), + fprintf(f, "%s(ETB%d):%lld", + printed ? ", " : "", info.curr_level, extent.e_pblk); printed = 1; continue; @@ -665,20 +699,20 @@ static void dump_extents(FILE *f, const char *prefix, ext2_ino_t ino, continue; else if (extent.e_len == 1) fprintf(f, - "%s(%lld%s): %lld", + "%s(%lld%s):%lld", printed ? ", " : "", extent.e_lblk, extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT ? - " [uninit]" : "", + "[u]" : "", extent.e_pblk); else fprintf(f, - "%s(%lld-%lld%s): %lld-%lld", + "%s(%lld-%lld%s):%lld-%lld", printed ? ", " : "", extent.e_lblk, extent.e_lblk + (extent.e_len - 1), extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT ? - " [uninit]" : "", + "[u]" : "", extent.e_pblk, extent.e_pblk + (extent.e_len - 1)); printed = 1; @@ -722,12 +756,9 @@ void internal_dump_inode(FILE *out, const char *prefix, } fprintf(out, "%sUser: %5d Group: %5d Size: ", prefix, inode_uid(*inode), inode_gid(*inode)); - if (LINUX_S_ISREG(inode->i_mode)) { - unsigned long long i_size = (inode->i_size | - ((unsigned long long)inode->i_size_high << 32)); - - fprintf(out, "%llu\n", i_size); - } else + if (LINUX_S_ISREG(inode->i_mode)) + fprintf(out, "%llu\n", EXT2_I_SIZE(inode)); + else fprintf(out, "%d\n", inode->i_size); if (os == EXT2_OS_HURD) fprintf(out, @@ -787,6 +818,19 @@ void internal_dump_inode(FILE *out, const char *prefix, if (EXT2_INODE_SIZE(current_fs->super) > EXT2_GOOD_OLD_INODE_SIZE) internal_dump_inode_extra(out, prefix, inode_num, (struct ext2_inode_large *) inode); + if (current_fs->super->s_creator_os == EXT2_OS_LINUX && + current_fs->super->s_feature_ro_compat & + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) { + __u32 crc = inode->i_checksum_lo; + if (is_large_inode && + large_inode->i_extra_isize >= + (offsetof(struct ext2_inode_large, + i_checksum_hi) - + EXT2_GOOD_OLD_INODE_SIZE)) + crc |= ((__u32)large_inode->i_checksum_hi) << 16; + fprintf(out, "Inode checksum: 0x%08x\n", crc); + } + if (LINUX_S_ISLNK(inode->i_mode) && ext2fs_inode_data_blocks(current_fs,inode) == 0) fprintf(out, "%sFast_link_dest: %.*s\n", prefix, (int) inode->i_size, (char *)inode->i_block); @@ -809,7 +853,7 @@ void internal_dump_inode(FILE *out, const char *prefix, } else if (do_dump_blocks) { if (inode->i_flags & EXT4_EXTENTS_FL) dump_extents(out, prefix, inode_num, - DUMP_LEAF_EXTENTS, 0, 0); + DUMP_LEAF_EXTENTS|DUMP_NODE_EXTENTS, 0, 0); else dump_blocks(out, prefix, inode_num); } @@ -855,7 +899,7 @@ void do_stat(int argc, char *argv[]) return; } -void do_dump_extents(int argc, char *argv[]) +void do_dump_extents(int argc, char **argv) { struct ext2_inode inode; ext2_ino_t ino; @@ -876,8 +920,7 @@ void do_dump_extents(int argc, char *argv[]) } } - if (argc != optind+1) { - print_usage: + if (argc != optind + 1) { com_err(0, 0, "Usage: dump_extents [-n] [-l] file"); return; } @@ -902,9 +945,7 @@ void do_dump_extents(int argc, char *argv[]) return; } - logical_width = int_log10(((inode.i_size | - (__u64) inode.i_size_high << 32) + - current_fs->blocksize - 1) / + logical_width = int_log10((EXT2_I_SIZE(&inode)+current_fs->blocksize-1)/ current_fs->blocksize) + 1; if (logical_width < 5) logical_width = 5; @@ -918,6 +959,34 @@ void do_dump_extents(int argc, char *argv[]) return; } +static int print_blocks_proc(ext2_filsys fs EXT2FS_ATTR((unused)), + blk64_t *blocknr, + e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *private EXT2FS_ATTR((unused))) +{ + printf("%llu ", *blocknr); + return 0; +} + +void do_blocks(int argc, char *argv[]) +{ + ext2_ino_t inode; + + if (check_fs_open(argv[0])) + return; + + if (common_inode_args_process(argc, argv, &inode, 0)) { + return; + } + + ext2fs_block_iterate3(current_fs, inode, BLOCK_FLAG_READ_ONLY, NULL, + print_blocks_proc, NULL); + fputc('\n', stdout); + return; +} + void do_chroot(int argc, char *argv[]) { ext2_ino_t inode; @@ -934,6 +1003,7 @@ void do_chroot(int argc, char *argv[]) root = inode; } +#ifndef READ_ONLY void do_clri(int argc, char *argv[]) { ext2_ino_t inode; @@ -951,31 +1021,64 @@ void do_clri(int argc, char *argv[]) void do_freei(int argc, char *argv[]) { - ext2_ino_t inode; + unsigned int len = 1; + int err = 0; + ext2_ino_t inode; + + if (common_args_process(argc, argv, 2, 3, argv[0], " [num]", + CHECK_FS_RW | CHECK_FS_BITMAPS)) + return; + if (check_fs_read_write(argv[0])) + return; - if (common_inode_args_process(argc, argv, &inode, - CHECK_FS_RW | CHECK_FS_BITMAPS)) + inode = string_to_inode(argv[1]); + if (!inode) return; - if (!ext2fs_test_inode_bitmap2(current_fs->inode_map,inode)) + if (argc == 3) { + len = parse_ulong(argv[2], argv[0], "length", &err); + if (err) + return; + } + + if (len == 1 && + !ext2fs_test_inode_bitmap2(current_fs->inode_map,inode)) com_err(argv[0], 0, "Warning: inode already clear"); - ext2fs_unmark_inode_bitmap2(current_fs->inode_map,inode); + while (len-- > 0) + ext2fs_unmark_inode_bitmap2(current_fs->inode_map, inode++); ext2fs_mark_ib_dirty(current_fs); } void do_seti(int argc, char *argv[]) { - ext2_ino_t inode; + unsigned int len = 1; + int err = 0; + ext2_ino_t inode; - if (common_inode_args_process(argc, argv, &inode, - CHECK_FS_RW | CHECK_FS_BITMAPS)) + if (common_args_process(argc, argv, 2, 3, argv[0], " [num]", + CHECK_FS_RW | CHECK_FS_BITMAPS)) + return; + if (check_fs_read_write(argv[0])) return; - if (ext2fs_test_inode_bitmap2(current_fs->inode_map,inode)) + inode = string_to_inode(argv[1]); + if (!inode) + return; + + if (argc == 3) { + len = parse_ulong(argv[2], argv[0], "length", &err); + if (err) + return; + } + + if ((len == 1) && + ext2fs_test_inode_bitmap2(current_fs->inode_map,inode)) com_err(argv[0], 0, "Warning: inode already set"); - ext2fs_mark_inode_bitmap2(current_fs->inode_map,inode); + while (len-- > 0) + ext2fs_mark_inode_bitmap2(current_fs->inode_map, inode++); ext2fs_mark_ib_dirty(current_fs); } +#endif /* READ_ONLY */ void do_testi(int argc, char *argv[]) { @@ -990,6 +1093,7 @@ void do_testi(int argc, char *argv[]) printf("Inode %u is not in use\n", inode); } +#ifndef READ_ONLY void do_freeb(int argc, char *argv[]) { blk64_t block; @@ -1027,6 +1131,7 @@ void do_setb(int argc, char *argv[]) } ext2fs_mark_bb_dirty(current_fs); } +#endif /* READ_ONLY */ void do_testb(int argc, char *argv[]) { @@ -1044,6 +1149,7 @@ void do_testb(int argc, char *argv[]) } } +#ifndef READ_ONLY static void modify_u8(char *com, const char *prompt, const char *format, __u8 *val) { @@ -1187,6 +1293,7 @@ void do_modify_inode(int argc, char *argv[]) if (debugfs_write_inode(inode_num, &inode, argv[1])) return; } +#endif /* READ_ONLY */ void do_change_working_dir(int argc, char *argv[]) { @@ -1239,35 +1346,7 @@ void do_print_working_directory(int argc, char *argv[]) return; } -/* - * Given a mode, return the ext2 file type - */ -static int ext2_file_type(unsigned int mode) -{ - if (LINUX_S_ISREG(mode)) - return EXT2_FT_REG_FILE; - - if (LINUX_S_ISDIR(mode)) - return EXT2_FT_DIR; - - if (LINUX_S_ISCHR(mode)) - return EXT2_FT_CHRDEV; - - if (LINUX_S_ISBLK(mode)) - return EXT2_FT_BLKDEV; - - if (LINUX_S_ISLNK(mode)) - return EXT2_FT_SYMLINK; - - if (LINUX_S_ISFIFO(mode)) - return EXT2_FT_FIFO; - - if (LINUX_S_ISSOCK(mode)) - return EXT2_FT_SOCK; - - return 0; -} - +#ifndef READ_ONLY static void make_link(char *sourcename, char *destname) { ext2_ino_t ino; @@ -1415,6 +1494,7 @@ void do_unlink(int argc, char *argv[]) unlink_file_by_name(argv[1]); } +#endif /* READ_ONLY */ void do_find_free_block(int argc, char *argv[]) { @@ -1507,22 +1587,39 @@ void do_find_free_inode(int argc, char *argv[]) printf("Free inode found: %u\n", free_inode); } -static errcode_t copy_file(int fd, ext2_ino_t newfile) +#ifndef READ_ONLY +static errcode_t copy_file(int fd, ext2_ino_t newfile, int bufsize, int make_holes) { ext2_file_t e2_file; errcode_t retval; int got; unsigned int written; - char buf[8192]; + char *buf; char *ptr; + char *zero_buf; + int cmp; retval = ext2fs_file_open(current_fs, newfile, EXT2_FILE_WRITE, &e2_file); if (retval) return retval; + retval = ext2fs_get_mem(bufsize, &buf); + if (retval) { + com_err("copy_file", retval, "can't allocate buffer\n"); + return retval; + } + + /* This is used for checking whether the whole block is zero */ + retval = ext2fs_get_memzero(bufsize, &zero_buf); + if (retval) { + com_err("copy_file", retval, "can't allocate buffer\n"); + ext2fs_free_mem(&buf); + return retval; + } + while (1) { - got = read(fd, buf, sizeof(buf)); + got = read(fd, buf, bufsize); if (got == 0) break; if (got < 0) { @@ -1530,6 +1627,21 @@ static errcode_t copy_file(int fd, ext2_ino_t newfile) goto fail; } ptr = buf; + + /* Sparse copy */ + if (make_holes) { + /* Check whether all is zero */ + cmp = memcmp(ptr, zero_buf, got); + if (cmp == 0) { + /* The whole block is zero, make a hole */ + retval = ext2fs_file_lseek(e2_file, got, EXT2_SEEK_CUR, NULL); + if (retval) + goto fail; + got = 0; + } + } + + /* Normal copy */ while (got > 0) { retval = ext2fs_file_write(e2_file, ptr, got, &written); @@ -1540,10 +1652,14 @@ static errcode_t copy_file(int fd, ext2_ino_t newfile) ptr += written; } } + ext2fs_free_mem(&buf); + ext2fs_free_mem(&zero_buf); retval = ext2fs_file_close(e2_file); return retval; fail: + ext2fs_free_mem(&buf); + ext2fs_free_mem(&zero_buf); (void) ext2fs_file_close(e2_file); return retval; } @@ -1556,6 +1672,8 @@ void do_write(int argc, char *argv[]) ext2_ino_t newfile; errcode_t retval; struct ext2_inode inode; + int bufsize = IO_BUFSIZE; + int make_holes = 0; if (common_args_process(argc, argv, 3, 3, "write", " ", CHECK_FS_RW)) @@ -1613,14 +1731,33 @@ void do_write(int argc, char *argv[]) inode.i_links_count = 1; inode.i_size = statbuf.st_size; if (current_fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_EXTENTS) + EXT3_FEATURE_INCOMPAT_EXTENTS) { + int i; + struct ext3_extent_header *eh; + + eh = (struct ext3_extent_header *) &inode.i_block[0]; + eh->eh_depth = 0; + eh->eh_entries = 0; + eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC); + i = (sizeof(inode.i_block) - sizeof(*eh)) / + sizeof(struct ext3_extent); + eh->eh_max = ext2fs_cpu_to_le16(i); inode.i_flags |= EXT4_EXTENTS_FL; + } if (debugfs_write_new_inode(newfile, &inode, argv[0])) { close(fd); return; } if (LINUX_S_ISREG(inode.i_mode)) { - retval = copy_file(fd, newfile); + if (statbuf.st_blocks < statbuf.st_size / S_BLKSIZE) { + make_holes = 1; + /* + * Use I/O blocksize as buffer size when + * copying sparse files. + */ + bufsize = statbuf.st_blksize; + } + retval = copy_file(fd, newfile, bufsize, make_holes); if (retval) com_err("copy_file", retval, 0); } @@ -1695,8 +1832,7 @@ void do_mknod(int argc, char *argv[]) } if (ext2fs_test_inode_bitmap2(current_fs->inode_map,newfile)) com_err(argv[0], 0, "Warning: inode already set"); - ext2fs_mark_inode_bitmap2(current_fs->inode_map, newfile); - ext2fs_mark_ib_dirty(current_fs); + ext2fs_inode_alloc_stats2(current_fs, newfile, +1, 0); memset(&inode, 0, sizeof(inode)); inode.i_mode = mode; inode.i_atime = inode.i_ctime = inode.i_mtime = @@ -1777,7 +1913,7 @@ static void kill_file_by_inode(ext2_ino_t inode) inode_buf.i_dtime = current_fs->now ? current_fs->now : time(0); if (debugfs_write_inode(inode, &inode_buf, 0)) return; - if (!ext2fs_inode_has_valid_blocks(&inode_buf)) + if (!ext2fs_inode_has_valid_blocks2(current_fs, &inode_buf)) return; ext2fs_block_iterate3(current_fs, inode, BLOCK_FLAG_READ_ONLY, NULL, @@ -1848,9 +1984,9 @@ static int rmdir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), if (dirent->inode == 0) return 0; - if (((dirent->name_len&0xFF) == 1) && (dirent->name[0] == '.')) + if ((ext2fs_dirent_name_len(dirent) == 1) && (dirent->name[0] == '.')) return 0; - if (((dirent->name_len&0xFF) == 2) && (dirent->name[0] == '.') && + if ((ext2fs_dirent_name_len(dirent) == 2) && (dirent->name[0] == '.') && (dirent->name[1] == '.')) { rds->parent = dirent->inode; return 0; @@ -1914,19 +2050,19 @@ void do_rmdir(int argc, char *argv[]) return; } } +#endif /* READ_ONLY */ void do_show_debugfs_params(int argc EXT2FS_ATTR((unused)), char *argv[] EXT2FS_ATTR((unused))) { - FILE *out = stdout; - if (current_fs) - fprintf(out, "Open mode: read-%s\n", - current_fs->flags & EXT2_FLAG_RW ? "write" : "only"); - fprintf(out, "Filesystem in use: %s\n", - current_fs ? current_fs->device_name : "--none--"); + printf("Open mode: read-%s\n", + current_fs->flags & EXT2_FLAG_RW ? "write" : "only"); + printf("Filesystem in use: %s\n", + current_fs ? current_fs->device_name : "--none--"); } +#ifndef READ_ONLY void do_expand_dir(int argc, char *argv[]) { ext2_ino_t inode; @@ -1960,6 +2096,7 @@ void do_features(int argc, char *argv[]) } print_features(current_fs->super, stdout); } +#endif /* READ_ONLY */ void do_bmap(int argc, char *argv[]) { @@ -1975,11 +2112,13 @@ void do_bmap(int argc, char *argv[]) ino = string_to_inode(argv[1]); if (!ino) return; - blk = parse_ulong(argv[2], argv[0], "logical_block", &err); + err = strtoblk(argv[0], argv[2], &blk); + if (err) + return; errcode = ext2fs_bmap2(current_fs, ino, 0, 0, 0, blk, 0, &pblk); if (errcode) { - com_err("argv[0]", errcode, + com_err(argv[0], errcode, "while mapping logical block %llu\n", blk); return; } @@ -2017,6 +2156,7 @@ void do_imap(int argc, char *argv[]) } +#ifndef READ_ONLY void do_set_current_time(int argc, char *argv[]) { time_t now; @@ -2036,6 +2176,7 @@ void do_set_current_time(int argc, char *argv[]) current_fs->now = now; } } +#endif /* READ_ONLY */ static int find_supp_feature(__u32 *supp, int feature_type, char *name) { @@ -2102,10 +2243,138 @@ void do_supported_features(int argc, char *argv[]) } } -static int source_file(const char *cmd_file, int sci_idx) +#ifndef READ_ONLY +void do_punch(int argc, char *argv[]) +{ + ext2_ino_t ino; + blk64_t start, end; + int err; + errcode_t errcode; + + if (common_args_process(argc, argv, 3, 4, argv[0], + " start_blk [end_blk]", + CHECK_FS_RW | CHECK_FS_BITMAPS)) + return; + + ino = string_to_inode(argv[1]); + if (!ino) + return; + err = strtoblk(argv[0], argv[2], &start); + if (err) + return; + if (argc == 4) { + err = strtoblk(argv[0], argv[3], &end); + if (err) + return; + } else + end = ~0; + + errcode = ext2fs_punch(current_fs, ino, 0, 0, start, end); + + if (errcode) { + com_err(argv[0], errcode, + "while truncating inode %u from %llu to %llu\n", ino, + (unsigned long long) start, (unsigned long long) end); + return; + } +} +#endif /* READ_ONLY */ + +void do_symlink(int argc, char *argv[]) +{ + char *cp; + ext2_ino_t parent; + char *name, *target; + errcode_t retval; + + if (common_args_process(argc, argv, 3, 3, "symlink", + " ", CHECK_FS_RW)) + return; + + cp = strrchr(argv[1], '/'); + if (cp) { + *cp = 0; + parent = string_to_inode(argv[1]); + if (!parent) { + com_err(argv[1], ENOENT, 0); + return; + } + name = cp+1; + } else { + parent = cwd; + name = argv[1]; + } + target = argv[2]; + +try_again: + retval = ext2fs_symlink(current_fs, parent, 0, name, target); + if (retval == EXT2_ET_DIR_NO_SPACE) { + retval = ext2fs_expand_dir(current_fs, parent); + if (retval) { + com_err(argv[0], retval, "while expanding directory"); + return; + } + goto try_again; + } + if (retval) { + com_err("ext2fs_symlink", retval, 0); + return; + } + +} + +void do_dump_mmp(int argc EXT2FS_ATTR((unused)), char *argv[]) +{ +#if CONFIG_MMP + struct ext2_super_block *sb; + struct mmp_struct *mmp_s; + time_t t; + errcode_t retval = 0; + + if (check_fs_open(argv[0])) + return; + + sb = current_fs->super; + + if (current_fs->mmp_buf == NULL) { + retval = ext2fs_get_mem(current_fs->blocksize, + ¤t_fs->mmp_buf); + if (retval) { + com_err(argv[0], retval, "allocating MMP buffer.\n"); + return; + } + } + + mmp_s = current_fs->mmp_buf; + + retval = ext2fs_mmp_read(current_fs, current_fs->super->s_mmp_block, + current_fs->mmp_buf); + if (retval) { + com_err(argv[0], retval, "reading MMP block.\n"); + return; + } + + t = mmp_s->mmp_time; + fprintf(stdout, "block_number: %llu\n", current_fs->super->s_mmp_block); + fprintf(stdout, "update_interval: %d\n", + current_fs->super->s_mmp_update_interval); + fprintf(stdout, "check_interval: %d\n", mmp_s->mmp_check_interval); + fprintf(stdout, "sequence: %08x\n", mmp_s->mmp_seq); + fprintf(stdout, "time: %lld -- %s", mmp_s->mmp_time, ctime(&t)); + fprintf(stdout, "node_name: %s\n", mmp_s->mmp_nodename); + fprintf(stdout, "device_name: %s\n", mmp_s->mmp_bdevname); + fprintf(stdout, "magic: 0x%x\n", mmp_s->mmp_magic); + fprintf(stdout, "checksum: 0x%08x\n", mmp_s->mmp_checksum); +#else + fprintf(stdout, "MMP is unsupported, please recompile with " + "--enable-mmp\n"); +#endif +} + +static int source_file(const char *cmd_file, int ss_idx) { FILE *f; - char buf[256]; + char buf[BUFSIZ]; char *cp; int exit_status = 0; int retval; @@ -2133,22 +2402,29 @@ static int source_file(const char *cmd_file, int sci_idx) if (cp) *cp = 0; printf("debugfs: %s\n", buf); - retval = ss_execute_line(sci_idx, buf); + retval = ss_execute_line(ss_idx, buf); if (retval) { - ss_perror(sci_idx, retval, buf); + ss_perror(ss_idx, retval, buf); exit_status++; } } + if (f != stdin) + fclose(f); return exit_status; } int main(int argc, char **argv) { int retval; - int sci_idx; - const char *usage = "Usage: %s [-b blocksize] [-s superblock] [-f cmd_file] [-R request] [-V] [[-w] [-c] device]"; + const char *usage = + "Usage: %s [-b blocksize] [-s superblock] [-f cmd_file] " + "[-R request] [-V] [" +#ifndef READ_ONLY + "[-w] " +#endif + "[-c] device]"; int c; - int open_flags = EXT2_FLAG_SOFTSUPP_FEATURES; + int open_flags = EXT2_FLAG_SOFTSUPP_FEATURES | EXT2_FLAG_64BITS; char *request = 0; int exit_status = 0; char *cmd_file = 0; @@ -2156,15 +2432,23 @@ int main(int argc, char **argv) blk64_t blocksize = 0; int catastrophic = 0; char *data_filename = 0; +#ifdef READ_ONLY + const char *opt_string = "nicR:f:b:s:Vd:D"; +#else + const char *opt_string = "niwcR:f:b:s:Vd:D"; +#endif if (debug_prog_name == 0) +#ifdef READ_ONLY + debug_prog_name = "rdebugfs"; +#else debug_prog_name = "debugfs"; - +#endif add_error_table(&et_ext2_error_table); fprintf (stderr, "%s %s (%s)\n", debug_prog_name, E2FSPROGS_VERSION, E2FSPROGS_DATE); - while ((c = getopt (argc, argv, "iwcR:f:b:s:Vd:")) != EOF) { + while ((c = getopt (argc, argv, opt_string)) != EOF) { switch (c) { case 'R': request = optarg; @@ -2178,16 +2462,25 @@ int main(int argc, char **argv) case 'i': open_flags |= EXT2_FLAG_IMAGE_FILE; break; + case 'n': + open_flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + break; +#ifndef READ_ONLY case 'w': open_flags |= EXT2_FLAG_RW; break; +#endif + case 'D': + open_flags |= EXT2_FLAG_DIRECT_IO; + break; case 'b': blocksize = parse_ulong(optarg, argv[0], "block size", 0); break; case 's': - superblock = parse_ulong(optarg, argv[0], - "superblock number", 0); + retval = strtoblk(argv[0], optarg, &superblock); + if (retval) + return 1; break; case 'c': catastrophic = 1;