* Modifications by Robert Sanders <gt8134b@prism.gatech.edu>
*/
+#include "config.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include "et/com_err.h"
-#include "ss/ss.h"
#include "debugfs.h"
#include "uuid/uuid.h"
#include "e2p/e2p.h"
#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;
"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);
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");
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;
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);
return;
break;
case 's':
- superblock = parse_ulong(optarg, argv[0],
- "superblock number", &err);
+ err = strtoblk(argv[0], optarg, &superblock);
if (err)
return;
break;
print_usage:
fprintf(stderr, "%s: Usage: open [-s superblock] [-b blocksize] "
- "[-c] [-w] <device>\n", argv[0]);
+ "[-d image_filename] [-c] [-i] [-f] [-e] [-D] "
+#ifndef READ_ONLY
+ "[-w] "
+#endif
+ "<device>\n", argv[0]);
}
void do_lcd(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",
- "<device> <blocksize>", CHECK_FS_NOTOPEN))
+ "<device> <blocks>", 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,
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)
void do_show_super_stats(int argc, char *argv[])
{
+ const char *units ="block";
dgrp_t i;
FILE *out;
int c, header_only = 0;
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);
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",
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)))
{
current_fs->super->s_state &= ~EXT2_VALID_FS;
ext2fs_mark_super_dirty(current_fs);
}
+#endif /* READ_ONLY */
struct list_blocks_struct {
FILE *f;
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;
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;
}
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,
} 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);
}
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;
}
}
- if (argc != optind+1) {
- print_usage:
+ if (argc != optind + 1) {
com_err(0, 0, "Usage: dump_extents [-n] [-l] file");
return;
}
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;
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;
root = inode;
}
+#ifndef READ_ONLY
void do_clri(int argc, char *argv[])
{
ext2_ino_t inode;
void do_freei(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], "<file> [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 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], "<file> [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[])
{
printf("Inode %u is not in use\n", inode);
}
+#ifndef READ_ONLY
void do_freeb(int argc, char *argv[])
{
blk64_t block;
}
ext2fs_mark_bb_dirty(current_fs);
}
+#endif /* READ_ONLY */
void do_testb(int argc, char *argv[])
{
}
}
+#ifndef READ_ONLY
static void modify_u8(char *com, const char *prompt,
const char *format, __u8 *val)
{
if (debugfs_write_inode(inode_num, &inode, argv[1]))
return;
}
+#endif /* READ_ONLY */
void do_change_working_dir(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;
unlink_file_by_name(argv[1]);
}
+#endif /* READ_ONLY */
void do_find_free_block(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) {
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);
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;
}
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",
"<native file> <new file>", CHECK_FS_RW))
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 = 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);
}
}
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 =
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,
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;
}
print_features(current_fs->super, stdout);
}
+#endif /* READ_ONLY */
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;
}
}
+#ifndef READ_ONLY
void do_set_current_time(int argc, char *argv[])
{
time_t now;
current_fs->now = now;
}
}
+#endif /* READ_ONLY */
static int find_supp_feature(__u32 *supp, int feature_type, char *name)
{
}
}
-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],
+ "<file> 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",
+ "<filename> <target>", 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[])
+{
+ 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);
+}
+
+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;
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++;
}
}
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 | EXT2_FLAG_64BITS;
char *request = 0;
blk64_t blocksize = 0;
int catastrophic = 0;
char *data_filename = 0;
+#ifdef READ_ONLY
+ const char *opt_string = "icR:f:b:s:Vd:D";
+#else
+ const char *opt_string = "iwcR: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;
case 'i':
open_flags |= EXT2_FLAG_IMAGE_FILE;
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) {
+ com_err(argv[0], retval, 0, debug_prog_name);
+ return 1;
+ }
break;
case 'c':
catastrophic = 1;
projects / thirdparty / e2fsprogs.git / blobdiff