misc: use EXT2_I_SIZE() consistently to get size

[tools/e2fsprogs.git] / e2fsck / journal.c

diff --git a/e2fsck/journal.c b/e2fsck/journal.c
index 7e30ea5..6d350ee 100644 (file)
--- a/e2fsck/journal.c
+++ b/e2fsck/journal.c
@@ -43,7 +43,7 @@ static int bh_count = 0;
  * to use the recovery.c file virtually unchanged from the kernel, so we
  * don't have to do much to keep kernel and user recovery in sync.
  */
-int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys)
+int journal_bmap(journal_t *journal, blk64_t block, unsigned long *phys)
 {
 #ifdef USE_INODE_IO
        *phys = block;
@@ -51,21 +51,21 @@ int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys)
 #else
        struct inode    *inode = journal->j_inode;
        errcode_t       retval;
-       blk_t           pblk;
+       blk64_t         pblk;
 
        if (!inode) {
                *phys = block;
                return 0;
        }
 
-       retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino,
-                           &inode->i_ext2, NULL, 0, block, &pblk);
+       retval= ext2fs_bmap2(inode->i_ctx->fs, inode->i_ino,
+                            &inode->i_ext2, NULL, 0, block, 0, &pblk);
        *phys = pblk;
        return (retval);
 #endif
 }
 
-struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize)
+struct buffer_head *getblk(kdev_t kdev, blk64_t blocknr, int blocksize)
 {
        struct buffer_head *bh;
        int bufsize = sizeof(*bh) + kdev->k_ctx->fs->blocksize -
@@ -203,19 +203,19 @@ struct process_block_struct {
 };
 
 static int process_journal_block(ext2_filsys fs,
-                                blk_t  *block_nr,
+                                blk64_t        *block_nr,
                                 e2_blkcnt_t blockcnt,
-                                blk_t ref_block EXT2FS_ATTR((unused)),
+                                blk64_t ref_block EXT2FS_ATTR((unused)),
                                 int ref_offset EXT2FS_ATTR((unused)),
                                 void *priv_data)
 {
        struct process_block_struct *p;
-       blk_t   blk = *block_nr;
+       blk64_t blk = *block_nr;
 
        p = (struct process_block_struct *) priv_data;
 
-       if (blk < fs->super->s_first_data_block ||
-           blk >= fs->super->s_blocks_count)
+       if (!blk || blk < fs->super->s_first_data_block ||
+           blk >= ext2fs_blocks_count(fs->super))
                return BLOCK_ABORT;
 
        if (blockcnt >= 0)
@@ -288,6 +288,7 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
                        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;
@@ -301,17 +302,17 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
                        retval = EXT2_ET_NO_JOURNAL;
                        goto try_backup_journal;
                }
-               if (j_inode->i_ext2.i_size / journal->j_blocksize <
+               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_iterate2(ctx->fs, j_inode->i_ino,
+               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 <
-                   j_inode->i_ext2.i_size) {
+               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;
                }
@@ -322,7 +323,8 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
                                goto errout;
                }
 
-               journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize;
+               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,
@@ -368,7 +370,8 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
 #ifndef USE_INODE_IO
        if (ext_journal)
 #endif
-               retval = io_ptr->open(journal_name, IO_FLAG_RW,
+               retval = io_ptr->open(journal_name,
+                                     IO_FLAG_RW | IO_FLAG_EXCLUSIVE,
                                      &ctx->journal_io);
        if (retval)
                goto errout;
@@ -409,7 +412,7 @@ static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
                        goto errout;
                }
 
-               journal->j_maxlen = jsuper.s_blocks_count;
+               journal->j_maxlen = ext2fs_blocks_count(&jsuper);
                start++;
        }
 
@@ -942,6 +945,7 @@ void e2fsck_move_ext3_journal(e2fsck_t ctx)
                if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) {
                        memcpy(sb->s_jnl_blocks, inode.i_block,
                               EXT2_N_BLOCKS*4);
+                       sb->s_jnl_blocks[15] = inode.i_size_high;
                        sb->s_jnl_blocks[16] = inode.i_size;
                        sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
                        ext2fs_mark_super_dirty(fs);
@@ -1011,7 +1015,7 @@ void e2fsck_move_ext3_journal(e2fsck_t ctx)
        group = ext2fs_group_of_ino(fs, ino);
        ext2fs_unmark_inode_bitmap2(fs->inode_map, ino);
        ext2fs_mark_ib_dirty(fs);
-       fs->group_desc[group].bg_free_inodes_count++;
+       ext2fs_bg_free_inodes_count_set(fs, group, ext2fs_bg_free_inodes_count(fs, group) + 1);
        ext2fs_group_desc_csum_set(fs, group);
        fs->super->s_free_inodes_count++;
        return;