/*
* This function adds a journal device to a filesystem
*/
errcode_t ext2fs_add_journal_device(ext2_filsys fs, ext2_filsys journal_dev)
{
struct stat st;
errcode_t retval;
char buf[SUPERBLOCK_SIZE];
journal_superblock_t *jsb;
int start;
__u32 i, nr_users;
/* Make sure the device exists and is a block device */
if (stat(journal_dev->device_name, &st) < 0)
return errno;
if (!S_ISBLK(st.st_mode))
return EXT2_ET_JOURNAL_NOT_BLOCK; /* Must be a block device */
/* Get the journal superblock */
start = ext2fs_journal_sb_start(journal_dev->blocksize);
if ((retval = io_channel_read_blk64(journal_dev->io, start,
-SUPERBLOCK_SIZE,
buf)))
return retval;
jsb = (journal_superblock_t *) buf;
if ((jsb->s_header.h_magic != (unsigned) ntohl(JFS_MAGIC_NUMBER)) ||
(jsb->s_header.h_blocktype != (unsigned) ntohl(JFS_SUPERBLOCK_V2)))
return EXT2_ET_NO_JOURNAL_SB;
if (ntohl(jsb->s_blocksize) != (unsigned long) fs->blocksize)
return EXT2_ET_UNEXPECTED_BLOCK_SIZE;
/* Check and see if this filesystem has already been added */
nr_users = ntohl(jsb->s_nr_users);
if (nr_users > JFS_USERS_MAX)
return EXT2_ET_CORRUPT_JOURNAL_SB;
for (i=0; i < nr_users; i++) {
if (memcmp(fs->super->s_uuid,
&jsb->s_users[i*16], 16) == 0)
break;
}
if (i >= nr_users) {
memcpy(&jsb->s_users[nr_users*16],
fs->super->s_uuid, 16);
jsb->s_nr_users = htonl(nr_users+1);
}
/* Writeback the journal superblock */
if ((retval = io_channel_write_blk64(journal_dev->io, start,
-SUPERBLOCK_SIZE, buf)))
return retval;
fs->super->s_journal_inum = 0;
fs->super->s_journal_dev = st.st_rdev;
memcpy(fs->super->s_journal_uuid, jsb->s_uuid,
sizeof(fs->super->s_journal_uuid));
memset(fs->super->s_jnl_blocks, 0, sizeof(fs->super->s_jnl_blocks));
ext2fs_set_feature_journal(fs->super);
ext2fs_mark_super_dirty(fs);
return 0;
}
/*
* This function automatically sets up the journal superblock and
* returns it as an allocated block.
*/
errcode_t ext2fs_create_journal_superblock(ext2_filsys fs,
__u32 num_blocks, int flags,
char **ret_jsb)
{
errcode_t retval;
journal_superblock_t *jsb;
if (num_blocks < JFS_MIN_JOURNAL_BLOCKS)
return EXT2_ET_JOURNAL_TOO_SMALL;
if ((retval = ext2fs_get_mem(fs->blocksize, &jsb)))
return retval;
memset (jsb, 0, fs->blocksize);
jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER);
if (flags & EXT2_MKJOURNAL_V1_SUPER)
jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V1);
else
jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2);
jsb->s_blocksize = htonl(fs->blocksize);
jsb->s_maxlen = htonl(num_blocks);
jsb->s_nr_users = htonl(1);
jsb->s_first = htonl(1);
jsb->s_sequence = htonl(1);
memcpy(jsb->s_uuid, fs->super->s_uuid, sizeof(fs->super->s_uuid));
/*
* If we're creating an external journal device, we need to
* adjust these fields.
*/
if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
jsb->s_nr_users = 0;
jsb->s_first = htonl(ext2fs_journal_sb_start(fs->blocksize) + 1);
}
*ret_jsb = (char *) jsb;
return 0;
}
static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
{
struct process_block_struct pb;
struct ext2_super_block *sb = ctx->fs->super;
struct ext2_super_block jsuper;
struct problem_context pctx;
struct buffer_head *bh;
struct inode *j_inode = NULL;
struct kdev_s *dev_fs = NULL, *dev_journal;
const char *journal_name = 0;
journal_t *journal = NULL;
errcode_t retval = 0;
io_manager io_ptr = 0;
unsigned long long start = 0;
int ext_journal = 0;
int tried_backup_jnl = 0;
clear_problem_context(&pctx);
journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal");
if (!journal) {
return EXT2_ET_NO_MEMORY;
}
dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev");
if (!dev_fs) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
dev_journal = dev_fs+1;
dev_fs->k_ctx = dev_journal->k_ctx = ctx;
dev_fs->k_dev = K_DEV_FS;
dev_journal->k_dev = K_DEV_JOURNAL;
journal->j_dev = dev_journal;
journal->j_fs_dev = dev_fs;
journal->j_inode = NULL;
journal->j_blocksize = ctx->fs->blocksize;
if (uuid_is_null(sb->s_journal_uuid)) {
if (!sb->s_journal_inum) {
retval = EXT2_ET_BAD_INODE_NUM;
goto errout;
}
j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode),
"journal inode");
if (!j_inode) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
j_inode->i_ctx = ctx;
j_inode->i_ino = sb->s_journal_inum;
if ((retval = ext2fs_read_inode(ctx->fs,
sb->s_journal_inum,
&j_inode->i_ext2))) {
try_backup_journal:
if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
tried_backup_jnl)
goto errout;
memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
EXT2_N_BLOCKS*4);
j_inode->i_ext2.i_size_high = sb->s_jnl_blocks[15];
j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
j_inode->i_ext2.i_links_count = 1;
j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
e2fsck_use_inode_shortcuts(ctx, 1);
ctx->stashed_ino = j_inode->i_ino;
ctx->stashed_inode = &j_inode->i_ext2;
tried_backup_jnl++;
}
if (!j_inode->i_ext2.i_links_count ||
!LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
retval = EXT2_ET_NO_JOURNAL;
goto try_backup_journal;
}
if (EXT2_I_SIZE(&j_inode->i_ext2) / journal->j_blocksize <
JFS_MIN_JOURNAL_BLOCKS) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
pb.last_block = -1;
retval = ext2fs_block_iterate3(ctx->fs, j_inode->i_ino,
BLOCK_FLAG_HOLE, 0,
process_journal_block, &pb);
if ((pb.last_block + 1) * ctx->fs->blocksize <
(int) EXT2_I_SIZE(&j_inode->i_ext2)) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
if (tried_backup_jnl && !(ctx->options & E2F_OPT_READONLY)) {
retval = ext2fs_write_inode(ctx->fs, sb->s_journal_inum,
&j_inode->i_ext2);
if (retval)
goto errout;
}
journal->j_maxlen = EXT2_I_SIZE(&j_inode->i_ext2) /
journal->j_blocksize;
#ifdef USE_INODE_IO
retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum,
&j_inode->i_ext2,
&journal_name);
if (retval)
goto errout;
io_ptr = inode_io_manager;
#else
journal->j_inode = j_inode;
ctx->journal_io = ctx->fs->io;
if ((retval = (errcode_t) journal_bmap(journal, 0, &start)) != 0)
goto errout;
#endif
} else {
ext_journal = 1;
if (!ctx->journal_name) {
char uuid[37];
uuid_unparse(sb->s_journal_uuid, uuid);
ctx->journal_name = blkid_get_devname(ctx->blkid,
"UUID", uuid);
if (!ctx->journal_name)
ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
}
journal_name = ctx->journal_name;
if (!journal_name) {
fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
goto errout;
}
jfs_debug(1, "Using journal file %s\n", journal_name);
io_ptr = unix_io_manager;
}
#if 0
test_io_backing_manager = io_ptr;
io_ptr = test_io_manager;
#endif
#ifndef USE_INODE_IO
if (ext_journal)
#endif
{
int flags = IO_FLAG_RW;
if (!(ctx->mount_flags & EXT2_MF_ISROOT &&
ctx->mount_flags & EXT2_MF_READONLY))
flags |= IO_FLAG_EXCLUSIVE;
if ((ctx->mount_flags & EXT2_MF_READONLY) &&
(ctx->options & E2F_OPT_FORCE))
flags &= ~IO_FLAG_EXCLUSIVE;
retval = io_ptr->open(journal_name, flags,
&ctx->journal_io);
}
if (retval)
goto errout;
io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
if (ext_journal) {
blk64_t maxlen;
start = ext2fs_journal_sb_start(ctx->fs->blocksize) - 1;
bh = getblk(dev_journal, start, ctx->fs->blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
ll_rw_block(READ, 1, &bh);
if ((retval = bh->b_err) != 0) {
brelse(bh);
goto errout;
}
memcpy(&jsuper, start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET,
sizeof(jsuper));
#ifdef WORDS_BIGENDIAN
if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(&jsuper);
#endif
if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
!(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Make sure the journal UUID is correct */
if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid,
sizeof(jsuper.s_uuid))) {
fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx);
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Check the superblock checksum */
if (jsuper.s_feature_ro_compat &
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
struct struct_ext2_filsys fsx;
struct ext2_super_block superx;
void *p;
p = start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET;
memcpy(&fsx, ctx->fs, sizeof(fsx));
memcpy(&superx, ctx->fs->super, sizeof(superx));
fsx.super = &superx;
fsx.super->s_feature_ro_compat |=
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM;
if (!ext2fs_superblock_csum_verify(&fsx, p) &&
fix_problem(ctx, PR_0_EXT_JOURNAL_SUPER_CSUM_INVALID,
&pctx)) {
ext2fs_superblock_csum_set(&fsx, p);
mark_buffer_dirty(bh);
}
}
brelse(bh);
maxlen = ext2fs_blocks_count(&jsuper);
journal->j_maxlen = (maxlen < 1ULL << 32) ? maxlen : (1ULL << 32) - 1;
start++;
}
if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
journal->j_sb_buffer = bh;
journal->j_superblock = (journal_superblock_t *)bh->b_data;
#ifdef USE_INODE_IO
if (j_inode)
ext2fs_free_mem(&j_inode);
#endif
*ret_journal = journal;
e2fsck_use_inode_shortcuts(ctx, 0);
return 0;
errout:
e2fsck_use_inode_shortcuts(ctx, 0);
if (dev_fs)
ext2fs_free_mem(&dev_fs);
if (j_inode)
ext2fs_free_mem(&j_inode);
if (journal)
ext2fs_free_mem(&journal);
return retval;
}
static errcode_t ext2fs_get_journal(ext2_filsys fs, journal_t **ret_journal)
{
struct process_block_struct pb;
struct ext2_super_block *sb = fs->super;
struct ext2_super_block jsuper;
struct buffer_head *bh;
struct inode *j_inode = NULL;
struct kdev_s *dev_fs = NULL, *dev_journal;
const char *journal_name = 0;
journal_t *journal = NULL;
errcode_t retval = 0;
io_manager io_ptr = 0;
unsigned long long start = 0;
int ext_journal = 0;
int tried_backup_jnl = 0;
retval = ext2fs_get_memzero(sizeof(journal_t), &journal);
if (retval)
return retval;
retval = ext2fs_get_memzero(2 * sizeof(struct kdev_s), &dev_fs);
if (retval)
goto errout;
dev_journal = dev_fs+1;
dev_fs->k_fs = dev_journal->k_fs = fs;
dev_fs->k_dev = K_DEV_FS;
dev_journal->k_dev = K_DEV_JOURNAL;
journal->j_dev = dev_journal;
journal->j_fs_dev = dev_fs;
journal->j_inode = NULL;
journal->j_blocksize = fs->blocksize;
if (uuid_is_null(sb->s_journal_uuid)) {
if (!sb->s_journal_inum) {
retval = EXT2_ET_BAD_INODE_NUM;
goto errout;
}
retval = ext2fs_get_memzero(sizeof(*j_inode), &j_inode);
if (retval)
goto errout;
j_inode->i_fs = fs;
j_inode->i_ino = sb->s_journal_inum;
retval = ext2fs_read_inode(fs, sb->s_journal_inum,
&j_inode->i_ext2);
if (retval) {
try_backup_journal:
if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
tried_backup_jnl)
goto errout;
memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
EXT2_N_BLOCKS*4);
j_inode->i_ext2.i_size_high = sb->s_jnl_blocks[15];
j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
j_inode->i_ext2.i_links_count = 1;
j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
tried_backup_jnl++;
}
if (!j_inode->i_ext2.i_links_count ||
!LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
retval = EXT2_ET_NO_JOURNAL;
goto try_backup_journal;
}
if (EXT2_I_SIZE(&j_inode->i_ext2) / journal->j_blocksize <
JFS_MIN_JOURNAL_BLOCKS) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
pb.last_block = -1;
retval = ext2fs_block_iterate3(fs, j_inode->i_ino,
BLOCK_FLAG_HOLE, 0,
process_journal_block, &pb);
if ((pb.last_block + 1) * fs->blocksize <
(int) EXT2_I_SIZE(&j_inode->i_ext2)) {
retval = EXT2_ET_JOURNAL_TOO_SMALL;
goto try_backup_journal;
}
if (tried_backup_jnl && (fs->flags & EXT2_FLAG_RW)) {
retval = ext2fs_write_inode(fs, sb->s_journal_inum,
&j_inode->i_ext2);
if (retval)
goto errout;
}
journal->j_maxlen = EXT2_I_SIZE(&j_inode->i_ext2) /
journal->j_blocksize;
#ifdef USE_INODE_IO
retval = ext2fs_inode_io_intern2(fs, sb->s_journal_inum,
&j_inode->i_ext2,
&journal_name);
if (retval)
goto errout;
io_ptr = inode_io_manager;
#else
journal->j_inode = j_inode;
fs->journal_io = fs->io;
retval = (errcode_t)journal_bmap(journal, 0, &start);
if (retval)
goto errout;
#endif
} else {
ext_journal = 1;
if (!fs->journal_name) {
char uuid[37];
blkid_cache blkid;
blkid_get_cache(&blkid, NULL);
uuid_unparse(sb->s_journal_uuid, uuid);
fs->journal_name = blkid_get_devname(blkid,
"UUID", uuid);
if (!fs->journal_name)
fs->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
blkid_put_cache(blkid);
}
journal_name = fs->journal_name;
if (!journal_name) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
goto errout;
}
jfs_debug(1, "Using journal file %s\n", journal_name);
io_ptr = unix_io_manager;
}
#if 0
test_io_backing_manager = io_ptr;
io_ptr = test_io_manager;
#endif
#ifndef USE_INODE_IO
if (ext_journal)
#endif
{
retval = io_ptr->open(journal_name, fs->flags & EXT2_FLAG_RW,
&fs->journal_io);
}
if (retval)
goto errout;
io_channel_set_blksize(fs->journal_io, fs->blocksize);
if (ext_journal) {
blk64_t maxlen;
start = ext2fs_journal_sb_start(fs->blocksize) - 1;
bh = getblk(dev_journal, start, fs->blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
ll_rw_block(READ, 1, &bh);
retval = bh->b_err;
if (retval) {
brelse(bh);
goto errout;
}
memcpy(&jsuper, start ? bh->b_data :
bh->b_data + SUPERBLOCK_OFFSET,
sizeof(jsuper));
#ifdef WORDS_BIGENDIAN
if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(&jsuper);
#endif
if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
!ext2fs_has_feature_journal_dev(&jsuper)) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Make sure the journal UUID is correct */
if (memcmp(jsuper.s_uuid, fs->super->s_journal_uuid,
sizeof(jsuper.s_uuid))) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
/* Check the superblock checksum */
if (ext2fs_has_feature_metadata_csum(&jsuper)) {
struct struct_ext2_filsys fsx;
struct ext2_super_block superx;
void *p;
p = start ? bh->b_data : bh->b_data + SUPERBLOCK_OFFSET;
memcpy(&fsx, fs, sizeof(fsx));
memcpy(&superx, fs->super, sizeof(superx));
fsx.super = &superx;
ext2fs_set_feature_metadata_csum(fsx.super);
if (!ext2fs_superblock_csum_verify(&fsx, p)) {
retval = EXT2_ET_LOAD_EXT_JOURNAL;
brelse(bh);
goto errout;
}
}
brelse(bh);
maxlen = ext2fs_blocks_count(&jsuper);
journal->j_maxlen = (maxlen < 1ULL << 32) ? maxlen :
(1ULL << 32) - 1;
start++;
}
bh = getblk(dev_journal, start, journal->j_blocksize);
if (!bh) {
retval = EXT2_ET_NO_MEMORY;
goto errout;
}
journal->j_sb_buffer = bh;
journal->j_superblock = (journal_superblock_t *)bh->b_data;
#ifdef USE_INODE_IO
if (j_inode)
ext2fs_free_mem(&j_inode);
#endif
*ret_journal = journal;
return 0;
errout:
if (dev_fs)
ext2fs_free_mem(&dev_fs);
if (j_inode)
ext2fs_free_mem(&j_inode);
if (journal)
ext2fs_free_mem(&journal);
return retval;
}