static int block_map_looks_insane(ext2_filsys fs,
struct ext2_inode_large *inode)
{
unsigned int i, bad;
/* We're only interested in block mapped files, dirs, and symlinks */
if ((inode->i_flags & EXT4_INLINE_DATA_FL) ||
(inode->i_flags & EXT4_EXTENTS_FL))
return 0;
if (!LINUX_S_ISREG(inode->i_mode) &&
!LINUX_S_ISLNK(inode->i_mode) &&
!LINUX_S_ISDIR(inode->i_mode))
return 0;
if (LINUX_S_ISLNK(inode->i_mode) &&
EXT2_I_SIZE(inode) <= sizeof(inode->i_block))
return 0;
/* Unused inodes probably aren't insane */
if (inode->i_links_count == 0)
return 0;
/* See if more than half the block maps are insane */
for (i = 0, bad = 0; i < EXT2_N_BLOCKS; i++)
if (inode->i_block[i] != 0 &&
(inode->i_block[i] < fs->super->s_first_data_block ||
inode->i_block[i] >= ext2fs_blocks_count(fs->super)))
bad++;
return bad > EXT2_N_BLOCKS / 2;
}
/*
* This fuction deallocates an inode
*/
static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf)
{
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
struct problem_context pctx;
__u32 count;
struct del_block del_block;
e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
e2fsck_clear_inode(ctx, ino, &inode, 0, "deallocate_inode");
clear_problem_context(&pctx);
pctx.ino = ino;
/*
* Fix up the bitmaps...
*/
e2fsck_read_bitmaps(ctx);
ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
if (ext2fs_file_acl_block(fs, &inode) &&
(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
pctx.errcode = ext2fs_adjust_ea_refcount3(fs,
ext2fs_file_acl_block(fs, &inode),
block_buf, -1, &count, ino);
if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
pctx.errcode = 0;
count = 1;
}
if (pctx.errcode) {
pctx.blk = ext2fs_file_acl_block(fs, &inode);
fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
if (count == 0) {
ext2fs_unmark_block_bitmap2(ctx->block_found_map,
ext2fs_file_acl_block(fs, &inode));
ext2fs_block_alloc_stats2(fs,
ext2fs_file_acl_block(fs, &inode), -1);
}
ext2fs_file_acl_block_set(fs, &inode, 0);
}
if (!ext2fs_inode_has_valid_blocks2(fs, &inode))
return;
if (LINUX_S_ISREG(inode.i_mode) && EXT2_I_SIZE(&inode) >= 0x80000000UL)
ctx->large_files--;
del_block.ctx = ctx;
del_block.num = 0;
pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, block_buf,
deallocate_inode_block,
&del_block);
if (pctx.errcode) {
fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
}
int ext2_open_r (struct _reent *r, void *fileStruct, const char *path, int flags, int mode)
{
//ext2_log_trace("fileStruct %p, path %s, flags %i, mode %i\n", fileStruct, path, flags, mode);
ext2_file_state* file = STATE(fileStruct);
// Get the volume descriptor for this path
file->vd = ext2GetVolume(path);
if (!file->vd) {
r->_errno = ENODEV;
return -1;
}
// Lock
ext2Lock(file->vd);
// Determine which mode the file is opened for
file->flags = flags;
if ((flags & 0x03) == O_RDONLY) {
file->read = true;
file->write = false;
file->append = false;
} else if ((flags & 0x03) == O_WRONLY) {
file->read = false;
file->write = true;
file->append = (flags & O_APPEND);
} else if ((flags & 0x03) == O_RDWR) {
file->read = true;
file->write = true;
file->append = (flags & O_APPEND);
} else {
r->_errno = EACCES;
ext2Unlock(file->vd);
return -1;
}
// Try and find the file and (if found) ensure that it is not a directory
file->ni = ext2OpenEntry(file->vd, path);
if (file->ni && LINUX_S_ISDIR(file->ni->ni.i_mode))
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = EISDIR;
return -1;
}
// Are we creating this file?
if ((flags & O_CREAT) && !file->ni)
// Create the file
file->ni = ext2Create(file->vd, path, S_IFREG, NULL);
// exit(0);
// Sanity check, the file should be open by now
if (!file->ni) {
ext2Unlock(file->vd);
r->_errno = ENOENT;
return -1;
}
// Make sure we aren't trying to write to a read-only file
if (!(file->vd->fs->flags & EXT2_FLAG_RW) && file->write)
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = EROFS;
return -1;
}
errcode_t err = ext2fs_file_open2(file->vd->fs, file->ni->ino, &file->ni->ni,
file->write ? EXT2_FLAG_RW : 0, &file->fd);
if(err != 0)
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = ENOENT;
return -1;
}
// Truncate the file if requested
if ((flags & O_TRUNC) && file->write) {
if (ext2fs_file_set_size2(file->fd, 0) != 0) {
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = errno;
return -1;
}
file->ni->ni.i_size = file->ni->ni.i_size_high = 0;
}
// Set the files current position
ext2fs_file_llseek(file->fd, file->append ? EXT2_I_SIZE(&file->ni->ni) : 0, SEEK_SET, 0);
//ext2_log_trace("file->len %lld\n", EXT2_I_SIZE(&file->ni->ni));
// Update file times
ext2UpdateTimes(file->vd, file->ni, EXT2_UPDATE_ATIME);
// Insert the file into the double-linked FILO list of open files
if (file->vd->firstOpenFile) {
file->nextOpenFile = file->vd->firstOpenFile;
file->vd->firstOpenFile->prevOpenFile = file;
} else {
file->nextOpenFile = NULL;
}
file->prevOpenFile = NULL;
file->vd->firstOpenFile = file;
file->vd->openFileCount++;
// Sync access time
ext2Sync(file->vd, file->ni);
file->is_ntfs = 0;
// Unlock
ext2Unlock(file->vd);
return (int)(s64)fileStruct;
}
/*
* This function expands '%IX' expressions
*/
static _INLINE_ void expand_inode_expression(FILE *f, ext2_filsys fs, char ch,
struct problem_context *ctx)
{
struct ext2_inode *inode;
struct ext2_inode_large *large_inode;
if (!ctx || !ctx->inode)
goto no_inode;
inode = ctx->inode;
large_inode = (struct ext2_inode_large *) inode;
switch (ch) {
case 's':
if (LINUX_S_ISDIR(inode->i_mode))
fprintf(f, "%u", inode->i_size);
else {
#ifdef EXT2_NO_64_TYPE
if (inode->i_size_high)
fprintf(f, "0x%x%08x", inode->i_size_high,
inode->i_size);
else
fprintf(f, "%u", inode->i_size);
#else
fprintf(f, "%llu", EXT2_I_SIZE(inode));
#endif
}
break;
case 'S':
fprintf(f, "%u", large_inode->i_extra_isize);
break;
case 'b':
if (ext2fs_has_feature_huge_file(fs->super))
fprintf(f, "%llu", inode->i_blocks +
(((long long) inode->osd2.linux2.l_i_blocks_hi)
<< 32));
else
fprintf(f, "%u", inode->i_blocks);
break;
case 'l':
fprintf(f, "%d", inode->i_links_count);
break;
case 'm':
fprintf(f, "0%o", inode->i_mode);
break;
case 'M':
print_time(f, inode->i_mtime);
break;
case 'F':
fprintf(f, "%u", inode->i_faddr);
break;
case 'f':
fprintf(f, "%llu", ext2fs_file_acl_block(fs, inode));
break;
case 'd':
fprintf(f, "%u", (LINUX_S_ISDIR(inode->i_mode) ?
inode->i_dir_acl : 0));
break;
case 'u':
fprintf(f, "%d", inode_uid(*inode));
break;
case 'g':
fprintf(f, "%d", inode_gid(*inode));
break;
case 't':
if (LINUX_S_ISREG(inode->i_mode))
fputs(_("regular file"), f);
else if (LINUX_S_ISDIR(inode->i_mode))
fputs(_("directory"), f);
else if (LINUX_S_ISCHR(inode->i_mode))
fputs(_("character device"), f);
else if (LINUX_S_ISBLK(inode->i_mode))
fputs(_("block device"), f);
else if (LINUX_S_ISFIFO(inode->i_mode))
fputs(_("named pipe"), f);
else if (LINUX_S_ISLNK(inode->i_mode))
fputs(_("symbolic link"), f);
else if (LINUX_S_ISSOCK(inode->i_mode))
fputs(_("socket"), f);
else
fprintf(f, _("unknown file type with mode 0%o"),
inode->i_mode);
break;
default:
no_inode:
fprintf(f, "%%I%c", ch);
break;
}
}
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 <
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 = 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
retval = io_ptr->open(journal_name,
IO_FLAG_RW | IO_FLAG_EXCLUSIVE,
&ctx->journal_io);
if (retval)
goto errout;
io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
if (ext_journal) {
if (ctx->fs->blocksize == 1024)
start = 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 + 1024,
sizeof(jsuper));
brelse(bh);
#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;
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;
goto errout;
}
journal->j_maxlen = ext2fs_blocks_count(&jsuper);
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;
}
extern errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino,
struct ext2_inode *inode,
ext2_extent_handle_t *ret_handle)
{
struct ext2_extent_handle *handle;
errcode_t retval;
int i;
struct ext3_extent_header *eh;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if (!inode)
if ((ino == 0) || (ino > fs->super->s_inodes_count))
return EXT2_ET_BAD_INODE_NUM;
retval = ext2fs_get_mem(sizeof(struct ext2_extent_handle), &handle);
if (retval)
return retval;
memset(handle, 0, sizeof(struct ext2_extent_handle));
handle->ino = ino;
handle->fs = fs;
if (inode) {
handle->inode = inode;
} else {
handle->inode = &handle->inodebuf;
retval = ext2fs_read_inode(fs, ino, handle->inode);
if (retval)
goto errout;
}
eh = (struct ext3_extent_header *) &handle->inode->i_block[0];
for (i=0; i < EXT2_N_BLOCKS; i++)
if (handle->inode->i_block[i])
break;
if (i >= EXT2_N_BLOCKS) {
eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
eh->eh_depth = 0;
eh->eh_entries = 0;
i = (sizeof(handle->inode->i_block) - sizeof(*eh)) /
sizeof(struct ext3_extent);
eh->eh_max = ext2fs_cpu_to_le16(i);
handle->inode->i_flags |= EXT4_EXTENTS_FL;
}
if (!(handle->inode->i_flags & EXT4_EXTENTS_FL)) {
retval = EXT2_ET_INODE_NOT_EXTENT;
goto errout;
}
retval = ext2fs_extent_header_verify(eh, sizeof(handle->inode->i_block));
if (retval)
goto errout;
handle->max_depth = ext2fs_le16_to_cpu(eh->eh_depth);
handle->type = ext2fs_le16_to_cpu(eh->eh_magic);
retval = ext2fs_get_mem(((handle->max_depth+1) *
sizeof(struct extent_path)),
&handle->path);
memset(handle->path, 0,
(handle->max_depth+1) * sizeof(struct extent_path));
handle->path[0].buf = (char *) handle->inode->i_block;
handle->path[0].left = handle->path[0].entries =
ext2fs_le16_to_cpu(eh->eh_entries);
handle->path[0].max_entries = ext2fs_le16_to_cpu(eh->eh_max);
handle->path[0].curr = 0;
handle->path[0].end_blk =
(EXT2_I_SIZE(handle->inode) + fs->blocksize - 1) >>
EXT2_BLOCK_SIZE_BITS(fs->super);
handle->path[0].visit_num = 1;
handle->level = 0;
handle->magic = EXT2_ET_MAGIC_EXTENT_HANDLE;
*ret_handle = handle;
return 0;
errout:
ext2fs_extent_free(handle);
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;
}
