extern int optind;
extern char *optarg;
#endif
-#ifdef HAVE_OPTRESET
-extern int optreset; /* defined by BSD, but not others */
-#endif
#include "debugfs.h"
+#include "blkid/blkid.h"
#include "jfs_user.h"
+#include <uuid/uuid.h>
enum journal_location {JOURNAL_IS_INTERNAL, JOURNAL_IS_EXTERNAL};
+#define ANY_BLOCK ((unsigned int) -1)
+
int dump_all, dump_contents, dump_descriptors;
unsigned int block_to_dump, group_to_dump, bitmap_to_dump;
unsigned int inode_block_to_dump, inode_offset_to_dump, bitmap_to_dump;
blocknr -= (be32_to_cpu((jsb)->s_maxlen) - \
be32_to_cpu((jsb)->s_first));
-
void do_logdump(int argc, char **argv)
{
- ext2_ino_t inode;
int c;
- int fd;
int retval;
char *out_fn;
FILE *out_file;
char *inode_spec = NULL;
char *journal_fn = NULL;
int journal_fd = 0;
+ int use_sb = 0;
ext2_ino_t journal_inum;
struct ext2_inode journal_inode;
ext2_file_t journal_file;
-
char *tmp;
+ struct journal_source journal_source;
+ struct ext2_super_block *es = NULL;
- const char *logdump_usage = ("Usage: logdump "
- "[-ac] [-b<block>] [-i<inode>] "
- "[-f<journal_file>] [output_file]");
-
- struct journal_source journal_source = {};
-
- optind = 0;
-#ifdef HAVE_OPTRESET
- optreset = 1; /* Makes BSD getopt happy */
-#endif
+ journal_source.where = 0;
+ journal_source.fd = 0;
+ journal_source.file = 0;
dump_all = 0;
dump_contents = 0;
dump_descriptors = 1;
- block_to_dump = -1;
+ block_to_dump = ANY_BLOCK;
bitmap_to_dump = -1;
- inode_block_to_dump = -1;
+ inode_block_to_dump = ANY_BLOCK;
inode_to_dump = -1;
- while ((c = getopt (argc, argv, "ab:ci:f:")) != EOF) {
+ reset_getopt();
+ while ((c = getopt (argc, argv, "ab:ci:f:s")) != EOF) {
switch (c) {
case 'a':
dump_all++;
inode_spec = optarg;
dump_descriptors = 0;
break;
+ case 's':
+ use_sb++;
+ break;
default:
- com_err(argv[0], 0, logdump_usage);
- return;
+ goto print_usage;
}
}
if (optind != argc && optind != argc-1) {
- com_err(argv[0], 0, logdump_usage);
- return;
+ goto print_usage;
}
+ if (current_fs)
+ es = current_fs->super;
+
if (inode_spec) {
int inode_group, group_offset, inodes_per_block;
-
+
if (check_fs_open(argv[0]))
return;
return;
inode_group = ((inode_to_dump - 1)
- / current_fs->super->s_inodes_per_group);
+ / es->s_inodes_per_group);
group_offset = ((inode_to_dump - 1)
- % current_fs->super->s_inodes_per_group);
+ % es->s_inodes_per_group);
inodes_per_block = (current_fs->blocksize
/ sizeof(struct ext2_inode));
} else {
out_fn = argv[optind];
out_file = fopen(out_fn, "w");
- if (!out_file < 0) {
+ if (!out_file) {
com_err(argv[0], errno, "while opening %s for logdump",
out_fn);
- return;
+ goto errout;
}
}
- if (block_to_dump != -1 && current_fs != NULL) {
+ if (block_to_dump != ANY_BLOCK && current_fs != NULL) {
group_to_dump = ((block_to_dump -
- current_fs->super->s_first_data_block)
- / current_fs->super->s_blocks_per_group);
+ es->s_first_data_block)
+ / es->s_blocks_per_group);
bitmap_to_dump = current_fs->group_desc[group_to_dump].bg_block_bitmap;
}
-
- if (journal_fn) {
+ if (!journal_fn && check_fs_open(argv[0]))
+ goto errout;
+
+ if (journal_fn) {
/* Set up to read journal from a regular file somewhere */
journal_fd = open(journal_fn, O_RDONLY, 0);
if (journal_fd < 0) {
com_err(argv[0], errno, "while opening %s for logdump",
journal_fn);
- return;
+ goto errout;
}
journal_source.where = JOURNAL_IS_EXTERNAL;
journal_source.fd = journal_fd;
-
- } else {
-
- /* Set up to read journal from the open filesystem */
- if (check_fs_open(argv[0]))
- return;
- journal_inum = current_fs->super->s_journal_inum;
- if (!journal_inum) {
- com_err(argv[0], 0, "filesystem has no journal");
- return;
- }
-
- retval = ext2fs_read_inode(current_fs, journal_inum,
- &journal_inode);
- if (retval) {
- com_err(argv[0], retval,
- "while reading inode %u", journal_inum);
- return;
+ } else if ((journal_inum = es->s_journal_inum)) {
+ if (use_sb) {
+ if (es->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS) {
+ com_err(argv[0], 0,
+ "no journal backup in super block\n");
+ goto errout;
+ }
+ memset(&journal_inode, 0, sizeof(struct ext2_inode));
+ memcpy(&journal_inode.i_block[0], es->s_jnl_blocks,
+ EXT2_N_BLOCKS*4);
+ journal_inode.i_size = es->s_jnl_blocks[16];
+ journal_inode.i_links_count = 1;
+ journal_inode.i_mode = LINUX_S_IFREG | 0600;
+ } else {
+ if (debugfs_read_inode(journal_inum, &journal_inode,
+ argv[0]))
+ goto errout;
}
- retval = ext2fs_file_open(current_fs, journal_inum,
- 0, &journal_file);
+ retval = ext2fs_file_open2(current_fs, journal_inum,
+ &journal_inode, 0, &journal_file);
if (retval) {
com_err(argv[0], retval, "while opening ext2 file");
- return;
+ goto errout;
}
-
journal_source.where = JOURNAL_IS_INTERNAL;
journal_source.file = journal_file;
+ } else {
+ char uuid[37];
+
+ uuid_unparse(es->s_journal_uuid, uuid);
+ journal_fn = blkid_get_devname(NULL, "UUID", uuid);
+ if (!journal_fn)
+ journal_fn = blkid_devno_to_devname(es->s_journal_dev);
+ if (!journal_fn) {
+ com_err(argv[0], 0, "filesystem has no journal");
+ goto errout;
+ }
+ journal_fd = open(journal_fn, O_RDONLY, 0);
+ if (journal_fd < 0) {
+ com_err(argv[0], errno, "while opening %s for logdump",
+ journal_fn);
+ free(journal_fn);
+ goto errout;
+ }
+ fprintf(out_file, "Using external journal found at %s\n",
+ journal_fn);
+ free(journal_fn);
+ journal_source.where = JOURNAL_IS_EXTERNAL;
+ journal_source.fd = journal_fd;
}
dump_journal(argv[0], out_file, &journal_source);
else
close(journal_fd);
+errout:
if (out_file != stdout)
fclose(out_file);
return;
+
+print_usage:
+ fprintf(stderr, "%s: Usage: logdump [-ac] [-b<block>] [-i<inode>]\n\t"
+ "[-f<journal_file>] [output_file]\n", argv[0]);
}
-int read_journal_block(char *cmd, struct journal_source *source, off_t offset,
- char *buf, int size, int *got)
+static int read_journal_block(const char *cmd, struct journal_source *source,
+ off_t offset, char *buf, int size,
+ unsigned int *got)
{
int retval;
if (source->where == JOURNAL_IS_EXTERNAL) {
- retval = pread(source->fd, buf, size, offset);
+ if (lseek(source->fd, offset, SEEK_SET) < 0) {
+ retval = errno;
+ com_err(cmd, retval, "while seeking in reading journal");
+ return retval;
+ }
+ retval = read(source->fd, buf, size);
if (retval >= 0) {
*got = retval;
retval = 0;
- }
- retval = errno;
+ } else
+ retval = errno;
} else {
retval = ext2fs_file_lseek(source->file, offset,
EXT2_SEEK_SET, NULL);
if (retval)
com_err(cmd, retval, "while while reading journal");
- else if (*got != size) {
+ else if (*got != (unsigned int) size) {
com_err(cmd, 0, "short read (read %d, expected %d) while while reading journal", *got, size);
retval = -1;
}
return retval;
}
-static char *type_to_name(int btype)
+static const char *type_to_name(int btype)
{
switch (btype) {
case JFS_DESCRIPTOR_BLOCK:
return "V2 superblock";
case JFS_REVOKE_BLOCK:
return "revoke table";
- default:
}
return "unrecognised type";
}
static void dump_journal(char *cmdname, FILE *out_file,
struct journal_source *source)
{
+ struct ext2_super_block *sb;
char jsb_buffer[1024];
char buf[8192];
journal_superblock_t *jsb;
- int blocksize;
- int got;
+ unsigned int blocksize = 1024;
+ unsigned int got;
int retval;
__u32 magic, sequence, blocktype;
journal_header_t *header;
tid_t transaction;
- unsigned int blocknr;
+ unsigned int blocknr = 0;
- /* First: locate the journal superblock */
-
+ /* First, check to see if there's an ext2 superblock header */
retval = read_journal_block(cmdname, source, 0,
- jsb_buffer, 1024, &got);
+ buf, 2048, &got);
if (retval)
return;
+
+ jsb = (journal_superblock_t *) buf;
+ sb = (struct ext2_super_block *) (buf+1024);
+#ifdef ENABLE_SWAPFS
+ if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
+ ext2fs_swap_super(sb);
+#endif
+
+ if ((be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) &&
+ (sb->s_magic == EXT2_SUPER_MAGIC) &&
+ (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
+ blocksize = EXT2_BLOCK_SIZE(sb);
+ blocknr = (blocksize == 1024) ? 2 : 1;
+ uuid_unparse(sb->s_uuid, jsb_buffer);
+ fprintf(out_file, "Ext2 superblock header found.\n");
+ if (dump_all) {
+ fprintf(out_file, "\tuuid=%s\n", jsb_buffer);
+ fprintf(out_file, "\tblocksize=%d\n", blocksize);
+ fprintf(out_file, "\tjournal data size %ld\n",
+ (long) sb->s_blocks_count);
+ }
+ }
+ /* Next, read the journal superblock */
+
+ retval = read_journal_block(cmdname, source, blocknr*blocksize,
+ jsb_buffer, 1024, &got);
+ if (retval)
+ return;
+
jsb = (journal_superblock_t *) jsb_buffer;
+ if (be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) {
+ fprintf(out_file,
+ "Journal superblock magic number invalid!\n");
+ return;
+ }
blocksize = be32_to_cpu(jsb->s_blocksize);
transaction = be32_to_cpu(jsb->s_sequence);
blocknr = be32_to_cpu(jsb->s_start);
static void dump_revoke_block(FILE *out_file, char *buf,
- journal_superblock_t *jsb,
- unsigned int blocknr, int blocksize,
- tid_t transaction)
+ journal_superblock_t *jsb EXT2FS_ATTR((unused)),
+ unsigned int blocknr,
+ int blocksize EXT2FS_ATTR((unused)),
+ tid_t transaction)
{
int offset, max;
journal_revoke_header_t *header;
start_extent, end_extent-start_extent, first_block);
}
-static void show_indirect(FILE *out_file, char *name, __u32 where)
+static void show_indirect(FILE *out_file, const char *name, __u32 where)
{
if (where)
fprintf(out_file, "(%s): %u ", name, where);
static void dump_metadata_block(FILE *out_file, struct journal_source *source,
- journal_superblock_t *jsb,
+ journal_superblock_t *jsb EXT2FS_ATTR((unused)),
unsigned int log_blocknr,
unsigned int fs_blocknr,
int blocksize,
tid_t transaction)
{
- int got, retval;
- char buf[8192];
+ unsigned int got;
+ int retval;
+ char buf[8192];
if (!(dump_all
|| (fs_blocknr == block_to_dump)
* inode. */
fprintf (out_file, " Blocks: ");
- start_extent = -1;
+ first = prev = start_extent = -1;
for (i=0; i<EXT2_NDIR_BLOCKS; i++) {
this = inode->i_block[i];
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff