From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Mark Fasheh To: linux-fsdevel@vger.kernel.org Cc: linux-kernel@vger.kernel.org, linux-btrfs@vger.kernel.org, Mark Fasheh Subject: [PATCH 31/76] fs/ext4: Use inode_sb() helper instead of inode->i_sb Date: Tue, 8 May 2018 11:03:51 -0700 Message-Id: <20180508180436.716-32-mfasheh@suse.de> In-Reply-To: <20180508180436.716-1-mfasheh@suse.de> References: <20180508180436.716-1-mfasheh@suse.de> Sender: linux-kernel-owner@vger.kernel.org List-ID: Signed-off-by: Mark Fasheh --- fs/ext4/acl.c | 2 +- fs/ext4/balloc.c | 14 +-- fs/ext4/block_validity.c | 4 +- fs/ext4/dir.c | 12 +- fs/ext4/ext4.h | 8 +- fs/ext4/ext4_jbd2.c | 10 +- fs/ext4/ext4_jbd2.h | 14 +-- fs/ext4/extents.c | 107 ++++++++--------- fs/ext4/extents_status.c | 23 ++-- fs/ext4/file.c | 22 ++-- fs/ext4/fsync.c | 15 +-- fs/ext4/ialloc.c | 7 +- fs/ext4/indirect.c | 53 ++++----- fs/ext4/inline.c | 53 ++++----- fs/ext4/inode.c | 295 ++++++++++++++++++++++++----------------------- fs/ext4/ioctl.c | 24 ++-- fs/ext4/mballoc.c | 13 ++- fs/ext4/migrate.c | 44 +++---- fs/ext4/move_extent.c | 10 +- fs/ext4/namei.c | 224 +++++++++++++++++------------------ fs/ext4/page-io.c | 9 +- fs/ext4/readpage.c | 2 +- fs/ext4/resize.c | 4 +- fs/ext4/super.c | 52 +++++---- fs/ext4/symlink.c | 2 +- fs/ext4/sysfs.c | 4 +- fs/ext4/truncate.h | 4 +- fs/ext4/xattr.c | 120 ++++++++++--------- fs/ext4/xattr_user.c | 4 +- 29 files changed, 591 insertions(+), 564 deletions(-) diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c index fb50f9aa6ead..651d49de6039 100644 --- a/fs/ext4/acl.c +++ b/fs/ext4/acl.c @@ -259,7 +259,7 @@ ext4_set_acl(struct inode *inode, struct posix_acl *acl, int type) } out_stop: ext4_journal_stop(handle); - if (error == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) + if (error == -ENOSPC && ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry; return error; } diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c index f9b3e0a83526..7ea1ed70bdfe 100644 --- a/fs/ext4/balloc.c +++ b/fs/ext4/balloc.c @@ -654,7 +654,7 @@ ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode, */ if (!(*errp) && (flags & EXT4_MB_DELALLOC_RESERVED)) { dquot_alloc_block_nofail(inode, - EXT4_C2B(EXT4_SB(inode->i_sb), ar.len)); + EXT4_C2B(EXT4_SB(inode_sb(inode)), ar.len)); } return ret; } @@ -855,7 +855,7 @@ ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode) struct ext4_inode_info *ei = EXT4_I(inode); ext4_group_t block_group; ext4_grpblk_t colour; - int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb)); + int flex_size = ext4_flex_bg_size(EXT4_SB(inode_sb(inode))); ext4_fsblk_t bg_start; ext4_fsblk_t last_block; @@ -873,19 +873,19 @@ ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode) if (S_ISREG(inode->i_mode)) block_group++; } - bg_start = ext4_group_first_block_no(inode->i_sb, block_group); - last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1; + bg_start = ext4_group_first_block_no(inode_sb(inode), block_group); + last_block = ext4_blocks_count(EXT4_SB(inode_sb(inode))->s_es) - 1; /* * If we are doing delayed allocation, we don't need take * colour into account. */ - if (test_opt(inode->i_sb, DELALLOC)) + if (test_opt(inode_sb(inode), DELALLOC)) return bg_start; - if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block) + if (bg_start + EXT4_BLOCKS_PER_GROUP(inode_sb(inode)) <= last_block) colour = (current->pid % 16) * - (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16); + (EXT4_BLOCKS_PER_GROUP(inode_sb(inode)) / 16); else colour = (current->pid % 16) * ((last_block - bg_start) / 16); return bg_start + colour; diff --git a/fs/ext4/block_validity.c b/fs/ext4/block_validity.c index 913061c0de1b..4ff7e6e93b18 100644 --- a/fs/ext4/block_validity.c +++ b/fs/ext4/block_validity.c @@ -223,14 +223,14 @@ int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk, int ext4_check_blockref(const char *function, unsigned int line, struct inode *inode, __le32 *p, unsigned int max) { - struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; + struct ext4_super_block *es = EXT4_SB(inode_sb(inode))->s_es; __le32 *bref = p; unsigned int blk; while (bref < p+max) { blk = le32_to_cpu(*bref++); if (blk && - unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb), + unlikely(!ext4_data_block_valid(EXT4_SB(inode_sb(inode)), blk, 1))) { es->s_last_error_block = cpu_to_le64(blk); ext4_error_inode(inode, function, line, blk, diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c index da87cf757f7d..78097b522abd 100644 --- a/fs/ext4/dir.c +++ b/fs/ext4/dir.c @@ -40,9 +40,9 @@ static int ext4_dx_readdir(struct file *, struct dir_context *); */ static int is_dx_dir(struct inode *inode) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); - if (ext4_has_feature_dir_index(inode->i_sb) && + if (ext4_has_feature_dir_index(inode_sb(inode)) && ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) || ((inode->i_size >> sb->s_blocksize_bits) == 1) || ext4_has_inline_data(inode))) @@ -67,7 +67,7 @@ int __ext4_check_dir_entry(const char *function, unsigned int line, { const char *error_msg = NULL; const int rlen = ext4_rec_len_from_disk(de->rec_len, - dir->i_sb->s_blocksize); + inode_sb(dir)->s_blocksize); if (unlikely(rlen < EXT4_DIR_REC_LEN(1))) error_msg = "rec_len is smaller than minimal"; @@ -78,7 +78,7 @@ int __ext4_check_dir_entry(const char *function, unsigned int line, else if (unlikely(((char *) de - buf) + rlen > size)) error_msg = "directory entry across range"; else if (unlikely(le32_to_cpu(de->inode) > - le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count))) + le32_to_cpu(EXT4_SB(inode_sb(dir))->s_es->s_inodes_count))) error_msg = "inode out of bounds"; else return 0; @@ -108,7 +108,7 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx) struct ext4_dir_entry_2 *de; int err; struct inode *inode = file_inode(file); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct buffer_head *bh = NULL; int dir_has_error = 0; struct fscrypt_str fstr = FSTR_INIT(NULL, 0); @@ -502,7 +502,7 @@ static int call_filldir(struct file *file, struct dir_context *ctx, { struct dir_private_info *info = file->private_data; struct inode *inode = file_inode(file); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); if (!fname) { ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: comm %s: " diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h index 3241475a1733..8a3784d7b51f 100644 --- a/fs/ext4/ext4.h +++ b/fs/ext4/ext4.h @@ -1978,10 +1978,10 @@ static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize) * (c) Daniel Phillips, 2001 */ -#define is_dx(dir) (ext4_has_feature_dir_index((dir)->i_sb) && \ +#define is_dx(dir) (ext4_has_feature_dir_index(inode_sb((dir))) && \ ext4_test_inode_flag((dir), EXT4_INODE_INDEX)) #define EXT4_DIR_LINK_MAX(dir) unlikely((dir)->i_nlink >= EXT4_LINK_MAX && \ - !(ext4_has_feature_dir_nlink((dir)->i_sb) && is_dx(dir))) + !(ext4_has_feature_dir_nlink(inode_sb((dir))) && is_dx(dir))) #define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1) /* Legal values for the dx_root hash_version field: */ @@ -2341,7 +2341,7 @@ void ext4_insert_dentry(struct inode *inode, struct ext4_filename *fname); static inline void ext4_update_dx_flag(struct inode *inode) { - if (!ext4_has_feature_dir_index(inode->i_sb)) + if (!ext4_has_feature_dir_index(inode_sb(inode))) ext4_clear_inode_flag(inode, EXT4_INODE_INDEX); } static const unsigned char ext4_filetype_table[] = { @@ -2924,7 +2924,7 @@ static inline void ext4_unlock_group(struct super_block *sb, #define ext4_check_indirect_blockref(inode, bh) \ ext4_check_blockref(__func__, __LINE__, inode, \ (__le32 *)(bh)->b_data, \ - EXT4_ADDR_PER_BLOCK((inode)->i_sb)) + EXT4_ADDR_PER_BLOCK(inode_sb((inode)))) #define ext4_ind_check_inode(inode) \ ext4_check_blockref(__func__, __LINE__, inode, \ diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c index 2d593201cf7a..151323c6844b 100644 --- a/fs/ext4/ext4_jbd2.c +++ b/fs/ext4/ext4_jbd2.c @@ -207,7 +207,7 @@ int __ext4_forget(const char *where, unsigned int line, handle_t *handle, jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, " "data mode %x\n", bh, is_metadata, inode->i_mode, - test_opt(inode->i_sb, DATA_FLAGS)); + test_opt(inode_sb(inode), DATA_FLAGS)); /* In the no journal case, we can just do a bforget and return */ if (!ext4_handle_valid(handle)) { @@ -220,7 +220,7 @@ int __ext4_forget(const char *where, unsigned int line, handle_t *handle, * support it. Otherwise, only skip the revoke on un-journaled * data blocks. */ - if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || + if (test_opt(inode_sb(inode), DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || (!is_metadata && !ext4_should_journal_data(inode))) { if (bh) { BUFFER_TRACE(bh, "call jbd2_journal_forget"); @@ -241,8 +241,8 @@ int __ext4_forget(const char *where, unsigned int line, handle_t *handle, if (err) { ext4_journal_abort_handle(where, line, __func__, bh, handle, err); - __ext4_abort(inode->i_sb, where, line, - "error %d when attempting revoke", err); + __ext4_abort(inode_sb(inode), where, line, + "error %d when attempting revoke", err); } BUFFER_TRACE(bh, "exit"); return err; @@ -308,7 +308,7 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line, if (buffer_req(bh) && !buffer_uptodate(bh)) { struct ext4_super_block *es; - es = EXT4_SB(inode->i_sb)->s_es; + es = EXT4_SB(inode_sb(inode))->s_es; es->s_last_error_block = cpu_to_le64(bh->b_blocknr); ext4_error_inode(inode, where, line, diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h index 15b6dd733780..029cfddd9035 100644 --- a/fs/ext4/ext4_jbd2.h +++ b/fs/ext4/ext4_jbd2.h @@ -16,7 +16,7 @@ #include #include "ext4.h" -#define EXT4_JOURNAL(inode) (EXT4_SB((inode)->i_sb)->s_journal) +#define EXT4_JOURNAL(inode) (EXT4_SB(inode_sb((inode)))->s_journal) /* Define the number of blocks we need to account to a transaction to * modify one block of data. @@ -308,7 +308,7 @@ static inline handle_t *__ext4_journal_start(struct inode *inode, unsigned int line, int type, int blocks, int rsv_blocks) { - return __ext4_journal_start_sb(inode->i_sb, line, type, blocks, + return __ext4_journal_start_sb(inode_sb(inode), line, type, blocks, rsv_blocks); } @@ -407,17 +407,17 @@ static inline int ext4_inode_journal_mode(struct inode *inode) return EXT4_INODE_WRITEBACK_DATA_MODE; /* writeback */ /* We do not support data journalling with delayed allocation */ if (!S_ISREG(inode->i_mode) || - test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || + test_opt(inode_sb(inode), DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || (ext4_test_inode_flag(inode, EXT4_INODE_JOURNAL_DATA) && - !test_opt(inode->i_sb, DELALLOC))) { + !test_opt(inode_sb(inode), DELALLOC))) { /* We do not support data journalling for encrypted data */ if (S_ISREG(inode->i_mode) && ext4_encrypted_inode(inode)) return EXT4_INODE_ORDERED_DATA_MODE; /* ordered */ return EXT4_INODE_JOURNAL_DATA_MODE; /* journal data */ } - if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) + if (test_opt(inode_sb(inode), DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) return EXT4_INODE_ORDERED_DATA_MODE; /* ordered */ - if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA) + if (test_opt(inode_sb(inode), DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA) return EXT4_INODE_WRITEBACK_DATA_MODE; /* writeback */ BUG(); } @@ -448,7 +448,7 @@ static inline int ext4_should_writeback_data(struct inode *inode) */ static inline int ext4_should_dioread_nolock(struct inode *inode) { - if (!test_opt(inode->i_sb, DIOREAD_NOLOCK)) + if (!test_opt(inode_sb(inode), DIOREAD_NOLOCK)) return 0; if (!S_ISREG(inode->i_mode)) return 0; diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c index 054416e9d827..5001725876ef 100644 --- a/fs/ext4/extents.c +++ b/fs/ext4/extents.c @@ -49,7 +49,7 @@ static __le32 ext4_extent_block_csum(struct inode *inode, struct ext4_extent_header *eh) { struct ext4_inode_info *ei = EXT4_I(inode); - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); __u32 csum; csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh, @@ -62,7 +62,7 @@ static int ext4_extent_block_csum_verify(struct inode *inode, { struct ext4_extent_tail *et; - if (!ext4_has_metadata_csum(inode->i_sb)) + if (!ext4_has_metadata_csum(inode_sb(inode))) return 1; et = find_ext4_extent_tail(eh); @@ -76,7 +76,7 @@ static void ext4_extent_block_csum_set(struct inode *inode, { struct ext4_extent_tail *et; - if (!ext4_has_metadata_csum(inode->i_sb)) + if (!ext4_has_metadata_csum(inode_sb(inode))) return; et = find_ext4_extent_tail(eh); @@ -233,7 +233,7 @@ static inline int ext4_ext_space_block(struct inode *inode, int check) { int size; - size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) + size = (inode_sb(inode)->s_blocksize - sizeof(struct ext4_extent_header)) / sizeof(struct ext4_extent); #ifdef AGGRESSIVE_TEST if (!check && size > 6) @@ -246,7 +246,7 @@ static inline int ext4_ext_space_block_idx(struct inode *inode, int check) { int size; - size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) + size = (inode_sb(inode)->s_blocksize - sizeof(struct ext4_extent_header)) / sizeof(struct ext4_extent_idx); #ifdef AGGRESSIVE_TEST if (!check && size > 5) @@ -307,7 +307,7 @@ int ext4_ext_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock) struct ext4_inode_info *ei = EXT4_I(inode); int idxs; - idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) + idxs = ((inode_sb(inode)->s_blocksize - sizeof(struct ext4_extent_header)) / sizeof(struct ext4_extent_idx)); /* @@ -377,7 +377,7 @@ static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext) */ if (lblock + len <= lblock) return 0; - return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len); + return ext4_data_block_valid(EXT4_SB(inode_sb(inode)), block, len); } static int ext4_valid_extent_idx(struct inode *inode, @@ -385,7 +385,7 @@ static int ext4_valid_extent_idx(struct inode *inode, { ext4_fsblk_t block = ext4_idx_pblock(ext_idx); - return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1); + return ext4_data_block_valid(EXT4_SB(inode_sb(inode)), block, 1); } static int ext4_valid_extent_entries(struct inode *inode, @@ -401,7 +401,7 @@ static int ext4_valid_extent_entries(struct inode *inode, if (depth == 0) { /* leaf entries */ struct ext4_extent *ext = EXT_FIRST_EXTENT(eh); - struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; + struct ext4_super_block *es = EXT4_SB(inode_sb(inode))->s_es; ext4_fsblk_t pblock = 0; ext4_lblk_t lblock = 0; ext4_lblk_t prev = 0; @@ -506,7 +506,7 @@ __read_extent_tree_block(const char *function, unsigned int line, struct buffer_head *bh; int err; - bh = sb_getblk_gfp(inode->i_sb, pblk, __GFP_MOVABLE | GFP_NOFS); + bh = sb_getblk_gfp(inode_sb(inode), pblk, __GFP_MOVABLE | GFP_NOFS); if (unlikely(!bh)) return ERR_PTR(-ENOMEM); @@ -1000,7 +1000,7 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode, } err = ext4_ext_dirty(handle, inode, curp); - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; } @@ -1084,7 +1084,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, err = -EFSCORRUPTED; goto cleanup; } - bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); + bh = sb_getblk_gfp(inode_sb(inode), newblock, + __GFP_MOVABLE | GFP_NOFS); if (unlikely(!bh)) { err = -ENOMEM; goto cleanup; @@ -1157,7 +1158,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, while (k--) { oldblock = newblock; newblock = ablocks[--a]; - bh = sb_getblk(inode->i_sb, newblock); + bh = sb_getblk(inode_sb(inode), newblock); if (unlikely(!bh)) { err = -ENOMEM; goto cleanup; @@ -1262,7 +1263,7 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode, struct ext4_extent_header *neh; struct buffer_head *bh; ext4_fsblk_t newblock, goal = 0; - struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; + struct ext4_super_block *es = EXT4_SB(inode_sb(inode))->s_es; int err = 0; /* Try to prepend new index to old one */ @@ -1278,7 +1279,8 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode, if (newblock == 0) return err; - bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); + bh = sb_getblk_gfp(inode_sb(inode), newblock, + __GFP_MOVABLE | GFP_NOFS); if (unlikely(!bh)) return -ENOMEM; lock_buffer(bh); @@ -2154,7 +2156,7 @@ static int ext4_fill_fiemap_extents(struct inode *inode, ext4_lblk_t last = block + num; int exists, depth = 0, err = 0; unsigned int flags = 0; - unsigned char blksize_bits = inode->i_sb->s_blocksize_bits; + unsigned char blksize_bits = inode_sb(inode)->s_blocksize_bits; while (block < last && block != EXT_MAX_BLOCKS) { num = last - block; @@ -2438,7 +2440,7 @@ int ext4_ext_calc_credits_for_single_extent(struct inode *inode, int nrblocks, * accounted. */ /* 1 bitmap, 1 block group descriptor */ - ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb); + ret = 2 + EXT4_META_TRANS_BLOCKS(inode_sb(inode)); return ret; } } @@ -2489,7 +2491,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode, long long *partial_cluster, ext4_lblk_t from, ext4_lblk_t to) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); unsigned short ee_len = ext4_ext_get_actual_len(ex); ext4_fsblk_t pblk; int flags = get_default_free_blocks_flags(inode); @@ -2520,7 +2522,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode, #ifdef EXTENTS_STATS { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); spin_lock(&sbi->s_ext_stats_lock); sbi->s_ext_blocks += ee_len; sbi->s_ext_extents++; @@ -2605,7 +2607,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, long long *partial_cluster, ext4_lblk_t start, ext4_lblk_t end) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); int err = 0, correct_index = 0; int depth = ext_depth(inode), credits; struct ext4_extent_header *eh; @@ -2693,12 +2695,12 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, * groups plus ex_ee_len/blocks_per_block_group for * the worst case */ - credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb)); + credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode_sb(inode))); if (ex == EXT_FIRST_EXTENT(eh)) { correct_index = 1; credits += (ext_depth(inode)) + 1; } - credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); + credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode_sb(inode)); err = ext4_ext_truncate_extend_restart(handle, inode, credits); if (err) @@ -2810,7 +2812,7 @@ ext4_ext_more_to_rm(struct ext4_ext_path *path) int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); int depth = ext_depth(inode); struct ext4_ext_path *path = NULL; long long partial_cluster = 0; @@ -3414,9 +3416,9 @@ static int ext4_ext_convert_to_initialized(handle_t *handle, "block %llu, max_blocks %u\n", inode->i_ino, (unsigned long long)map->m_lblk, map_len); - sbi = EXT4_SB(inode->i_sb); - eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> - inode->i_sb->s_blocksize_bits; + sbi = EXT4_SB(inode_sb(inode)); + eof_block = (inode->i_size + inode_sb(inode)->s_blocksize - 1) >> + inode_sb(inode)->s_blocksize_bits; if (eof_block < map->m_lblk + map_len) eof_block = map->m_lblk + map_len; @@ -3561,7 +3563,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle, if (EXT4_EXT_MAY_ZEROOUT & split_flag) max_zeroout = sbi->s_extent_max_zeroout_kb >> - (inode->i_sb->s_blocksize_bits - 10); + (inode_sb(inode)->s_blocksize_bits - 10); if (ext4_encrypted_inode(inode)) max_zeroout = 0; @@ -3671,8 +3673,8 @@ static int ext4_split_convert_extents(handle_t *handle, __func__, inode->i_ino, (unsigned long long)map->m_lblk, map->m_len); - eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> - inode->i_sb->s_blocksize_bits; + eof_block = (inode->i_size + inode_sb(inode)->s_blocksize - 1) >> + inode_sb(inode)->s_blocksize_bits; if (eof_block < map->m_lblk + map->m_len) eof_block = map->m_lblk + map->m_len; /* @@ -3838,7 +3840,7 @@ int ext4_find_delalloc_range(struct inode *inode, int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); ext4_lblk_t lblk_start, lblk_end; lblk_start = EXT4_LBLK_CMASK(sbi, lblk); lblk_end = lblk_start + sbi->s_cluster_ratio - 1; @@ -3885,7 +3887,7 @@ static unsigned int get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start, unsigned int num_blks) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); ext4_lblk_t alloc_cluster_start, alloc_cluster_end; ext4_lblk_t lblk_from, lblk_to, c_offset; unsigned int allocated_clusters = 0; @@ -4096,7 +4098,8 @@ ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode, * new. */ if (allocated > map->m_len) { - clean_bdev_aliases(inode->i_sb->s_bdev, newblock + map->m_len, + clean_bdev_aliases(inode_sb(inode)->s_bdev, + newblock + map->m_len, allocated - map->m_len); allocated = map->m_len; } @@ -4263,7 +4266,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, { struct ext4_ext_path *path = NULL; struct ext4_extent newex, *ex, *ex2; - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); ext4_fsblk_t newblock = 0; int free_on_err = 0, err = 0, depth, ret; unsigned int allocated = 0, offset = 0; @@ -4382,7 +4385,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, * by ext4_find_extent() implies a cluster we can use. */ if (cluster_offset && ex && - get_implied_cluster_alloc(inode->i_sb, map, ex, path)) { + get_implied_cluster_alloc(inode_sb(inode), map, ex, path)) { ar.len = allocated = map->m_len; newblock = map->m_pblk; map_from_cluster = true; @@ -4403,7 +4406,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, /* Check if the extent after searching to the right implies a * cluster we can use. */ if ((sbi->s_cluster_ratio > 1) && ex2 && - get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) { + get_implied_cluster_alloc(inode_sb(inode), map, ex2, path)) { ar.len = allocated = map->m_len; newblock = map->m_pblk; map_from_cluster = true; @@ -4607,7 +4610,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, int ext4_ext_truncate(handle_t *handle, struct inode *inode) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); ext4_lblk_t last_block; int err = 0; @@ -4716,7 +4719,7 @@ static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset, break; } if (ret == -ENOSPC && - ext4_should_retry_alloc(inode->i_sb, &retries)) { + ext4_should_retry_alloc(inode_sb(inode), &retries)) { ret = 0; goto retry; } @@ -4746,7 +4749,7 @@ static long ext4_zero_range(struct file *file, loff_t offset, /* Call ext4_force_commit to flush all data in case of data=journal. */ if (ext4_should_journal_data(inode)) { - ret = ext4_force_commit(inode->i_sb); + ret = ext4_force_commit(inode_sb(inode)); if (ret) return ret; } @@ -4849,7 +4852,7 @@ static long ext4_zero_range(struct file *file, loff_t offset, handle = ext4_journal_start(inode, EXT4_HT_MISC, credits); if (IS_ERR(handle)) { ret = PTR_ERR(handle); - ext4_std_error(inode->i_sb, ret); + ext4_std_error(inode_sb(inode), ret); goto out_dio; } @@ -4972,8 +4975,8 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len) if (ret) goto out; - if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) { - ret = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal, + if (file->f_flags & O_SYNC && EXT4_SB(inode_sb(inode))->s_journal) { + ret = jbd2_complete_transaction(EXT4_SB(inode_sb(inode))->s_journal, EXT4_I(inode)->i_sync_tid); } out: @@ -5035,7 +5038,7 @@ int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode, ret = ext4_map_blocks(handle, inode, &map, EXT4_GET_BLOCKS_IO_CONVERT_EXT); if (ret <= 0) - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "inode #%lu: block %u: len %u: " "ext4_ext_map_blocks returned %d", inode->i_ino, map.m_lblk, @@ -5106,7 +5109,7 @@ static int ext4_xattr_fiemap(struct inode *inode, __u64 physical = 0; __u64 length; __u32 flags = FIEMAP_EXTENT_LAST; - int blockbits = inode->i_sb->s_blocksize_bits; + int blockbits = inode_sb(inode)->s_blocksize_bits; int error = 0; /* in-inode? */ @@ -5121,12 +5124,12 @@ static int ext4_xattr_fiemap(struct inode *inode, offset = EXT4_GOOD_OLD_INODE_SIZE + EXT4_I(inode)->i_extra_isize; physical += offset; - length = EXT4_SB(inode->i_sb)->s_inode_size - offset; + length = EXT4_SB(inode_sb(inode))->s_inode_size - offset; flags |= FIEMAP_EXTENT_DATA_INLINE; brelse(iloc.bh); } else { /* external block */ physical = (__u64)EXT4_I(inode)->i_file_acl << blockbits; - length = inode->i_sb->s_blocksize; + length = inode_sb(inode)->s_blocksize; } if (physical) @@ -5171,8 +5174,8 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, ext4_lblk_t len_blks; __u64 last_blk; - start_blk = start >> inode->i_sb->s_blocksize_bits; - last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits; + start_blk = start >> inode_sb(inode)->s_blocksize_bits; + last_blk = (start + len - 1) >> inode_sb(inode)->s_blocksize_bits; if (last_blk >= EXT_MAX_BLOCKS) last_blk = EXT_MAX_BLOCKS-1; len_blks = ((ext4_lblk_t) last_blk) - start_blk + 1; @@ -5433,7 +5436,7 @@ ext4_ext_shift_extents(struct inode *inode, handle_t *handle, */ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); ext4_lblk_t punch_start, punch_stop; handle_t *handle; unsigned int credits; @@ -5463,7 +5466,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len) /* Call ext4_force_commit to flush all data in case of data=journal. */ if (ext4_should_journal_data(inode)) { - ret = ext4_force_commit(inode->i_sb); + ret = ext4_force_commit(inode_sb(inode)); if (ret) return ret; } @@ -5578,7 +5581,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len) */ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); handle_t *handle; struct ext4_ext_path *path; struct ext4_extent *extent; @@ -5610,7 +5613,7 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len) /* Call ext4_force_commit to flush all data in case of data=journal */ if (ext4_should_journal_data(inode)) { - ret = ext4_force_commit(inode->i_sb); + ret = ext4_force_commit(inode_sb(inode)); if (ret) return ret; } @@ -5623,7 +5626,7 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len) } /* Check for wrap through zero */ - if (inode->i_size + len > inode->i_sb->s_maxbytes) { + if (inode->i_size + len > inode_sb(inode)->s_maxbytes) { ret = -EFBIG; goto out_mutex; } diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c index 763ef185dd17..56c59000c9cc 100644 --- a/fs/ext4/extents_status.c +++ b/fs/ext4/extents_status.c @@ -299,7 +299,7 @@ void ext4_es_find_delayed_extent_range(struct inode *inode, static void ext4_es_list_add(struct inode *inode) { struct ext4_inode_info *ei = EXT4_I(inode); - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); if (!list_empty(&ei->i_es_list)) return; @@ -315,7 +315,7 @@ static void ext4_es_list_add(struct inode *inode) static void ext4_es_list_del(struct inode *inode) { struct ext4_inode_info *ei = EXT4_I(inode); - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); spin_lock(&sbi->s_es_lock); if (!list_empty(&ei->i_es_list)) { @@ -344,12 +344,12 @@ ext4_es_alloc_extent(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len, if (!ext4_es_is_delayed(es)) { if (!EXT4_I(inode)->i_es_shk_nr++) ext4_es_list_add(inode); - percpu_counter_inc(&EXT4_SB(inode->i_sb)-> + percpu_counter_inc(&EXT4_SB(inode_sb(inode))-> s_es_stats.es_stats_shk_cnt); } EXT4_I(inode)->i_es_all_nr++; - percpu_counter_inc(&EXT4_SB(inode->i_sb)->s_es_stats.es_stats_all_cnt); + percpu_counter_inc(&EXT4_SB(inode_sb(inode))->s_es_stats.es_stats_all_cnt); return es; } @@ -357,14 +357,14 @@ ext4_es_alloc_extent(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len, static void ext4_es_free_extent(struct inode *inode, struct extent_status *es) { EXT4_I(inode)->i_es_all_nr--; - percpu_counter_dec(&EXT4_SB(inode->i_sb)->s_es_stats.es_stats_all_cnt); + percpu_counter_dec(&EXT4_SB(inode_sb(inode))->s_es_stats.es_stats_all_cnt); /* Decrease the shrink counter when this es is not delayed */ if (!ext4_es_is_delayed(es)) { BUG_ON(EXT4_I(inode)->i_es_shk_nr == 0); if (!--EXT4_I(inode)->i_es_shk_nr) ext4_es_list_del(inode); - percpu_counter_dec(&EXT4_SB(inode->i_sb)-> + percpu_counter_dec(&EXT4_SB(inode_sb(inode))-> s_es_stats.es_stats_shk_cnt); } @@ -706,7 +706,7 @@ int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk, if ((status & EXTENT_STATUS_DELAYED) && (status & EXTENT_STATUS_WRITTEN)) { - ext4_warning(inode->i_sb, "Inserting extent [%u/%u] as " + ext4_warning(inode_sb(inode), "Inserting extent [%u/%u] as " " delayed and written which can potentially " " cause data loss.", lblk, len); WARN_ON(1); @@ -725,7 +725,7 @@ int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk, goto error; retry: err = __es_insert_extent(inode, &newes); - if (err == -ENOMEM && __es_shrink(EXT4_SB(inode->i_sb), + if (err == -ENOMEM && __es_shrink(EXT4_SB(inode_sb(inode)), 128, EXT4_I(inode))) goto retry; if (err == -ENOMEM && !ext4_es_is_delayed(&newes)) @@ -818,7 +818,7 @@ int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk, } out: - stats = &EXT4_SB(inode->i_sb)->s_es_stats; + stats = &EXT4_SB(inode_sb(inode))->s_es_stats; if (found) { BUG_ON(!es1); es->es_lblk = es1->es_lblk; @@ -885,7 +885,7 @@ static int __es_remove_extent(struct inode *inode, ext4_lblk_t lblk, es->es_lblk = orig_es.es_lblk; es->es_len = orig_es.es_len; if ((err == -ENOMEM) && - __es_shrink(EXT4_SB(inode->i_sb), + __es_shrink(EXT4_SB(inode_sb(inode)), 128, EXT4_I(inode))) goto retry; goto out; @@ -1244,7 +1244,8 @@ static int es_reclaim_extents(struct ext4_inode_info *ei, int *nr_to_scan) if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED) && __ratelimit(&_rs)) - ext4_warning(inode->i_sb, "forced shrink of precached extents"); + ext4_warning(inode_sb(inode), + "forced shrink of precached extents"); if (!es_do_reclaim_extents(ei, EXT_MAX_BLOCKS, nr_to_scan, &nr_shrunk) && start != 0) diff --git a/fs/ext4/file.c b/fs/ext4/file.c index fb6f023622fe..d6547085f4d2 100644 --- a/fs/ext4/file.c +++ b/fs/ext4/file.c @@ -64,7 +64,7 @@ static ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to) static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to) { - if (unlikely(ext4_forced_shutdown(EXT4_SB(file_inode(iocb->ki_filp)->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(file_inode(iocb->ki_filp)))))) return -EIO; if (!iov_iter_count(to)) @@ -122,7 +122,7 @@ static void ext4_unwritten_wait(struct inode *inode) static int ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); int blockmask = sb->s_blocksize - 1; if (pos >= i_size_read(inode)) @@ -170,7 +170,7 @@ static ssize_t ext4_write_checks(struct kiocb *iocb, struct iov_iter *from) * is smaller than s_maxbytes, which is for extent-mapped files. */ if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) return -EFBIG; @@ -219,7 +219,7 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from) int overwrite = 0; ssize_t ret; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; #ifdef CONFIG_FS_DAX @@ -284,7 +284,7 @@ static int ext4_dax_huge_fault(struct vm_fault *vmf, int retries = 0; handle_t *handle = NULL; struct inode *inode = file_inode(vmf->vma->vm_file); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); /* * We have to distinguish real writes from writes which will result in a @@ -360,7 +360,7 @@ static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma) { struct inode *inode = file->f_mapping->host; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; /* @@ -382,14 +382,14 @@ static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma) static int ext4_file_open(struct inode * inode, struct file * filp) { - struct super_block *sb = inode->i_sb; - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct super_block *sb = inode_sb(inode); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); struct vfsmount *mnt = filp->f_path.mnt; struct path path; char buf[64], *cp; int ret; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) && @@ -454,9 +454,9 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int whence) loff_t maxbytes; if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) - maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; + maxbytes = EXT4_SB(inode_sb(inode))->s_bitmap_maxbytes; else - maxbytes = inode->i_sb->s_maxbytes; + maxbytes = inode_sb(inode)->s_maxbytes; switch (whence) { default: diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c index 26a7fe5c4fd3..ad5a1fff59ec 100644 --- a/fs/ext4/fsync.c +++ b/fs/ext4/fsync.c @@ -96,22 +96,22 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) { struct inode *inode = file->f_mapping->host; struct ext4_inode_info *ei = EXT4_I(inode); - journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; + journal_t *journal = EXT4_SB(inode_sb(inode))->s_journal; int ret = 0, err; tid_t commit_tid; bool needs_barrier = false; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; J_ASSERT(ext4_journal_current_handle() == NULL); trace_ext4_sync_file_enter(file, datasync); - if (sb_rdonly(inode->i_sb)) { + if (sb_rdonly(inode_sb(inode))) { /* Make sure that we read updated s_mount_flags value */ smp_rmb(); - if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED) + if (EXT4_SB(inode_sb(inode))->s_mount_flags & EXT4_MF_FS_ABORTED) ret = -EROFS; goto out; } @@ -120,7 +120,7 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) ret = __generic_file_fsync(file, start, end, datasync); if (!ret) ret = ext4_sync_parent(inode); - if (test_opt(inode->i_sb, BARRIER)) + if (test_opt(inode_sb(inode), BARRIER)) goto issue_flush; goto out; } @@ -143,7 +143,7 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) * safe in-journal, which is all fsync() needs to ensure. */ if (ext4_should_journal_data(inode)) { - ret = ext4_force_commit(inode->i_sb); + ret = ext4_force_commit(inode_sb(inode)); goto out; } @@ -154,7 +154,8 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync) ret = jbd2_complete_transaction(journal, commit_tid); if (needs_barrier) { issue_flush: - err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); + err = blkdev_issue_flush(inode_sb(inode)->s_bdev, GFP_KERNEL, + NULL); if (!ret) ret = err; } diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c index 7830d28df331..95b8d6077faf 100644 --- a/fs/ext4/ialloc.c +++ b/fs/ext4/ialloc.c @@ -255,7 +255,7 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group) */ void ext4_free_inode(handle_t *handle, struct inode *inode) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); int is_directory; unsigned long ino; struct buffer_head *bitmap_bh = NULL; @@ -795,7 +795,7 @@ struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir, if (!dir || !dir->i_nlink) return ERR_PTR(-EPERM); - sb = dir->i_sb; + sb = inode_sb(dir); sbi = EXT4_SB(sb); if (unlikely(ext4_forced_shutdown(sbi))) @@ -953,7 +953,8 @@ struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir, if (!handle) { BUG_ON(nblocks <= 0); - handle = __ext4_journal_start_sb(dir->i_sb, line_no, + handle = __ext4_journal_start_sb(inode_sb(dir), + line_no, handle_type, nblocks, 0); if (IS_ERR(handle)) { diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c index c32802c956d5..8725e486df18 100644 --- a/fs/ext4/indirect.c +++ b/fs/ext4/indirect.c @@ -58,7 +58,7 @@ static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v) * * Note: function doesn't find node addresses, so no IO is needed. All * we need to know is the capacity of indirect blocks (taken from the - * inode->i_sb). + * inode_sb(inode)). */ /* @@ -75,8 +75,8 @@ static int ext4_block_to_path(struct inode *inode, ext4_lblk_t i_block, ext4_lblk_t offsets[4], int *boundary) { - int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb); - int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb); + int ptrs = EXT4_ADDR_PER_BLOCK(inode_sb(inode)); + int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode_sb(inode)); const long direct_blocks = EXT4_NDIR_BLOCKS, indirect_blocks = ptrs, double_blocks = (1 << (ptrs_bits * 2)); @@ -102,7 +102,7 @@ static int ext4_block_to_path(struct inode *inode, offsets[n++] = i_block & (ptrs - 1); final = ptrs; } else { - ext4_warning(inode->i_sb, "block %lu > max in inode %lu", + ext4_warning(inode_sb(inode), "block %lu > max in inode %lu", i_block + direct_blocks + indirect_blocks + double_blocks, inode->i_ino); } @@ -145,7 +145,7 @@ static Indirect *ext4_get_branch(struct inode *inode, int depth, ext4_lblk_t *offsets, Indirect chain[4], int *err) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); Indirect *p = chain; struct buffer_head *bh; int ret = -EIO; @@ -346,7 +346,8 @@ static int ext4_alloc_branch(handle_t *handle, if (i == 0) continue; - bh = branch[i].bh = sb_getblk(ar->inode->i_sb, new_blocks[i-1]); + bh = branch[i].bh = sb_getblk(inode_sb(ar->inode), + new_blocks[i-1]); if (unlikely(!bh)) { err = -ENOMEM; goto failed; @@ -558,7 +559,7 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode, /* Next simple case - plain lookup failed */ if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { - unsigned epb = inode->i_sb->s_blocksize / sizeof(u32); + unsigned epb = inode_sb(inode)->s_blocksize / sizeof(u32); int i; /* Count number blocks in a subtree under 'partial' */ @@ -578,7 +579,7 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode, /* * Okay, we need to do block allocation. */ - if (ext4_has_feature_bigalloc(inode->i_sb)) { + if (ext4_has_feature_bigalloc(inode_sb(inode))) { EXT4_ERROR_INODE(inode, "Can't allocate blocks for " "non-extent mapped inodes with bigalloc"); return -EFSCORRUPTED; @@ -656,7 +657,7 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode, int ext4_ind_calc_metadata_amount(struct inode *inode, sector_t lblock) { struct ext4_inode_info *ei = EXT4_I(inode); - sector_t dind_mask = ~((sector_t)EXT4_ADDR_PER_BLOCK(inode->i_sb) - 1); + sector_t dind_mask = ~((sector_t)EXT4_ADDR_PER_BLOCK(inode_sb(inode)) - 1); int blk_bits; if (lblock < EXT4_NDIR_BLOCKS) @@ -672,7 +673,7 @@ int ext4_ind_calc_metadata_amount(struct inode *inode, sector_t lblock) ei->i_da_metadata_calc_last_lblock = lblock & dind_mask; ei->i_da_metadata_calc_len = 1; blk_bits = order_base_2(lblock); - return (blk_bits / EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb)) + 1; + return (blk_bits / EXT4_ADDR_PER_BLOCK_BITS(inode_sb(inode))) + 1; } /* @@ -683,10 +684,10 @@ int ext4_ind_trans_blocks(struct inode *inode, int nrblocks) { /* * With N contiguous data blocks, we need at most - * N/EXT4_ADDR_PER_BLOCK(inode->i_sb) + 1 indirect blocks, + * N/EXT4_ADDR_PER_BLOCK(inode_sb(inode)) + 1 indirect blocks, * 2 dindirect blocks, and 1 tindirect block */ - return DIV_ROUND_UP(nrblocks, EXT4_ADDR_PER_BLOCK(inode->i_sb)) + 4; + return DIV_ROUND_UP(nrblocks, EXT4_ADDR_PER_BLOCK(inode_sb(inode))) + 4; } /* @@ -836,7 +837,7 @@ static int ext4_clear_blocks(handle_t *handle, struct inode *inode, else if (ext4_should_journal_data(inode)) flags |= EXT4_FREE_BLOCKS_FORGET; - if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), block_to_free, + if (!ext4_data_block_valid(EXT4_SB(inode_sb(inode)), block_to_free, count)) { EXT4_ERROR_INODE(inode, "attempt to clear invalid " "blocks %llu len %lu", @@ -872,7 +873,7 @@ static int ext4_clear_blocks(handle_t *handle, struct inode *inode, ext4_free_blocks(handle, inode, NULL, block_to_free, count, flags); return 0; out_err: - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; } @@ -992,14 +993,14 @@ static void ext4_free_branches(handle_t *handle, struct inode *inode, if (depth--) { struct buffer_head *bh; - int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); + int addr_per_block = EXT4_ADDR_PER_BLOCK(inode_sb(inode)); p = last; while (--p >= first) { nr = le32_to_cpu(*p); if (!nr) continue; /* A hole */ - if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), + if (!ext4_data_block_valid(EXT4_SB(inode_sb(inode)), nr, 1)) { EXT4_ERROR_INODE(inode, "invalid indirect mapped " @@ -1009,7 +1010,7 @@ static void ext4_free_branches(handle_t *handle, struct inode *inode, } /* Go read the buffer for the next level down */ - bh = sb_bread(inode->i_sb, nr); + bh = sb_bread(inode_sb(inode), nr); /* * A read failure? Report error and clear slot @@ -1096,19 +1097,19 @@ void ext4_ind_truncate(handle_t *handle, struct inode *inode) { struct ext4_inode_info *ei = EXT4_I(inode); __le32 *i_data = ei->i_data; - int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); + int addr_per_block = EXT4_ADDR_PER_BLOCK(inode_sb(inode)); ext4_lblk_t offsets[4]; Indirect chain[4]; Indirect *partial; __le32 nr = 0; int n = 0; ext4_lblk_t last_block, max_block; - unsigned blocksize = inode->i_sb->s_blocksize; + unsigned blocksize = inode_sb(inode)->s_blocksize; last_block = (inode->i_size + blocksize-1) - >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); - max_block = (EXT4_SB(inode->i_sb)->s_bitmap_maxbytes + blocksize-1) - >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); + >> EXT4_BLOCK_SIZE_BITS(inode_sb(inode)); + max_block = (EXT4_SB(inode_sb(inode))->s_bitmap_maxbytes + blocksize-1) + >> EXT4_BLOCK_SIZE_BITS(inode_sb(inode)); if (last_block != max_block) { n = ext4_block_to_path(inode, last_block, offsets, NULL); @@ -1209,17 +1210,17 @@ int ext4_ind_remove_space(handle_t *handle, struct inode *inode, { struct ext4_inode_info *ei = EXT4_I(inode); __le32 *i_data = ei->i_data; - int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); + int addr_per_block = EXT4_ADDR_PER_BLOCK(inode_sb(inode)); ext4_lblk_t offsets[4], offsets2[4]; Indirect chain[4], chain2[4]; Indirect *partial, *partial2; ext4_lblk_t max_block; __le32 nr = 0, nr2 = 0; int n = 0, n2 = 0; - unsigned blocksize = inode->i_sb->s_blocksize; + unsigned blocksize = inode_sb(inode)->s_blocksize; - max_block = (EXT4_SB(inode->i_sb)->s_bitmap_maxbytes + blocksize-1) - >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); + max_block = (EXT4_SB(inode_sb(inode))->s_bitmap_maxbytes + blocksize-1) + >> EXT4_BLOCK_SIZE_BITS(inode_sb(inode)); if (end >= max_block) end = max_block; if ((start >= end) || (start > max_block)) diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c index 70cf4c7b268a..efd245dccae1 100644 --- a/fs/ext4/inline.c +++ b/fs/ext4/inline.c @@ -34,7 +34,7 @@ static int get_max_inline_xattr_value_size(struct inode *inode, struct ext4_inode *raw_inode; int free, min_offs; - min_offs = EXT4_SB(inode->i_sb)->s_inode_size - + min_offs = EXT4_SB(inode_sb(inode))->s_inode_size - EXT4_GOOD_OLD_INODE_SIZE - EXT4_I(inode)->i_extra_isize - sizeof(struct ext4_xattr_ibody_header); @@ -209,7 +209,7 @@ static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc, struct ext4_inode *raw_inode; int cp_len = 0; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return; BUG_ON(!EXT4_I(inode)->i_inline_off); @@ -432,7 +432,7 @@ static int ext4_destroy_inline_data_nolock(handle_t *handle, memset((void *)ext4_raw_inode(&is.iloc)->i_block, 0, EXT4_MIN_INLINE_DATA_SIZE); - if (ext4_has_feature_extents(inode->i_sb)) { + if (ext4_has_feature_extents(inode_sb(inode))) { if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) { ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS); @@ -466,7 +466,8 @@ static int ext4_read_inline_page(struct inode *inode, struct page *page) BUG_ON(page->index); if (!EXT4_I(inode)->i_inline_off) { - ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.", + ext4_warning(inode_sb(inode), + "inode %lu doesn't have inline data.", inode->i_ino); goto out; } @@ -611,7 +612,7 @@ static int ext4_convert_inline_data_to_extent(struct address_space *mapping, ext4_orphan_del(NULL, inode); } - if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) + if (ret == -ENOSPC && ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry; if (page) @@ -728,7 +729,7 @@ int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len, ret = ext4_get_inode_loc(inode, &iloc); if (ret) { - ext4_std_error(inode->i_sb, ret); + ext4_std_error(inode_sb(inode), ret); copied = 0; goto out; } @@ -760,7 +761,7 @@ ext4_journalled_write_inline_data(struct inode *inode, ret = ext4_get_inode_loc(inode, &iloc); if (ret) { - ext4_std_error(inode->i_sb, ret); + ext4_std_error(inode_sb(inode), ret); return NULL; } @@ -886,7 +887,7 @@ int ext4_da_write_inline_data_begin(struct address_space *mapping, fsdata); ext4_journal_stop(handle); if (ret == -ENOSPC && - ext4_should_retry_alloc(inode->i_sb, &retries)) + ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry_journal; goto out; } @@ -1128,27 +1129,27 @@ static int ext4_finish_convert_inline_dir(handle_t *handle, */ de = (struct ext4_dir_entry_2 *)target; de = ext4_init_dot_dotdot(inode, de, - inode->i_sb->s_blocksize, csum_size, + inode_sb(inode)->s_blocksize, csum_size, le32_to_cpu(((struct ext4_dir_entry_2 *)buf)->inode), 1); header_size = (void *)de - target; memcpy((void *)de, buf + EXT4_INLINE_DOTDOT_SIZE, inline_size - EXT4_INLINE_DOTDOT_SIZE); - if (ext4_has_metadata_csum(inode->i_sb)) + if (ext4_has_metadata_csum(inode_sb(inode))) csum_size = sizeof(struct ext4_dir_entry_tail); - inode->i_size = inode->i_sb->s_blocksize; - i_size_write(inode, inode->i_sb->s_blocksize); - EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize; + inode->i_size = inode_sb(inode)->s_blocksize; + i_size_write(inode, inode_sb(inode)->s_blocksize); + EXT4_I(inode)->i_disksize = inode_sb(inode)->s_blocksize; ext4_update_final_de(dir_block->b_data, inline_size - EXT4_INLINE_DOTDOT_SIZE + header_size, - inode->i_sb->s_blocksize - csum_size); + inode_sb(inode)->s_blocksize - csum_size); if (csum_size) { t = EXT4_DIRENT_TAIL(dir_block->b_data, - inode->i_sb->s_blocksize); - initialize_dirent_tail(t, inode->i_sb->s_blocksize); + inode_sb(inode)->s_blocksize); + initialize_dirent_tail(t, inode_sb(inode)->s_blocksize); } set_buffer_uptodate(dir_block); err = ext4_handle_dirty_dirent_node(handle, inode, dir_block); @@ -1206,7 +1207,7 @@ static int ext4_convert_inline_data_nolock(handle_t *handle, goto out_restore; } - data_bh = sb_getblk(inode->i_sb, map.m_pblk); + data_bh = sb_getblk(inode_sb(inode), map.m_pblk); if (!data_bh) { error = -ENOMEM; goto out_restore; @@ -1219,7 +1220,7 @@ static int ext4_convert_inline_data_nolock(handle_t *handle, error = -EIO; goto out_restore; } - memset(data_bh->b_data, 0, inode->i_sb->s_blocksize); + memset(data_bh->b_data, 0, inode_sb(inode)->s_blocksize); if (!S_ISDIR(inode->i_mode)) { memcpy(data_bh->b_data, buf, inline_size); @@ -1370,7 +1371,7 @@ int htree_inlinedir_to_tree(struct file *dir_file, fake.rec_len = ext4_rec_len_to_disk( EXT4_DIR_REC_LEN(fake.name_len), inline_size); - ext4_set_de_type(inode->i_sb, &fake, S_IFDIR); + ext4_set_de_type(inode_sb(inode), &fake, S_IFDIR); de = &fake; pos = EXT4_INLINE_DOTDOT_OFFSET; } else if (pos == EXT4_INLINE_DOTDOT_OFFSET) { @@ -1380,7 +1381,7 @@ int htree_inlinedir_to_tree(struct file *dir_file, fake.rec_len = ext4_rec_len_to_disk( EXT4_DIR_REC_LEN(fake.name_len), inline_size); - ext4_set_de_type(inode->i_sb, &fake, S_IFDIR); + ext4_set_de_type(inode_sb(inode), &fake, S_IFDIR); de = &fake; pos = EXT4_INLINE_DOTDOT_SIZE; } else { @@ -1465,7 +1466,7 @@ int ext4_read_inline_dir(struct file *file, goto out; ret = 0; - sb = inode->i_sb; + sb = inode_sb(inode); parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode); offset = ctx->pos; @@ -1706,7 +1707,7 @@ int ext4_delete_inline_entry(handle_t *handle, err = ext4_mark_inode_dirty(handle, dir); brelse(iloc.bh); if (err != -ENOENT) - ext4_std_error(dir->i_sb, err); + ext4_std_error(inode_sb(dir), err); return err; } @@ -1763,7 +1764,7 @@ bool empty_inline_dir(struct inode *dir, int *has_inline_data) de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block; if (!le32_to_cpu(de->inode)) { - ext4_warning(dir->i_sb, + ext4_warning(inode_sb(dir), "bad inline directory (dir #%lu) - no `..'", dir->i_ino); ret = true; @@ -1777,7 +1778,7 @@ bool empty_inline_dir(struct inode *dir, int *has_inline_data) if (ext4_check_dir_entry(dir, NULL, de, iloc.bh, inline_pos, inline_size, offset)) { - ext4_warning(dir->i_sb, + ext4_warning(inode_sb(dir), "bad inline directory (dir #%lu) - " "inode %u, rec_len %u, name_len %d" "inline size %d", @@ -1825,7 +1826,7 @@ int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap) if (error) goto out; - addr = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits; + addr = (__u64)iloc.bh->b_blocknr << inode_sb(inode)->s_blocksize_bits; addr += (char *)ext4_raw_inode(&iloc) - iloc.bh->b_data; addr += offsetof(struct ext4_inode, i_block); @@ -1871,7 +1872,7 @@ int ext4_inline_data_fiemap(struct inode *inode, if (error) goto out; - physical = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits; + physical = (__u64)iloc.bh->b_blocknr << inode_sb(inode)->s_blocksize_bits; physical += (char *)ext4_raw_inode(&iloc) - iloc.bh->b_data; physical += offsetof(struct ext4_inode, i_block); diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index c94780075b04..89e91fec7cc9 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -53,7 +53,7 @@ static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw, struct ext4_inode_info *ei) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); __u32 csum; __u16 dummy_csum = 0; int offset = offsetof(struct ext4_inode, i_checksum_lo); @@ -65,7 +65,7 @@ static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw, csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset, EXT4_GOOD_OLD_INODE_SIZE - offset); - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE) { offset = offsetof(struct ext4_inode, i_checksum_hi); csum = ext4_chksum(sbi, csum, (__u8 *)raw + EXT4_GOOD_OLD_INODE_SIZE, @@ -76,7 +76,7 @@ static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw, offset += csum_size; } csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset, - EXT4_INODE_SIZE(inode->i_sb) - offset); + EXT4_INODE_SIZE(inode_sb(inode)) - offset); } return csum; @@ -87,14 +87,14 @@ static int ext4_inode_csum_verify(struct inode *inode, struct ext4_inode *raw, { __u32 provided, calculated; - if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != + if (EXT4_SB(inode_sb(inode))->s_es->s_creator_os != cpu_to_le32(EXT4_OS_LINUX) || - !ext4_has_metadata_csum(inode->i_sb)) + !ext4_has_metadata_csum(inode_sb(inode))) return 1; provided = le16_to_cpu(raw->i_checksum_lo); calculated = ext4_inode_csum(inode, raw, ei); - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE && EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) provided |= ((__u32)le16_to_cpu(raw->i_checksum_hi)) << 16; else @@ -108,14 +108,14 @@ static void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw, { __u32 csum; - if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != + if (EXT4_SB(inode_sb(inode))->s_es->s_creator_os != cpu_to_le32(EXT4_OS_LINUX) || - !ext4_has_metadata_csum(inode->i_sb)) + !ext4_has_metadata_csum(inode_sb(inode))) return; csum = ext4_inode_csum(inode, raw, ei); raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF); - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE && EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) raw->i_checksum_hi = cpu_to_le16(csum >> 16); } @@ -152,7 +152,7 @@ int ext4_inode_is_fast_symlink(struct inode *inode) { if (!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL)) { int ea_blocks = EXT4_I(inode)->i_file_acl ? - EXT4_CLUSTER_SIZE(inode->i_sb) >> 9 : 0; + EXT4_CLUSTER_SIZE(inode_sb(inode)) >> 9 : 0; if (ext4_has_inline_data(inode)) return 0; @@ -224,7 +224,7 @@ void ext4_evict_inode(struct inode *inode) ext4_should_journal_data(inode) && (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode)) && inode->i_data.nrpages) { - journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; + journal_t *journal = EXT4_SB(inode_sb(inode))->s_journal; tid_t commit_tid = EXT4_I(inode)->i_datasync_tid; jbd2_complete_transaction(journal, commit_tid); @@ -247,22 +247,22 @@ void ext4_evict_inode(struct inode *inode) * Protect us against freezing - iput() caller didn't have to have any * protection against it */ - sb_start_intwrite(inode->i_sb); + sb_start_intwrite(inode_sb(inode)); if (!IS_NOQUOTA(inode)) - extra_credits += EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb); + extra_credits += EXT4_MAXQUOTAS_DEL_BLOCKS(inode_sb(inode)); handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, ext4_blocks_for_truncate(inode)+extra_credits); if (IS_ERR(handle)) { - ext4_std_error(inode->i_sb, PTR_ERR(handle)); + ext4_std_error(inode_sb(inode), PTR_ERR(handle)); /* * If we're going to skip the normal cleanup, we still need to * make sure that the in-core orphan linked list is properly * cleaned up. */ ext4_orphan_del(NULL, inode); - sb_end_intwrite(inode->i_sb); + sb_end_intwrite(inode_sb(inode)); goto no_delete; } @@ -281,14 +281,14 @@ void ext4_evict_inode(struct inode *inode) inode->i_size = 0; err = ext4_mark_inode_dirty(handle, inode); if (err) { - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "couldn't mark inode dirty (err %d)", err); goto stop_handle; } if (inode->i_blocks) { err = ext4_truncate(inode); if (err) { - ext4_error(inode->i_sb, + ext4_error(inode_sb(inode), "couldn't truncate inode %lu (err %d)", inode->i_ino, err); goto stop_handle; @@ -299,11 +299,11 @@ void ext4_evict_inode(struct inode *inode) err = ext4_xattr_delete_inode(handle, inode, &ea_inode_array, extra_credits); if (err) { - ext4_warning(inode->i_sb, "xattr delete (err %d)", err); + ext4_warning(inode_sb(inode), "xattr delete (err %d)", err); stop_handle: ext4_journal_stop(handle); ext4_orphan_del(NULL, inode); - sb_end_intwrite(inode->i_sb); + sb_end_intwrite(inode_sb(inode)); ext4_xattr_inode_array_free(ea_inode_array); goto no_delete; } @@ -332,7 +332,7 @@ void ext4_evict_inode(struct inode *inode) else ext4_free_inode(handle, inode); ext4_journal_stop(handle); - sb_end_intwrite(inode->i_sb); + sb_end_intwrite(inode_sb(inode)); ext4_xattr_inode_array_free(ea_inode_array); return; no_delete: @@ -353,16 +353,16 @@ qsize_t *ext4_get_reserved_space(struct inode *inode) void ext4_da_update_reserve_space(struct inode *inode, int used, int quota_claim) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); struct ext4_inode_info *ei = EXT4_I(inode); spin_lock(&ei->i_block_reservation_lock); trace_ext4_da_update_reserve_space(inode, used, quota_claim); if (unlikely(used > ei->i_reserved_data_blocks)) { - ext4_warning(inode->i_sb, "%s: ino %lu, used %d " - "with only %d reserved data blocks", - __func__, inode->i_ino, used, - ei->i_reserved_data_blocks); + ext4_warning(inode_sb(inode), "%s: ino %lu, used %d " + "with only %d reserved data blocks", + __func__, inode->i_ino, used, + ei->i_reserved_data_blocks); WARN_ON(1); used = ei->i_reserved_data_blocks; } @@ -399,7 +399,7 @@ static int __check_block_validity(struct inode *inode, const char *func, unsigned int line, struct ext4_map_blocks *map) { - if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk, + if (!ext4_data_block_valid(EXT4_SB(inode_sb(inode)), map->m_pblk, map->m_len)) { ext4_error_inode(inode, func, line, map->m_pblk, "lblock %lu mapped to illegal pblock " @@ -418,7 +418,7 @@ int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk, if (ext4_encrypted_inode(inode)) return fscrypt_zeroout_range(inode, lblk, pblk, len); - ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS); + ret = sb_issue_zeroout(inode_sb(inode), pblk, len, GFP_NOFS); if (ret > 0) ret = 0; @@ -566,7 +566,7 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode, unsigned int status; if (unlikely(retval != map->m_len)) { - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "ES len assertion failed for inode " "%lu: retval %d != map->m_len %d", inode->i_ino, retval, map->m_len); @@ -661,7 +661,7 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode, unsigned int status; if (unlikely(retval != map->m_len)) { - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "ES len assertion failed for inode " "%lu: retval %d != map->m_len %d", inode->i_ino, retval, map->m_len); @@ -678,7 +678,8 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode, if (flags & EXT4_GET_BLOCKS_ZERO && map->m_flags & EXT4_MAP_MAPPED && map->m_flags & EXT4_MAP_NEW) { - clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk, + clean_bdev_aliases(inode_sb(inode)->s_bdev, + map->m_pblk, map->m_len); ret = ext4_issue_zeroout(inode, map->m_lblk, map->m_pblk, map->m_len); @@ -783,13 +784,13 @@ static int _ext4_get_block(struct inode *inode, sector_t iblock, ret = ext4_map_blocks(ext4_journal_current_handle(), inode, &map, flags); if (ret > 0) { - map_bh(bh, inode->i_sb, map.m_pblk); + map_bh(bh, inode_sb(inode), map.m_pblk); ext4_update_bh_state(bh, map.m_flags); - bh->b_size = inode->i_sb->s_blocksize * map.m_len; + bh->b_size = inode_sb(inode)->s_blocksize * map.m_len; ret = 0; } else if (ret == 0) { /* hole case, need to fill in bh->b_size */ - bh->b_size = inode->i_sb->s_blocksize * map.m_len; + bh->b_size = inode_sb(inode)->s_blocksize * map.m_len; } return ret; } @@ -844,7 +845,7 @@ static int ext4_get_block_trans(struct inode *inode, sector_t iblock, ret = _ext4_get_block(inode, iblock, bh_result, flags); ext4_journal_stop(handle); - if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) + if (ret == -ENOSPC && ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry; return ret; } @@ -970,7 +971,7 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, if (err < 0) return ERR_PTR(err); - bh = sb_getblk(inode->i_sb, map.m_pblk); + bh = sb_getblk(inode_sb(inode), map.m_pblk); if (unlikely(!bh)) return ERR_PTR(-ENOMEM); if (map.m_flags & EXT4_MAP_NEW) { @@ -992,7 +993,7 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, goto errout; } if (!buffer_uptodate(bh)) { - memset(bh->b_data, 0, inode->i_sb->s_blocksize); + memset(bh->b_data, 0, inode_sb(inode)->s_blocksize); set_buffer_uptodate(bh); } unlock_buffer(bh); @@ -1160,7 +1161,7 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len, unsigned block_start, block_end; sector_t block; int err = 0; - unsigned blocksize = inode->i_sb->s_blocksize; + unsigned blocksize = inode_sb(inode)->s_blocksize; unsigned bbits; struct buffer_head *bh, *head, *wait[2], **wait_bh = wait; bool decrypt = false; @@ -1250,7 +1251,7 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping, pgoff_t index; unsigned from, to; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; trace_ext4_write_begin(inode, pos, len, flags); @@ -1350,7 +1351,7 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping, } if (ret == -ENOSPC && - ext4_should_retry_alloc(inode->i_sb, &retries)) + ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry_journal; put_page(page); return ret; @@ -1567,7 +1568,7 @@ static int ext4_journalled_write_end(struct file *file, */ static int ext4_da_reserve_space(struct inode *inode) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); struct ext4_inode_info *ei = EXT4_I(inode); int ret; @@ -1595,7 +1596,7 @@ static int ext4_da_reserve_space(struct inode *inode) static void ext4_da_release_space(struct inode *inode, int to_free) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); struct ext4_inode_info *ei = EXT4_I(inode); if (!to_free) @@ -1611,10 +1612,10 @@ static void ext4_da_release_space(struct inode *inode, int to_free) * function is called from invalidate page, it's * harmless to return without any action. */ - ext4_warning(inode->i_sb, "ext4_da_release_space: " - "ino %lu, to_free %d with only %d reserved " - "data blocks", inode->i_ino, to_free, - ei->i_reserved_data_blocks); + ext4_warning(inode_sb(inode), "ext4_da_release_space: " + "ino %lu, to_free %d with only %d reserved " + "data blocks", inode->i_ino, to_free, + ei->i_reserved_data_blocks); WARN_ON(1); to_free = ei->i_reserved_data_blocks; } @@ -1636,7 +1637,7 @@ static void ext4_da_page_release_reservation(struct page *page, struct buffer_head *head, *bh; unsigned int curr_off = 0; struct inode *inode = page->mapping->host; - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); unsigned int stop = offset + length; int num_clusters; ext4_fsblk_t lblk; @@ -1753,12 +1754,12 @@ static void mpage_release_unused_pages(struct mpage_da_data *mpd, static void ext4_print_free_blocks(struct inode *inode) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); - struct super_block *sb = inode->i_sb; + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); + struct super_block *sb = inode_sb(inode); struct ext4_inode_info *ei = EXT4_I(inode); ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld", - EXT4_C2B(EXT4_SB(inode->i_sb), + EXT4_C2B(EXT4_SB(inode_sb(inode)), ext4_count_free_clusters(sb))); ext4_msg(sb, KERN_CRIT, "Free/Dirty block details"); ext4_msg(sb, KERN_CRIT, "free_blocks=%lld", @@ -1797,7 +1798,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, memcpy(&orig_map, map, sizeof(*map)); #endif - if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es)) + if (invalid_block < ext4_blocks_count(EXT4_SB(inode_sb(inode))->s_es)) invalid_block = ~0; map->m_flags = 0; @@ -1818,7 +1819,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, * So we need to check it. */ if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) { - map_bh(bh, inode->i_sb, invalid_block); + map_bh(bh, inode_sb(inode), invalid_block); set_buffer_new(bh); set_buffer_delay(bh); return 0; @@ -1866,7 +1867,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, * then we don't need to reserve it again. However we still need * to reserve metadata for every block we're going to write. */ - if (EXT4_SB(inode->i_sb)->s_cluster_ratio == 1 || + if (EXT4_SB(inode_sb(inode))->s_cluster_ratio == 1 || !ext4_find_delalloc_cluster(inode, map->m_lblk)) { ret = ext4_da_reserve_space(inode); if (ret) { @@ -1883,7 +1884,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, goto out_unlock; } - map_bh(bh, inode->i_sb, invalid_block); + map_bh(bh, inode_sb(inode), invalid_block); set_buffer_new(bh); set_buffer_delay(bh); } else if (retval > 0) { @@ -1891,7 +1892,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, unsigned int status; if (unlikely(retval != map->m_len)) { - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "ES len assertion failed for inode " "%lu: retval %d != map->m_len %d", inode->i_ino, retval, map->m_len); @@ -1931,7 +1932,7 @@ int ext4_da_get_block_prep(struct inode *inode, sector_t iblock, int ret = 0; BUG_ON(create == 0); - BUG_ON(bh->b_size != inode->i_sb->s_blocksize); + BUG_ON(bh->b_size != inode_sb(inode)->s_blocksize); map.m_lblk = iblock; map.m_len = 1; @@ -1945,7 +1946,7 @@ int ext4_da_get_block_prep(struct inode *inode, sector_t iblock, if (ret <= 0) return ret; - map_bh(bh, inode->i_sb, map.m_pblk); + map_bh(bh, inode_sb(inode), map.m_pblk); ext4_update_bh_state(bh, map.m_flags); if (buffer_unwritten(bh)) { @@ -2110,7 +2111,7 @@ static int ext4_writepage(struct page *page, struct ext4_io_submit io_submit; bool keep_towrite = false; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) { + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) { ext4_invalidatepage(page, 0, PAGE_SIZE); unlock_page(page); return -EIO; @@ -2145,7 +2146,7 @@ static int ext4_writepage(struct page *page, ext4_bh_delay_or_unwritten)) { redirty_page_for_writepage(wbc, page); if ((current->flags & PF_MEMALLOC) || - (inode->i_sb->s_blocksize == PAGE_SIZE)) { + (inode_sb(inode)->s_blocksize == PAGE_SIZE)) { /* * For memory cleaning there's no point in writing only * some buffers. So just bail out. Warn if we came here @@ -2463,7 +2464,7 @@ static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd) BUG_ON(map->m_len == 0); if (map->m_flags & EXT4_MAP_NEW) { - clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk, + clean_bdev_aliases(inode_sb(inode)->s_bdev, map->m_pblk, map->m_len); } return 0; @@ -2504,7 +2505,7 @@ static int mpage_map_and_submit_extent(handle_t *handle, do { err = mpage_map_one_extent(handle, mpd); if (err < 0) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); if (ext4_forced_shutdown(EXT4_SB(sb)) || EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED) @@ -2565,7 +2566,7 @@ static int mpage_map_and_submit_extent(handle_t *handle, up_write(&EXT4_I(inode)->i_data_sem); err2 = ext4_mark_inode_dirty(handle, inode); if (err2) - ext4_error(inode->i_sb, + ext4_error(inode_sb(inode), "Failed to mark inode %lu dirty", inode->i_ino); if (!err) @@ -2714,19 +2715,20 @@ static int ext4_writepages(struct address_space *mapping, struct mpage_da_data mpd; struct inode *inode = mapping->host; int needed_blocks, rsv_blocks = 0, ret = 0; - struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(mapping->host)); bool done; struct blk_plug plug; bool give_up_on_write = false; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; percpu_down_read(&sbi->s_journal_flag_rwsem); trace_ext4_writepages(inode, wbc); if (dax_mapping(mapping)) { - ret = dax_writeback_mapping_range(mapping, inode->i_sb->s_bdev, + ret = dax_writeback_mapping_range(mapping, + inode_sb(inode)->s_bdev, wbc); goto out_writepages; } @@ -2758,7 +2760,7 @@ static int ext4_writepages(struct address_space *mapping, * *never* be called, so if that ever happens, we would want * the stack trace. */ - if (unlikely(ext4_forced_shutdown(EXT4_SB(mapping->host->i_sb)) || + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(mapping->host))) || sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) { ret = -EROFS; goto out_writepages; @@ -2858,9 +2860,10 @@ static int ext4_writepages(struct address_space *mapping, EXT4_HT_WRITE_PAGE, needed_blocks, rsv_blocks); if (IS_ERR(handle)) { ret = PTR_ERR(handle); - ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: " - "%ld pages, ino %lu; err %d", __func__, - wbc->nr_to_write, inode->i_ino, ret); + ext4_msg(inode_sb(inode), KERN_CRIT, + "%s: jbd2_start: " + "%ld pages, ino %lu; err %d", __func__, + wbc->nr_to_write, inode->i_ino, ret); /* Release allocated io_end */ ext4_put_io_end(mpd.io_submit.io_end); mpd.io_submit.io_end = NULL; @@ -2992,7 +2995,7 @@ static int ext4_nonda_switch(struct super_block *sb) /* We always reserve for an inode update; the superblock could be there too */ static int ext4_da_write_credits(struct inode *inode, loff_t pos, unsigned len) { - if (likely(ext4_has_feature_large_file(inode->i_sb))) + if (likely(ext4_has_feature_large_file(inode_sb(inode)))) return 1; if (pos + len <= 0x7fffffffULL) @@ -3012,12 +3015,12 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping, struct inode *inode = mapping->host; handle_t *handle; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; index = pos >> PAGE_SHIFT; - if (ext4_nonda_switch(inode->i_sb) || + if (ext4_nonda_switch(inode_sb(inode)) || S_ISLNK(inode->i_mode)) { *fsdata = (void *)FALL_BACK_TO_NONDELALLOC; return ext4_write_begin(file, mapping, pos, @@ -3092,7 +3095,7 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping, ext4_truncate_failed_write(inode); if (ret == -ENOSPC && - ext4_should_retry_alloc(inode->i_sb, &retries)) + ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry_journal; put_page(page); @@ -3272,7 +3275,7 @@ static sector_t ext4_bmap(struct address_space *mapping, sector_t block) return 0; if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) && - test_opt(inode->i_sb, DELALLOC)) { + test_opt(inode_sb(inode), DELALLOC)) { /* * With delalloc we want to sync the file * so that we can make sure we allocate @@ -3396,7 +3399,7 @@ static int ext4_releasepage(struct page *page, gfp_t wait) static bool ext4_inode_datasync_dirty(struct inode *inode) { - journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; + journal_t *journal = EXT4_SB(inode_sb(inode))->s_journal; if (journal) return !jbd2_transaction_committed(journal, @@ -3410,7 +3413,7 @@ static bool ext4_inode_datasync_dirty(struct inode *inode) static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length, unsigned flags, struct iomap *iomap) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); unsigned int blkbits = inode->i_blkbits; unsigned long first_block = offset >> blkbits; unsigned long last_block = (offset + length - 1) >> blkbits; @@ -3488,7 +3491,7 @@ static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length, if (ret < 0) { ext4_journal_stop(handle); if (ret == -ENOSPC && - ext4_should_retry_alloc(inode->i_sb, &retries)) + ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry; return ret; } @@ -3522,7 +3525,7 @@ static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length, iomap->flags = 0; if (ext4_inode_datasync_dirty(inode)) iomap->flags |= IOMAP_F_DIRTY; - iomap->bdev = inode->i_sb->s_bdev; + iomap->bdev = inode_sb(inode)->s_bdev; iomap->dax_dev = sbi->s_daxdev; iomap->offset = first_block << blkbits; iomap->length = (u64)map.m_len << blkbits; @@ -3735,7 +3738,7 @@ static ssize_t ext4_direct_IO_write(struct kiocb *iocb, struct iov_iter *iter) get_block_func = ext4_dio_get_block_unwritten_async; dio_flags = DIO_LOCKING; } - ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter, + ret = __blockdev_direct_IO(iocb, inode, inode_sb(inode)->s_bdev, iter, get_block_func, ext4_end_io_dio, NULL, dio_flags); @@ -3827,7 +3830,7 @@ static ssize_t ext4_direct_IO_read(struct kiocb *iocb, struct iov_iter *iter) iocb->ki_pos + count - 1); if (ret) goto out_unlock; - ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, + ret = __blockdev_direct_IO(iocb, inode, inode_sb(inode)->s_bdev, iter, ext4_dio_get_block, NULL, NULL, 0); out_unlock: inode_unlock_shared(inode); @@ -3958,7 +3961,7 @@ void ext4_set_aops(struct inode *inode) default: BUG(); } - if (test_opt(inode->i_sb, DELALLOC)) + if (test_opt(inode_sb(inode), DELALLOC)) inode->i_mapping->a_ops = &ext4_da_aops; else inode->i_mapping->a_ops = &ext4_aops; @@ -3981,9 +3984,9 @@ static int __ext4_block_zero_page_range(handle_t *handle, if (!page) return -ENOMEM; - blocksize = inode->i_sb->s_blocksize; + blocksize = inode_sb(inode)->s_blocksize; - iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits); + iblock = index << (PAGE_SHIFT - inode_sb(inode)->s_blocksize_bits); if (!page_has_buffers(page)) create_empty_buffers(page, blocksize, 0); @@ -4066,7 +4069,7 @@ static int ext4_block_zero_page_range(handle_t *handle, { struct inode *inode = mapping->host; unsigned offset = from & (PAGE_SIZE-1); - unsigned blocksize = inode->i_sb->s_blocksize; + unsigned blocksize = inode_sb(inode)->s_blocksize; unsigned max = blocksize - (offset & (blocksize - 1)); /* @@ -4101,7 +4104,7 @@ static int ext4_block_truncate_page(handle_t *handle, if (ext4_encrypted_inode(inode) && !fscrypt_has_encryption_key(inode)) return 0; - blocksize = inode->i_sb->s_blocksize; + blocksize = inode_sb(inode)->s_blocksize; length = blocksize - (offset & (blocksize - 1)); return ext4_block_zero_page_range(handle, mapping, from, length); @@ -4110,7 +4113,7 @@ static int ext4_block_truncate_page(handle_t *handle, int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode, loff_t lstart, loff_t length) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct address_space *mapping = inode->i_mapping; unsigned partial_start, partial_end; ext4_fsblk_t start, end; @@ -4198,7 +4201,7 @@ int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset, int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); ext4_lblk_t first_block, stop_block; struct address_space *mapping = inode->i_mapping; loff_t first_block_offset, last_block_offset; @@ -4335,7 +4338,7 @@ int ext4_inode_attach_jinode(struct inode *inode) struct ext4_inode_info *ei = EXT4_I(inode); struct jbd2_inode *jinode; - if (ei->jinode || !EXT4_SB(inode->i_sb)->s_journal) + if (ei->jinode || !EXT4_SB(inode_sb(inode))->s_journal) return 0; jinode = jbd2_alloc_inode(GFP_KERNEL); @@ -4405,7 +4408,7 @@ int ext4_truncate(struct inode *inode) ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS); - if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC)) + if (inode->i_size == 0 && !test_opt(inode_sb(inode), NO_AUTO_DA_ALLOC)) ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE); if (ext4_has_inline_data(inode)) { @@ -4419,7 +4422,7 @@ int ext4_truncate(struct inode *inode) } /* If we zero-out tail of the page, we have to create jinode for jbd2 */ - if (inode->i_size & (inode->i_sb->s_blocksize - 1)) { + if (inode->i_size & (inode_sb(inode)->s_blocksize - 1)) { if (ext4_inode_attach_jinode(inode) < 0) return 0; } @@ -4433,7 +4436,7 @@ int ext4_truncate(struct inode *inode) if (IS_ERR(handle)) return PTR_ERR(handle); - if (inode->i_size & (inode->i_sb->s_blocksize - 1)) + if (inode->i_size & (inode_sb(inode)->s_blocksize - 1)) ext4_block_truncate_page(handle, mapping, inode->i_size); /* @@ -4495,7 +4498,7 @@ static int __ext4_get_inode_loc(struct inode *inode, { struct ext4_group_desc *gdp; struct buffer_head *bh; - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); ext4_fsblk_t block; int inodes_per_block, inode_offset; @@ -4636,7 +4639,7 @@ int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc) static bool ext4_should_use_dax(struct inode *inode) { - if (!test_opt(inode->i_sb, DAX)) + if (!test_opt(inode_sb(inode), DAX)) return false; if (!S_ISREG(inode->i_mode)) return false; @@ -4678,7 +4681,7 @@ static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode, { blkcnt_t i_blocks ; struct inode *inode = &(ei->vfs_inode); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); if (ext4_has_feature_huge_file(sb)) { /* we are using combined 48 bit field */ @@ -4702,7 +4705,7 @@ static inline void ext4_iget_extra_inode(struct inode *inode, __le32 *magic = (void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize; if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize + sizeof(__le32) <= - EXT4_INODE_SIZE(inode->i_sb) && + EXT4_INODE_SIZE(inode_sb(inode)) && *magic == cpu_to_le32(EXT4_XATTR_MAGIC)) { ext4_set_inode_state(inode, EXT4_STATE_XATTR); ext4_find_inline_data_nolock(inode); @@ -4712,7 +4715,7 @@ static inline void ext4_iget_extra_inode(struct inode *inode, int ext4_get_projid(struct inode *inode, kprojid_t *projid) { - if (!ext4_has_feature_project(inode->i_sb)) + if (!ext4_has_feature_project(inode_sb(inode))) return -EOPNOTSUPP; *projid = EXT4_I(inode)->i_projid; return 0; @@ -4746,15 +4749,15 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) goto bad_inode; raw_inode = ext4_raw_inode(&iloc); - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE) { ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize); if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize > - EXT4_INODE_SIZE(inode->i_sb) || - (ei->i_extra_isize & 3)) { + EXT4_INODE_SIZE(inode_sb(inode)) || + (ei->i_extra_isize & 3)) { EXT4_ERROR_INODE(inode, "bad extra_isize %u (inode size %u)", ei->i_extra_isize, - EXT4_INODE_SIZE(inode->i_sb)); + EXT4_INODE_SIZE(inode_sb(inode))); ret = -EFSCORRUPTED; goto bad_inode; } @@ -4763,7 +4766,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) /* Precompute checksum seed for inode metadata */ if (ext4_has_metadata_csum(sb)) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); __u32 csum; __le32 inum = cpu_to_le32(inode->i_ino); __le32 gen = raw_inode->i_generation; @@ -4789,7 +4792,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) else i_projid = EXT4_DEF_PROJID; - if (!(test_opt(inode->i_sb, NO_UID32))) { + if (!(test_opt(inode_sb(inode), NO_UID32))) { i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16; i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16; } @@ -4809,7 +4812,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) */ if (inode->i_nlink == 0) { if ((inode->i_mode == 0 || - !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) && + !(EXT4_SB(inode_sb(inode))->s_mount_state & EXT4_ORPHAN_FS)) && ino != EXT4_BOOT_LOADER_INO) { /* this inode is deleted */ ret = -ESTALE; @@ -4874,7 +4877,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) ei->i_datasync_tid = tid; } - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE) { if (ei->i_extra_isize == 0) { /* The extra space is currently unused. Use it. */ BUILD_BUG_ON(sizeof(struct ext4_inode) & 3); @@ -4890,10 +4893,10 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode); EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode); - if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { + if (likely(!test_opt2(inode_sb(inode), HURD_COMPAT))) { u64 ivers = le32_to_cpu(raw_inode->i_disk_version); - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE) { if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi)) ivers |= (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32; @@ -4987,7 +4990,7 @@ static int ext4_inode_blocks_set(handle_t *handle, { struct inode *inode = &(ei->vfs_inode); u64 i_blocks = inode->i_blocks; - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); if (i_blocks <= ~0U) { /* @@ -5098,7 +5101,7 @@ static int ext4_do_update_inode(handle_t *handle, struct ext4_inode *raw_inode = ext4_raw_inode(iloc); struct ext4_inode_info *ei = EXT4_I(inode); struct buffer_head *bh = iloc->bh; - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); int err = 0, rc, block; int need_datasync = 0, set_large_file = 0; uid_t i_uid; @@ -5110,13 +5113,13 @@ static int ext4_do_update_inode(handle_t *handle, /* For fields not tracked in the in-memory inode, * initialise them to zero for new inodes. */ if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) - memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); + memset(raw_inode, 0, EXT4_SB(inode_sb(inode))->s_inode_size); raw_inode->i_mode = cpu_to_le16(inode->i_mode); i_uid = i_uid_read(inode); i_gid = i_gid_read(inode); i_projid = from_kprojid(&init_user_ns, ei->i_projid); - if (!(test_opt(inode->i_sb, NO_UID32))) { + if (!(test_opt(inode_sb(inode), NO_UID32))) { raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid)); raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid)); /* @@ -5152,11 +5155,11 @@ static int ext4_do_update_inode(handle_t *handle, } raw_inode->i_dtime = cpu_to_le32(ei->i_dtime); raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF); - if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) + if (likely(!test_opt2(inode_sb(inode), HURD_COMPAT))) raw_inode->i_file_acl_high = cpu_to_le16(ei->i_file_acl >> 32); raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl); - if (ei->i_disksize != ext4_isize(inode->i_sb, raw_inode)) { + if (ei->i_disksize != ext4_isize(inode_sb(inode), raw_inode)) { ext4_isize_set(raw_inode, ei->i_disksize); need_datasync = 1; } @@ -5183,7 +5186,7 @@ static int ext4_do_update_inode(handle_t *handle, raw_inode->i_block[block] = ei->i_data[block]; } - if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { + if (likely(!test_opt2(inode_sb(inode), HURD_COMPAT))) { u64 ivers = inode_peek_iversion(inode); raw_inode->i_disk_version = cpu_to_le32(ivers); @@ -5196,17 +5199,17 @@ static int ext4_do_update_inode(handle_t *handle, } } - BUG_ON(!ext4_has_feature_project(inode->i_sb) && + BUG_ON(!ext4_has_feature_project(inode_sb(inode)) && i_projid != EXT4_DEF_PROJID); - if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && + if (EXT4_INODE_SIZE(inode_sb(inode)) > EXT4_GOOD_OLD_INODE_SIZE && EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) raw_inode->i_projid = cpu_to_le32(i_projid); ext4_inode_csum_set(inode, raw_inode, ei); spin_unlock(&ei->i_raw_lock); - if (inode->i_sb->s_flags & SB_LAZYTIME) - ext4_update_other_inodes_time(inode->i_sb, inode->i_ino, + if (inode_sb(inode)->s_flags & SB_LAZYTIME) + ext4_update_other_inodes_time(inode_sb(inode), inode->i_ino, bh->b_data); BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); @@ -5227,7 +5230,7 @@ static int ext4_do_update_inode(handle_t *handle, ext4_update_inode_fsync_trans(handle, inode, need_datasync); out_brelse: brelse(bh); - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; } @@ -5272,7 +5275,7 @@ int ext4_write_inode(struct inode *inode, struct writeback_control *wbc) if (WARN_ON_ONCE(current->flags & PF_MEMALLOC)) return 0; - if (EXT4_SB(inode->i_sb)->s_journal) { + if (EXT4_SB(inode_sb(inode))->s_journal) { if (ext4_journal_current_handle()) { jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n"); dump_stack(); @@ -5287,7 +5290,7 @@ int ext4_write_inode(struct inode *inode, struct writeback_control *wbc) if (wbc->sync_mode != WB_SYNC_ALL || wbc->for_sync) return 0; - err = ext4_force_commit(inode->i_sb); + err = ext4_force_commit(inode_sb(inode)); } else { struct ext4_iloc iloc; @@ -5319,7 +5322,7 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode) { struct page *page; unsigned offset; - journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; + journal_t *journal = EXT4_SB(inode_sb(inode))->s_journal; tid_t commit_tid = 0; int ret; @@ -5383,7 +5386,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) int orphan = 0; const unsigned int ia_valid = attr->ia_valid; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; error = setattr_prepare(dentry, attr); @@ -5406,8 +5409,8 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) /* (user+group)*(old+new) structure, inode write (sb, * inode block, ? - but truncate inode update has it) */ handle = ext4_journal_start(inode, EXT4_HT_QUOTA, - (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) + - EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3); + (EXT4_MAXQUOTAS_INIT_BLOCKS(inode_sb(inode)) + + EXT4_MAXQUOTAS_DEL_BLOCKS(inode_sb(inode))) + 3); if (IS_ERR(handle)) { error = PTR_ERR(handle); goto err_out; @@ -5440,7 +5443,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) int shrink = (attr->ia_size <= inode->i_size); if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); if (attr->ia_size > sbi->s_bitmap_maxbytes) return -EFBIG; @@ -5542,7 +5545,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) rc = posix_acl_chmod(inode, inode->i_mode); err_out: - ext4_std_error(inode->i_sb, error); + ext4_std_error(inode_sb(inode), error); if (!error) error = rc; return error; @@ -5611,9 +5614,9 @@ int ext4_file_getattr(const struct path *path, struct kstat *stat, * will return the blocks that include the delayed allocation * blocks for this file. */ - delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb), + delalloc_blocks = EXT4_C2B(EXT4_SB(inode_sb(inode)), EXT4_I(inode)->i_reserved_data_blocks); - stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9); + stat->blocks += delalloc_blocks << (inode_sb(inode)->s_blocksize_bits - 9); return 0; } @@ -5639,7 +5642,7 @@ static int ext4_index_trans_blocks(struct inode *inode, int lblocks, static int ext4_meta_trans_blocks(struct inode *inode, int lblocks, int pextents) { - ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb); + ext4_group_t groups, ngroups = ext4_get_groups_count(inode_sb(inode)); int gdpblocks; int idxblocks; int ret = 0; @@ -5660,14 +5663,14 @@ static int ext4_meta_trans_blocks(struct inode *inode, int lblocks, gdpblocks = groups; if (groups > ngroups) groups = ngroups; - if (groups > EXT4_SB(inode->i_sb)->s_gdb_count) - gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count; + if (groups > EXT4_SB(inode_sb(inode))->s_gdb_count) + gdpblocks = EXT4_SB(inode_sb(inode))->s_gdb_count; /* bitmaps and block group descriptor blocks */ ret += groups + gdpblocks; /* Blocks for super block, inode, quota and xattr blocks */ - ret += EXT4_META_TRANS_BLOCKS(inode->i_sb); + ret += EXT4_META_TRANS_BLOCKS(inode_sb(inode)); return ret; } @@ -5718,7 +5721,7 @@ int ext4_mark_iloc_dirty(handle_t *handle, { int err = 0; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; if (IS_I_VERSION(inode)) @@ -5744,7 +5747,7 @@ ext4_reserve_inode_write(handle_t *handle, struct inode *inode, { int err; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; err = ext4_get_inode_loc(inode, iloc); @@ -5756,7 +5759,7 @@ ext4_reserve_inode_write(handle_t *handle, struct inode *inode, iloc->bh = NULL; } } - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; } @@ -5822,7 +5825,7 @@ static int ext4_try_to_expand_extra_isize(struct inode *inode, */ if (ext4_handle_valid(handle) && jbd2_journal_extend(handle, - EXT4_DATA_TRANS_BLOCKS(inode->i_sb)) != 0) + EXT4_DATA_TRANS_BLOCKS(inode_sb(inode))) != 0) return -ENOSPC; if (ext4_write_trylock_xattr(inode, &no_expand) == 0) @@ -5849,7 +5852,7 @@ int ext4_expand_extra_isize(struct inode *inode, } handle = ext4_journal_start(inode, EXT4_HT_INODE, - EXT4_DATA_TRANS_BLOCKS(inode->i_sb)); + EXT4_DATA_TRANS_BLOCKS(inode_sb(inode))); if (IS_ERR(handle)) { error = PTR_ERR(handle); brelse(iloc->bh); @@ -5894,7 +5897,7 @@ int ext4_expand_extra_isize(struct inode *inode, int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode) { struct ext4_iloc iloc; - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); int err; might_sleep(); @@ -5970,7 +5973,7 @@ static int ext4_pin_inode(handle_t *handle, struct inode *inode) brelse(iloc.bh); } } - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; } #endif @@ -5980,7 +5983,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val) journal_t *journal; handle_t *handle; int err; - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); /* * We have to be very careful here: changing a data block's @@ -6061,7 +6064,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val) err = ext4_mark_inode_dirty(handle, inode); ext4_handle_sync(handle); ext4_journal_stop(handle); - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; } @@ -6085,7 +6088,7 @@ int ext4_page_mkwrite(struct vm_fault *vmf) get_block_t *get_block; int retries = 0; - sb_start_pagefault(inode->i_sb); + sb_start_pagefault(inode_sb(inode)); file_update_time(vma->vm_file); down_read(&EXT4_I(inode)->i_mmap_sem); @@ -6095,14 +6098,14 @@ int ext4_page_mkwrite(struct vm_fault *vmf) goto out_ret; /* Delalloc case is easy... */ - if (test_opt(inode->i_sb, DELALLOC) && + if (test_opt(inode_sb(inode), DELALLOC) && !ext4_should_journal_data(inode) && - !ext4_nonda_switch(inode->i_sb)) { + !ext4_nonda_switch(inode_sb(inode))) { do { ret = block_page_mkwrite(vma, vmf, ext4_da_get_block_prep); } while (ret == -ENOSPC && - ext4_should_retry_alloc(inode->i_sb, &retries)); + ext4_should_retry_alloc(inode_sb(inode), &retries)); goto out_ret; } @@ -6158,13 +6161,13 @@ int ext4_page_mkwrite(struct vm_fault *vmf) ext4_set_inode_state(inode, EXT4_STATE_JDATA); } ext4_journal_stop(handle); - if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) + if (ret == -ENOSPC && ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry_alloc; out_ret: ret = block_page_mkwrite_return(ret); out: up_read(&EXT4_I(inode)->i_mmap_sem); - sb_end_pagefault(inode->i_sb); + sb_end_pagefault(inode_sb(inode)); return ret; } diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c index 7e99ad02f1ba..d8a9930f0ff6 100644 --- a/fs/ext4/ioctl.c +++ b/fs/ext4/ioctl.c @@ -166,17 +166,17 @@ static long swap_inode_boot_loader(struct super_block *sb, err = ext4_mark_inode_dirty(handle, inode); if (err < 0) { - ext4_warning(inode->i_sb, - "couldn't mark inode #%lu dirty (err %d)", - inode->i_ino, err); + ext4_warning(inode_sb(inode), + "couldn't mark inode #%lu dirty (err %d)", + inode->i_ino, err); /* Revert all changes: */ swap_inode_data(inode, inode_bl); } else { err = ext4_mark_inode_dirty(handle, inode_bl); if (err < 0) { - ext4_warning(inode_bl->i_sb, - "couldn't mark inode #%lu dirty (err %d)", - inode_bl->i_ino, err); + ext4_warning(inode_sb(inode_bl), + "couldn't mark inode #%lu dirty (err %d)", + inode_bl->i_ino, err); /* Revert all changes: */ swap_inode_data(inode, inode_bl); ext4_mark_inode_dirty(handle, inode); @@ -295,7 +295,7 @@ static int ext4_ioctl_setflags(struct inode *inode, * Changes to the journaling mode can cause unsafe changes to * S_DAX if we are using the DAX mount option. */ - if (test_opt(inode->i_sb, DAX)) { + if (test_opt(inode_sb(inode), DAX)) { err = -EBUSY; goto flags_out; } @@ -319,7 +319,7 @@ static int ext4_ioctl_setflags(struct inode *inode, static int ext4_ioctl_setproject(struct file *filp, __u32 projid) { struct inode *inode = file_inode(filp); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct ext4_inode_info *ei = EXT4_I(inode); int err, rc; handle_t *handle; @@ -596,7 +596,7 @@ static int ext4_ioc_getfsmap(struct super_block *sb, static long ext4_ioctl_group_add(struct file *file, struct ext4_new_group_data *input) { - struct super_block *sb = file_inode(file)->i_sb; + struct super_block *sb = inode_sb(file_inode(file)); int err, err2=0; err = ext4_resize_begin(sb); @@ -634,7 +634,7 @@ static long ext4_ioctl_group_add(struct file *file, long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct inode *inode = file_inode(filp); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct ext4_inode_info *ei = EXT4_I(inode); unsigned int flags; @@ -690,7 +690,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) if (!inode_owner_or_capable(inode)) return -EPERM; - if (ext4_has_metadata_csum(inode->i_sb)) { + if (ext4_has_metadata_csum(inode_sb(inode))) { ext4_warning(sb, "Setting inode version is not " "supported with metadata_csum enabled."); return -ENOTTY; @@ -995,7 +995,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) memset(&fa, 0, sizeof(struct fsxattr)); fa.fsx_xflags = ext4_iflags_to_xflags(ei->i_flags & EXT4_FL_USER_VISIBLE); - if (ext4_has_feature_project(inode->i_sb)) { + if (ext4_has_feature_project(inode_sb(inode))) { fa.fsx_projid = (__u32)from_kprojid(&init_user_ns, EXT4_I(inode)->i_projid); } diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c index 769a62708b1c..051379dc75f2 100644 --- a/fs/ext4/mballoc.c +++ b/fs/ext4/mballoc.c @@ -822,7 +822,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp) mb_debug(1, "init page %lu\n", page->index); inode = page->mapping->host; - sb = inode->i_sb; + sb = inode_sb(inode); ngroups = ext4_get_groups_count(sb); blocksize = i_blocksize(inode); blocks_per_page = PAGE_SIZE / blocksize; @@ -4006,7 +4006,7 @@ ext4_mb_discard_group_preallocations(struct super_block *sb, void ext4_discard_preallocations(struct inode *inode) { struct ext4_inode_info *ei = EXT4_I(inode); - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct buffer_head *bitmap_bh = NULL; struct ext4_prealloc_space *pa, *tmp; ext4_group_t group = 0; @@ -4233,7 +4233,7 @@ static noinline_for_stack int ext4_mb_initialize_context(struct ext4_allocation_context *ac, struct ext4_allocation_request *ar) { - struct super_block *sb = ar->inode->i_sb; + struct super_block *sb = inode_sb(ar->inode); struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_super_block *es = sbi->s_es; ext4_group_t group; @@ -4490,7 +4490,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle, unsigned int reserv_clstrs = 0; might_sleep(); - sb = ar->inode->i_sb; + sb = inode_sb(ar->inode); sbi = EXT4_SB(sb); trace_ext4_request_blocks(ar); @@ -4723,7 +4723,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode, unsigned long count, int flags) { struct buffer_head *bitmap_bh = NULL; - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct ext4_group_desc *gdp; unsigned int overflow; ext4_grpblk_t bit; @@ -4800,7 +4800,8 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode, for (i = 0; i < count; i++) { cond_resched(); if (is_metadata) - bh = sb_find_get_block(inode->i_sb, block + i); + bh = sb_find_get_block(inode_sb(inode), + block + i); ext4_forget(handle, is_metadata, inode, bh, block + i); } } diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c index 61a9d1927817..479e3b54d5be 100644 --- a/fs/ext4/migrate.c +++ b/fs/ext4/migrate.c @@ -114,9 +114,9 @@ static int update_ind_extent_range(handle_t *handle, struct inode *inode, struct buffer_head *bh; __le32 *i_data; int i, retval = 0; - unsigned long max_entries = inode->i_sb->s_blocksize >> 2; + unsigned long max_entries = inode_sb(inode)->s_blocksize >> 2; - bh = sb_bread(inode->i_sb, pblock); + bh = sb_bread(inode_sb(inode), pblock); if (!bh) return -EIO; @@ -143,9 +143,9 @@ static int update_dind_extent_range(handle_t *handle, struct inode *inode, struct buffer_head *bh; __le32 *i_data; int i, retval = 0; - unsigned long max_entries = inode->i_sb->s_blocksize >> 2; + unsigned long max_entries = inode_sb(inode)->s_blocksize >> 2; - bh = sb_bread(inode->i_sb, pblock); + bh = sb_bread(inode_sb(inode), pblock); if (!bh) return -EIO; @@ -173,9 +173,9 @@ static int update_tind_extent_range(handle_t *handle, struct inode *inode, struct buffer_head *bh; __le32 *i_data; int i, retval = 0; - unsigned long max_entries = inode->i_sb->s_blocksize >> 2; + unsigned long max_entries = inode_sb(inode)->s_blocksize >> 2; - bh = sb_bread(inode->i_sb, pblock); + bh = sb_bread(inode_sb(inode), pblock); if (!bh) return -EIO; @@ -208,7 +208,7 @@ static int extend_credit_for_blkdel(handle_t *handle, struct inode *inode) * So allocate a credit of 3. We may update * quota (user and group). */ - needed = 3 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); + needed = 3 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode_sb(inode)); if (ext4_journal_extend(handle, needed) != 0) retval = ext4_journal_restart(handle, needed); @@ -222,9 +222,9 @@ static int free_dind_blocks(handle_t *handle, int i; __le32 *tmp_idata; struct buffer_head *bh; - unsigned long max_entries = inode->i_sb->s_blocksize >> 2; + unsigned long max_entries = inode_sb(inode)->s_blocksize >> 2; - bh = sb_bread(inode->i_sb, le32_to_cpu(i_data)); + bh = sb_bread(inode_sb(inode), le32_to_cpu(i_data)); if (!bh) return -EIO; @@ -252,9 +252,9 @@ static int free_tind_blocks(handle_t *handle, int i, retval = 0; __le32 *tmp_idata; struct buffer_head *bh; - unsigned long max_entries = inode->i_sb->s_blocksize >> 2; + unsigned long max_entries = inode_sb(inode)->s_blocksize >> 2; - bh = sb_bread(inode->i_sb, le32_to_cpu(i_data)); + bh = sb_bread(inode_sb(inode), le32_to_cpu(i_data)); if (!bh) return -EIO; @@ -382,7 +382,7 @@ static int free_ext_idx(handle_t *handle, struct inode *inode, struct ext4_extent_header *eh; block = ext4_idx_pblock(ix); - bh = sb_bread(inode->i_sb, block); + bh = sb_bread(inode_sb(inode), block); if (!bh) return -EIO; @@ -441,7 +441,7 @@ int ext4_ext_migrate(struct inode *inode) * If the filesystem does not support extents, or the inode * already is extent-based, error out. */ - if (!ext4_has_feature_extents(inode->i_sb) || + if (!ext4_has_feature_extents(inode_sb(inode)) || (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) return -EINVAL; @@ -457,17 +457,17 @@ int ext4_ext_migrate(struct inode *inode) * need to worry about credits for modifying the quota inode. */ handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, - 4 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb)); + 4 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode_sb(inode))); if (IS_ERR(handle)) { retval = PTR_ERR(handle); return retval; } - goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) * - EXT4_INODES_PER_GROUP(inode->i_sb)) + 1; + goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode_sb(inode))) * + EXT4_INODES_PER_GROUP(inode_sb(inode))) + 1; owner[0] = i_uid_read(inode); owner[1] = i_gid_read(inode); - tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root), + tmp_inode = ext4_new_inode(handle, d_inode(inode_sb(inode)->s_root), S_IFREG, NULL, goal, owner, 0); if (IS_ERR(tmp_inode)) { retval = PTR_ERR(tmp_inode); @@ -522,7 +522,7 @@ int ext4_ext_migrate(struct inode *inode) memset(&lb, 0, sizeof(lb)); /* 32 bit block address 4 bytes */ - max_entries = inode->i_sb->s_blocksize >> 2; + max_entries = inode_sb(inode)->s_blocksize >> 2; for (i = 0; i < EXT4_NDIR_BLOCKS; i++) { if (i_data[i]) { retval = update_extent_range(handle, tmp_inode, @@ -608,7 +608,7 @@ int ext4_ext_migrate(struct inode *inode) int ext4_ind_migrate(struct inode *inode) { struct ext4_extent_header *eh; - struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; + struct ext4_super_block *es = EXT4_SB(inode_sb(inode))->s_es; struct ext4_inode_info *ei = EXT4_I(inode); struct ext4_extent *ex; unsigned int i, len; @@ -617,11 +617,11 @@ int ext4_ind_migrate(struct inode *inode) handle_t *handle; int ret; - if (!ext4_has_feature_extents(inode->i_sb) || + if (!ext4_has_feature_extents(inode_sb(inode)) || (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) return -EINVAL; - if (ext4_has_feature_bigalloc(inode->i_sb)) + if (ext4_has_feature_bigalloc(inode_sb(inode))) return -EOPNOTSUPP; /* @@ -629,7 +629,7 @@ int ext4_ind_migrate(struct inode *inode) * blocks to be allocated, otherwise delayed allocation blocks may not * be reflected and bypass the checks on extent header. */ - if (test_opt(inode->i_sb, DELALLOC)) + if (test_opt(inode_sb(inode), DELALLOC)) ext4_alloc_da_blocks(inode); handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1); diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c index b96e4bd3b3ec..670ccca993a0 100644 --- a/fs/ext4/move_extent.c +++ b/fs/ext4/move_extent.c @@ -255,13 +255,13 @@ move_extent_per_page(struct file *o_filp, struct inode *donor_inode, struct page *pagep[2] = {NULL, NULL}; handle_t *handle; ext4_lblk_t orig_blk_offset, donor_blk_offset; - unsigned long blocksize = orig_inode->i_sb->s_blocksize; + unsigned long blocksize = inode_sb(orig_inode)->s_blocksize; unsigned int tmp_data_size, data_size, replaced_size; int i, err2, jblocks, retries = 0; int replaced_count = 0; int from = data_offset_in_page << orig_inode->i_blkbits; int blocks_per_page = PAGE_SIZE >> orig_inode->i_blkbits; - struct super_block *sb = orig_inode->i_sb; + struct super_block *sb = inode_sb(orig_inode); struct buffer_head *bh = NULL; /* @@ -558,7 +558,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, __u64 orig_blk, ext4_lblk_t d_start = donor_blk; int ret; - if (orig_inode->i_sb != donor_inode->i_sb) { + if (inode_sb(orig_inode) != inode_sb(donor_inode)) { ext4_debug("ext4 move extent: The argument files " "should be in same FS [ino:orig %lu, donor %lu]\n", orig_inode->i_ino, donor_inode->i_ino); @@ -585,14 +585,14 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, __u64 orig_blk, journaling enabled */ if (ext4_should_journal_data(orig_inode) || ext4_should_journal_data(donor_inode)) { - ext4_msg(orig_inode->i_sb, KERN_ERR, + ext4_msg(inode_sb(orig_inode), KERN_ERR, "Online defrag not supported with data journaling"); return -EOPNOTSUPP; } if (ext4_encrypted_inode(orig_inode) || ext4_encrypted_inode(donor_inode)) { - ext4_msg(orig_inode->i_sb, KERN_ERR, + ext4_msg(inode_sb(orig_inode), KERN_ERR, "Online defrag not supported for encrypted files"); return -EOPNOTSUPP; } diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c index b1f21e3a0763..68d59adb8590 100644 --- a/fs/ext4/namei.c +++ b/fs/ext4/namei.c @@ -56,23 +56,23 @@ static struct buffer_head *ext4_append(handle_t *handle, struct buffer_head *bh; int err; - if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb && + if (unlikely(EXT4_SB(inode_sb(inode))->s_max_dir_size_kb && ((inode->i_size >> 10) >= - EXT4_SB(inode->i_sb)->s_max_dir_size_kb))) + EXT4_SB(inode_sb(inode))->s_max_dir_size_kb))) return ERR_PTR(-ENOSPC); - *block = inode->i_size >> inode->i_sb->s_blocksize_bits; + *block = inode->i_size >> inode_sb(inode)->s_blocksize_bits; bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE); if (IS_ERR(bh)) return bh; - inode->i_size += inode->i_sb->s_blocksize; + inode->i_size += inode_sb(inode)->s_blocksize; EXT4_I(inode)->i_disksize = inode->i_size; BUFFER_TRACE(bh, "get_write_access"); err = ext4_journal_get_write_access(handle, bh); if (err) { brelse(bh); - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return ERR_PTR(err); } return bh; @@ -100,7 +100,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode, bh = ext4_bread(NULL, inode, block, 0); if (IS_ERR(bh)) { - __ext4_warning(inode->i_sb, func, line, + __ext4_warning(inode_sb(inode), func, line, "inode #%lu: lblock %lu: comm %s: " "error %ld reading directory block", inode->i_ino, (unsigned long)block, @@ -119,8 +119,8 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode, if (block == 0) is_dx_block = 1; else if (ext4_rec_len_from_disk(dirent->rec_len, - inode->i_sb->s_blocksize) == - inode->i_sb->s_blocksize) + inode_sb(inode)->s_blocksize) == + inode_sb(inode)->s_blocksize) is_dx_block = 1; } if (!is_dx_block && type == INDEX) { @@ -128,7 +128,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode, "directory leaf block found instead of index block"); return ERR_PTR(-EFSCORRUPTED); } - if (!ext4_has_metadata_csum(inode->i_sb) || + if (!ext4_has_metadata_csum(inode_sb(inode)) || buffer_verified(bh)) return bh; @@ -298,8 +298,8 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode, d = de; top = (struct ext4_dir_entry *)(((void *)de) + - (EXT4_BLOCK_SIZE(inode->i_sb) - - sizeof(struct ext4_dir_entry_tail))); + (EXT4_BLOCK_SIZE(inode_sb(inode)) - + sizeof(struct ext4_dir_entry_tail))); while (d < top && d->rec_len) d = (struct ext4_dir_entry *)(((void *)d) + le16_to_cpu(d->rec_len)); @@ -309,7 +309,7 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode, t = (struct ext4_dir_entry_tail *)d; #else - t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode->i_sb)); + t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode_sb(inode))); #endif if (t->det_reserved_zero1 || @@ -324,7 +324,7 @@ static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode, static __le32 ext4_dirent_csum(struct inode *inode, struct ext4_dir_entry *dirent, int size) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); struct ext4_inode_info *ei = EXT4_I(inode); __u32 csum; @@ -346,7 +346,7 @@ int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent) { struct ext4_dir_entry_tail *t; - if (!ext4_has_metadata_csum(inode->i_sb)) + if (!ext4_has_metadata_csum(inode_sb(inode))) return 1; t = get_dirent_tail(inode, dirent); @@ -367,7 +367,7 @@ static void ext4_dirent_csum_set(struct inode *inode, { struct ext4_dir_entry_tail *t; - if (!ext4_has_metadata_csum(inode->i_sb)) + if (!ext4_has_metadata_csum(inode_sb(inode))) return; t = get_dirent_tail(inode, dirent); @@ -396,12 +396,12 @@ static struct dx_countlimit *get_dx_countlimit(struct inode *inode, struct dx_root_info *root; int count_offset; - if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb)) + if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode_sb(inode))) count_offset = 8; else if (le16_to_cpu(dirent->rec_len) == 12) { dp = (struct ext4_dir_entry *)(((void *)dirent) + 12); if (le16_to_cpu(dp->rec_len) != - EXT4_BLOCK_SIZE(inode->i_sb) - 12) + EXT4_BLOCK_SIZE(inode_sb(inode)) - 12) return NULL; root = (struct dx_root_info *)(((void *)dp + 12)); if (root->reserved_zero || @@ -419,7 +419,7 @@ static struct dx_countlimit *get_dx_countlimit(struct inode *inode, static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent, int count_offset, int count, struct dx_tail *t) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); struct ext4_inode_info *ei = EXT4_I(inode); __u32 csum; int size; @@ -441,7 +441,7 @@ static int ext4_dx_csum_verify(struct inode *inode, struct dx_tail *t; int count_offset, limit, count; - if (!ext4_has_metadata_csum(inode->i_sb)) + if (!ext4_has_metadata_csum(inode_sb(inode))) return 1; c = get_dx_countlimit(inode, dirent, &count_offset); @@ -452,7 +452,7 @@ static int ext4_dx_csum_verify(struct inode *inode, limit = le16_to_cpu(c->limit); count = le16_to_cpu(c->count); if (count_offset + (limit * sizeof(struct dx_entry)) > - EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { + EXT4_BLOCK_SIZE(inode_sb(inode)) - sizeof(struct dx_tail)) { warn_no_space_for_csum(inode); return 0; } @@ -470,7 +470,7 @@ static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent) struct dx_tail *t; int count_offset, limit, count; - if (!ext4_has_metadata_csum(inode->i_sb)) + if (!ext4_has_metadata_csum(inode_sb(inode))) return; c = get_dx_countlimit(inode, dirent, &count_offset); @@ -481,7 +481,7 @@ static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent) limit = le16_to_cpu(c->limit); count = le16_to_cpu(c->count); if (count_offset + (limit * sizeof(struct dx_entry)) > - EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { + EXT4_BLOCK_SIZE(inode_sb(inode)) - sizeof(struct dx_tail)) { warn_no_space_for_csum(inode); return; } @@ -555,19 +555,19 @@ static inline void dx_set_limit(struct dx_entry *entries, unsigned value) static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize) { - unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) - + unsigned entry_space = inode_sb(dir)->s_blocksize - EXT4_DIR_REC_LEN(1) - EXT4_DIR_REC_LEN(2) - infosize; - if (ext4_has_metadata_csum(dir->i_sb)) + if (ext4_has_metadata_csum(inode_sb(dir))) entry_space -= sizeof(struct dx_tail); return entry_space / sizeof(struct dx_entry); } static inline unsigned dx_node_limit(struct inode *dir) { - unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0); + unsigned entry_space = inode_sb(dir)->s_blocksize - EXT4_DIR_REC_LEN(0); - if (ext4_has_metadata_csum(dir->i_sb)) + if (ext4_has_metadata_csum(inode_sb(dir))) entry_space -= sizeof(struct dx_tail); return entry_space / sizeof(struct dx_entry); } @@ -689,7 +689,7 @@ static struct stats dx_show_leaf(struct inode *dir, struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir, struct dx_entry *entries, int levels) { - unsigned blocksize = dir->i_sb->s_blocksize; + unsigned blocksize = inode_sb(dir)->s_blocksize; unsigned count = dx_get_count(entries), names = 0, space = 0, i; unsigned bcount = 0; struct buffer_head *bh; @@ -758,8 +758,8 @@ dx_probe(struct ext4_filename *fname, struct inode *dir, hinfo = &fname->hinfo; hinfo->hash_version = root->info.hash_version; if (hinfo->hash_version <= DX_HASH_TEA) - hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; - hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed; + hinfo->hash_version += EXT4_SB(inode_sb(dir))->s_hash_unsigned; + hinfo->seed = EXT4_SB(inode_sb(dir))->s_hash_seed; if (fname && fname_name(fname)) ext4fs_dirhash(fname_name(fname), fname_len(fname), hinfo); hash = hinfo->hash; @@ -771,13 +771,13 @@ dx_probe(struct ext4_filename *fname, struct inode *dir, } indirect = root->info.indirect_levels; - if (indirect >= ext4_dir_htree_level(dir->i_sb)) { - ext4_warning(dir->i_sb, + if (indirect >= ext4_dir_htree_level(inode_sb(dir))) { + ext4_warning(inode_sb(dir), "Directory (ino: %lu) htree depth %#06x exceed" "supported value", dir->i_ino, - ext4_dir_htree_level(dir->i_sb)); - if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) { - ext4_warning(dir->i_sb, "Enable large directory " + ext4_dir_htree_level(inode_sb(dir))); + if (ext4_dir_htree_level(inode_sb(dir)) < EXT4_HTREE_LEVEL) { + ext4_warning(inode_sb(dir), "Enable large directory " "feature to access it"); } goto fail; @@ -981,7 +981,7 @@ static int htree_dirblock_to_tree(struct file *dir_file, de = (struct ext4_dir_entry_2 *) bh->b_data; top = (struct ext4_dir_entry_2 *) ((char *) de + - dir->i_sb->s_blocksize - + inode_sb(dir)->s_blocksize - EXT4_DIR_REC_LEN(0)); #ifdef CONFIG_EXT4_FS_ENCRYPTION /* Check if the directory is encrypted */ @@ -999,11 +999,11 @@ static int htree_dirblock_to_tree(struct file *dir_file, } } #endif - for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) { + for (; de < top; de = ext4_next_entry(de, inode_sb(dir)->s_blocksize)) { if (ext4_check_dir_entry(dir, NULL, de, bh, bh->b_data, bh->b_size, - (block<i_sb)) - + ((char *)de - bh->b_data))) { + (block<b_data))) { /* silently ignore the rest of the block */ break; } @@ -1078,11 +1078,11 @@ int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash, start_hash, start_minor_hash)); dir = file_inode(dir_file); if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) { - hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version; + hinfo.hash_version = EXT4_SB(inode_sb(dir))->s_def_hash_version; if (hinfo.hash_version <= DX_HASH_TEA) hinfo.hash_version += - EXT4_SB(dir->i_sb)->s_hash_unsigned; - hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; + EXT4_SB(inode_sb(dir))->s_hash_unsigned; + hinfo.seed = EXT4_SB(inode_sb(dir))->s_hash_seed; if (ext4_has_inline_data(dir)) { int has_inline_data = 1; count = htree_inlinedir_to_tree(dir_file, dir, 0, @@ -1118,7 +1118,7 @@ int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash, } if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) { de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data; - de = ext4_next_entry(de, dir->i_sb->s_blocksize); + de = ext4_next_entry(de, inode_sb(dir)->s_blocksize); tmp_str.name = de->name; tmp_str.len = de->name_len; err = ext4_htree_store_dirent(dir_file, 2, 0, @@ -1174,7 +1174,8 @@ static inline int search_dirblock(struct buffer_head *bh, unsigned int offset, struct ext4_dir_entry_2 **res_dir) { - return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir, + return ext4_search_dir(bh, bh->b_data, inode_sb(dir)->s_blocksize, + dir, fname, offset, res_dir); } @@ -1300,7 +1301,7 @@ int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size, } /* prevent looping on a bad block */ de_len = ext4_rec_len_from_disk(de->rec_len, - dir->i_sb->s_blocksize); + inode_sb(dir)->s_blocksize); if (de_len <= 0) return -1; offset += de_len; @@ -1312,7 +1313,7 @@ int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size, static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block, struct ext4_dir_entry *de) { - struct super_block *sb = dir->i_sb; + struct super_block *sb = inode_sb(dir); if (!is_dx(dir)) return 0; @@ -1355,7 +1356,7 @@ static struct buffer_head * ext4_find_entry (struct inode *dir, struct ext4_filename fname; *res_dir = NULL; - sb = dir->i_sb; + sb = inode_sb(dir); namelen = d_name->len; if (namelen > EXT4_NAME_LEN) return NULL; @@ -1490,7 +1491,7 @@ static struct buffer_head * ext4_dx_find_entry(struct inode *dir, struct ext4_filename *fname, struct ext4_dir_entry_2 **res_dir) { - struct super_block * sb = dir->i_sb; + struct super_block * sb = inode_sb(dir); struct dx_frame frames[EXT4_HTREE_LEVEL], *frame; struct buffer_head *bh; ext4_lblk_t block; @@ -1560,7 +1561,7 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi if (bh) { __u32 ino = le32_to_cpu(de->inode); brelse(bh); - if (!ext4_valid_inum(dir->i_sb, ino)) { + if (!ext4_valid_inum(inode_sb(dir), ino)) { EXT4_ERROR_INODE(dir, "bad inode number: %u", ino); return ERR_PTR(-EFSCORRUPTED); } @@ -1569,7 +1570,7 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi dentry); return ERR_PTR(-EFSCORRUPTED); } - inode = ext4_iget_normal(dir->i_sb, ino); + inode = ext4_iget_normal(inode_sb(dir), ino); if (inode == ERR_PTR(-ESTALE)) { EXT4_ERROR_INODE(dir, "deleted inode referenced: %u", @@ -1579,7 +1580,7 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi if (!IS_ERR(inode) && ext4_encrypted_inode(dir) && (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) && !fscrypt_has_permitted_context(dir, inode)) { - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "Inconsistent encryption contexts: %lu/%lu", dir->i_ino, inode->i_ino); iput(inode); @@ -1672,7 +1673,7 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir, struct buffer_head **bh,struct dx_frame *frame, struct dx_hash_info *hinfo) { - unsigned blocksize = dir->i_sb->s_blocksize; + unsigned blocksize = inode_sb(dir)->s_blocksize; unsigned count, continued; struct buffer_head *bh2; ext4_lblk_t newblock; @@ -1685,7 +1686,7 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir, int csum_size = 0; int err = 0, i; - if (ext4_has_metadata_csum(dir->i_sb)) + if (ext4_has_metadata_csum(inode_sb(dir))) csum_size = sizeof(struct ext4_dir_entry_tail); bh2 = ext4_append(handle, dir, &newblock); @@ -1774,7 +1775,7 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir, brelse(*bh); brelse(bh2); *bh = NULL; - ext4_std_error(dir->i_sb, err); + ext4_std_error(inode_sb(dir), err); return ERR_PTR(err); } @@ -1831,7 +1832,7 @@ void ext4_insert_dentry(struct inode *inode, } de->file_type = EXT4_FT_UNKNOWN; de->inode = cpu_to_le32(inode->i_ino); - ext4_set_de_type(inode->i_sb, de, inode->i_mode); + ext4_set_de_type(inode_sb(inode), de, inode->i_mode); de->name_len = fname_len(fname); memcpy(de->name, fname_name(fname), fname_len(fname)); } @@ -1849,11 +1850,11 @@ static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname, struct inode *inode, struct ext4_dir_entry_2 *de, struct buffer_head *bh) { - unsigned int blocksize = dir->i_sb->s_blocksize; + unsigned int blocksize = inode_sb(dir)->s_blocksize; int csum_size = 0; int err; - if (ext4_has_metadata_csum(inode->i_sb)) + if (ext4_has_metadata_csum(inode_sb(inode))) csum_size = sizeof(struct ext4_dir_entry_tail); if (!de) { @@ -1865,7 +1866,7 @@ static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname, BUFFER_TRACE(bh, "get_write_access"); err = ext4_journal_get_write_access(handle, bh); if (err) { - ext4_std_error(dir->i_sb, err); + ext4_std_error(inode_sb(dir), err); return err; } @@ -1890,7 +1891,7 @@ static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname, BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); err = ext4_handle_dirty_dirent_node(handle, dir, bh); if (err) - ext4_std_error(dir->i_sb, err); + ext4_std_error(inode_sb(dir), err); return 0; } @@ -1916,15 +1917,15 @@ static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname, struct fake_dirent *fde; int csum_size = 0; - if (ext4_has_metadata_csum(inode->i_sb)) + if (ext4_has_metadata_csum(inode_sb(inode))) csum_size = sizeof(struct ext4_dir_entry_tail); - blocksize = dir->i_sb->s_blocksize; + blocksize = inode_sb(dir)->s_blocksize; dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino)); BUFFER_TRACE(bh, "get_write_access"); retval = ext4_journal_get_write_access(handle, bh); if (retval) { - ext4_std_error(dir->i_sb, retval); + ext4_std_error(inode_sb(dir), retval); brelse(bh); return retval; } @@ -1970,7 +1971,7 @@ static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname, blocksize); memset (&root->info, 0, sizeof(root->info)); root->info.info_length = sizeof(root->info); - root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version; + root->info.hash_version = EXT4_SB(inode_sb(dir))->s_def_hash_version; entries = root->entries; dx_set_block(entries, 1); dx_set_count(entries, 1); @@ -1979,8 +1980,8 @@ static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname, /* Initialize as for dx_probe */ fname->hinfo.hash_version = root->info.hash_version; if (fname->hinfo.hash_version <= DX_HASH_TEA) - fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; - fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; + fname->hinfo.hash_version += EXT4_SB(inode_sb(dir))->s_hash_unsigned; + fname->hinfo.seed = EXT4_SB(inode_sb(dir))->s_hash_seed; ext4fs_dirhash(fname_name(fname), fname_len(fname), &fname->hinfo); memset(frames, 0, sizeof(frames)); @@ -2041,10 +2042,10 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry, ext4_lblk_t block, blocks; int csum_size = 0; - if (ext4_has_metadata_csum(inode->i_sb)) + if (ext4_has_metadata_csum(inode_sb(inode))) csum_size = sizeof(struct ext4_dir_entry_tail); - sb = dir->i_sb; + sb = inode_sb(dir); blocksize = sb->s_blocksize; if (!dentry->d_name.len) return -EINVAL; @@ -2126,7 +2127,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname, struct dx_frame frames[EXT4_HTREE_LEVEL], *frame; struct dx_entry *entries, *at; struct buffer_head *bh; - struct super_block *sb = dir->i_sb; + struct super_block *sb = inode_sb(dir); struct ext4_dir_entry_2 *de; int restart; int err; @@ -2279,7 +2280,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname, goto cleanup; journal_error: - ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */ + ext4_std_error(inode_sb(dir), err); /* this is a no-op if err == 0 */ cleanup: brelse(bh); dx_release(frames); @@ -2304,7 +2305,7 @@ int ext4_generic_delete_entry(handle_t *handle, int csum_size) { struct ext4_dir_entry_2 *de, *pde; - unsigned int blocksize = dir->i_sb->s_blocksize; + unsigned int blocksize = inode_sb(dir)->s_blocksize; int i; i = 0; @@ -2349,7 +2350,7 @@ static int ext4_delete_entry(handle_t *handle, return err; } - if (ext4_has_metadata_csum(dir->i_sb)) + if (ext4_has_metadata_csum(inode_sb(dir))) csum_size = sizeof(struct ext4_dir_entry_tail); BUFFER_TRACE(bh, "get_write_access"); @@ -2359,7 +2360,7 @@ static int ext4_delete_entry(handle_t *handle, err = ext4_generic_delete_entry(handle, dir, de_del, bh, bh->b_data, - dir->i_sb->s_blocksize, csum_size); + inode_sb(dir)->s_blocksize, csum_size); if (err) goto out; @@ -2371,7 +2372,7 @@ static int ext4_delete_entry(handle_t *handle, return 0; out: if (err != -ENOENT) - ext4_std_error(dir->i_sb, err); + ext4_std_error(inode_sb(dir), err); return err; } @@ -2440,7 +2441,7 @@ static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode, if (err) return err; - credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + + credits = (EXT4_DATA_TRANS_BLOCKS(inode_sb(dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3); retry: inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0, @@ -2457,7 +2458,7 @@ static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode, } if (handle) ext4_journal_stop(handle); - if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) + if (err == -ENOSPC && ext4_should_retry_alloc(inode_sb(dir), &retries)) goto retry; return err; } @@ -2473,7 +2474,7 @@ static int ext4_mknod(struct inode *dir, struct dentry *dentry, if (err) return err; - credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + + credits = (EXT4_DATA_TRANS_BLOCKS(inode_sb(dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3); retry: inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0, @@ -2489,7 +2490,7 @@ static int ext4_mknod(struct inode *dir, struct dentry *dentry, } if (handle) ext4_journal_stop(handle); - if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) + if (err == -ENOSPC && ext4_should_retry_alloc(inode_sb(dir), &retries)) goto retry; return err; } @@ -2508,8 +2509,8 @@ static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) inode = ext4_new_inode_start_handle(dir, mode, NULL, 0, NULL, EXT4_HT_DIR, - EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + - 4 + EXT4_XATTR_TRANS_BLOCKS); + EXT4_MAXQUOTAS_INIT_BLOCKS(inode_sb(dir)) + + 4 + EXT4_XATTR_TRANS_BLOCKS); handle = ext4_journal_current_handle(); err = PTR_ERR(inode); if (!IS_ERR(inode)) { @@ -2525,7 +2526,7 @@ static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) } if (handle) ext4_journal_stop(handle); - if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) + if (err == -ENOSPC && ext4_should_retry_alloc(inode_sb(dir), &retries)) goto retry; return err; err_unlock_inode: @@ -2544,7 +2545,7 @@ struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode, de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len), blocksize); strcpy(de->name, "."); - ext4_set_de_type(inode->i_sb, de, S_IFDIR); + ext4_set_de_type(inode_sb(inode), de, S_IFDIR); de = ext4_next_entry(de, blocksize); de->inode = cpu_to_le32(parent_ino); @@ -2557,7 +2558,7 @@ struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode, de->rec_len = ext4_rec_len_to_disk( EXT4_DIR_REC_LEN(de->name_len), blocksize); strcpy(de->name, ".."); - ext4_set_de_type(inode->i_sb, de, S_IFDIR); + ext4_set_de_type(inode_sb(inode), de, S_IFDIR); return ext4_next_entry(de, blocksize); } @@ -2569,11 +2570,11 @@ static int ext4_init_new_dir(handle_t *handle, struct inode *dir, struct ext4_dir_entry_2 *de; struct ext4_dir_entry_tail *t; ext4_lblk_t block = 0; - unsigned int blocksize = dir->i_sb->s_blocksize; + unsigned int blocksize = inode_sb(dir)->s_blocksize; int csum_size = 0; int err; - if (ext4_has_metadata_csum(dir->i_sb)) + if (ext4_has_metadata_csum(inode_sb(dir))) csum_size = sizeof(struct ext4_dir_entry_tail); if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { @@ -2619,7 +2620,7 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) if (err) return err; - credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + + credits = (EXT4_DATA_TRANS_BLOCKS(inode_sb(dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3); retry: inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode, @@ -2659,7 +2660,7 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) out_stop: if (handle) ext4_journal_stop(handle); - if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) + if (err == -ENOSPC && ext4_should_retry_alloc(inode_sb(dir), &retries)) goto retry; return err; } @@ -2683,7 +2684,7 @@ bool ext4_empty_dir(struct inode *inode) return ret; } - sb = inode->i_sb; + sb = inode_sb(inode); if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) { EXT4_ERROR_INODE(inode, "invalid size"); return true; @@ -2746,7 +2747,7 @@ bool ext4_empty_dir(struct inode *inode) */ int ext4_orphan_add(handle_t *handle, struct inode *inode) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_iloc iloc; int err = 0, rc; @@ -2829,7 +2830,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode) { struct list_head *prev; struct ext4_inode_info *ei = EXT4_I(inode); - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); __u32 ino_next; struct ext4_iloc iloc; int err = 0; @@ -2874,7 +2875,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode) } sbi->s_es->s_last_orphan = cpu_to_le32(ino_next); mutex_unlock(&sbi->s_orphan_lock); - err = ext4_handle_dirty_super(handle, inode->i_sb); + err = ext4_handle_dirty_super(handle, inode_sb(inode)); } else { struct ext4_iloc iloc2; struct inode *i_prev = @@ -2896,7 +2897,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode) NEXT_ORPHAN(inode) = 0; err = ext4_mark_iloc_dirty(handle, inode, &iloc); out_err: - ext4_std_error(inode->i_sb, err); + ext4_std_error(inode_sb(inode), err); return err; out_brelse: @@ -2912,7 +2913,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry) struct ext4_dir_entry_2 *de; handle_t *handle = NULL; - if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(dir))))) return -EIO; /* Initialize quotas before so that eventual writes go in @@ -2942,7 +2943,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry) goto end_rmdir; handle = ext4_journal_start(dir, EXT4_HT_DIR, - EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); + EXT4_DATA_TRANS_BLOCKS(inode_sb(dir))); if (IS_ERR(handle)) { retval = PTR_ERR(handle); handle = NULL; @@ -2988,7 +2989,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry) struct ext4_dir_entry_2 *de; handle_t *handle = NULL; - if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(dir))))) return -EIO; trace_ext4_unlink_enter(dir, dentry); @@ -3015,7 +3016,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry) goto end_unlink; handle = ext4_journal_start(dir, EXT4_HT_DIR, - EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); + EXT4_DATA_TRANS_BLOCKS(inode_sb(dir))); if (IS_ERR(handle)) { retval = PTR_ERR(handle); handle = NULL; @@ -3059,10 +3060,11 @@ static int ext4_symlink(struct inode *dir, int credits; struct fscrypt_str disk_link; - if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(dir))))) return -EIO; - err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize, + err = fscrypt_prepare_symlink(dir, symname, len, + inode_sb(dir)->s_blocksize, &disk_link); if (err) return err; @@ -3078,7 +3080,7 @@ static int ext4_symlink(struct inode *dir, * group descriptor, sb, inode block, quota blocks, and * possibly selinux xattr blocks. */ - credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + + credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(inode_sb(dir)) + EXT4_XATTR_TRANS_BLOCKS; } else { /* @@ -3087,7 +3089,7 @@ static int ext4_symlink(struct inode *dir, * allocate new inode (bitmap, group descriptor, inode block, * quota blocks, sb is already counted in previous macros). */ - credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + + credits = EXT4_DATA_TRANS_BLOCKS(inode_sb(dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3; } @@ -3137,7 +3139,7 @@ static int ext4_symlink(struct inode *dir, * + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified */ handle = ext4_journal_start(dir, EXT4_HT_DIR, - EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + + EXT4_DATA_TRANS_BLOCKS(inode_sb(dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1); if (IS_ERR(handle)) { err = PTR_ERR(handle); @@ -3205,7 +3207,7 @@ static int ext4_link(struct dentry *old_dentry, retry: handle = ext4_journal_start(dir, EXT4_HT_DIR, - (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + + (EXT4_DATA_TRANS_BLOCKS(inode_sb(dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1); if (IS_ERR(handle)) return PTR_ERR(handle); @@ -3231,7 +3233,7 @@ static int ext4_link(struct dentry *old_dentry, iput(inode); } ext4_journal_stop(handle); - if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) + if (err == -ENOSPC && ext4_should_retry_alloc(inode_sb(dir), &retries)) goto retry; return err; } @@ -3258,7 +3260,7 @@ static struct buffer_head *ext4_get_first_dir_block(handle_t *handle, } *parent_de = ext4_next_entry( (struct ext4_dir_entry_2 *)bh->b_data, - inode->i_sb->s_blocksize); + inode_sb(inode)->s_blocksize); return bh; } @@ -3320,7 +3322,7 @@ static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent, retval = ext4_mark_inode_dirty(handle, ent->inode); } if (retval) { - ext4_std_error(ent->dir->i_sb, retval); + ext4_std_error(inode_sb(ent->dir), retval); return retval; } return 0; @@ -3336,7 +3338,7 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent, if (retval) return retval; ent->de->inode = cpu_to_le32(ino); - if (ext4_has_feature_filetype(ent->dir->i_sb)) + if (ext4_has_feature_filetype(inode_sb(ent->dir))) ent->de->file_type = file_type; inode_inc_iversion(ent->dir); ent->dir->i_ctime = ent->dir->i_mtime = @@ -3347,7 +3349,7 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent, retval = ext4_handle_dirty_dirent_node(handle, ent->dir, ent->bh); if (unlikely(retval)) { - ext4_std_error(ent->dir->i_sb, retval); + ext4_std_error(inode_sb(ent->dir), retval); return retval; } } @@ -3428,7 +3430,7 @@ static struct inode *ext4_whiteout_for_rename(struct ext4_renament *ent, * for inode block, sb block, group summaries, * and inode bitmap */ - credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) + + credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(inode_sb(ent->dir)) + EXT4_XATTR_TRANS_BLOCKS + 4); retry: wh = ext4_new_inode_start_handle(ent->dir, S_IFCHR | WHITEOUT_MODE, @@ -3440,7 +3442,7 @@ static struct inode *ext4_whiteout_for_rename(struct ext4_renament *ent, if (handle) ext4_journal_stop(handle); if (PTR_ERR(wh) == -ENOSPC && - ext4_should_retry_alloc(ent->dir->i_sb, &retries)) + ext4_should_retry_alloc(inode_sb(ent->dir), &retries)) goto retry; } else { *h = handle; @@ -3525,10 +3527,10 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry, new.bh = NULL; } } - if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC)) + if (new.inode && !test_opt(inode_sb(new.dir), NO_AUTO_DA_ALLOC)) ext4_alloc_da_blocks(old.inode); - credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + + credits = (2 * EXT4_DATA_TRANS_BLOCKS(inode_sb(old.dir)) + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2); if (!(flags & RENAME_WHITEOUT)) { handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits); @@ -3719,7 +3721,7 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry, goto end_rename; handle = ext4_journal_start(old.dir, EXT4_HT_DIR, - (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + + (2 * EXT4_DATA_TRANS_BLOCKS(inode_sb(old.dir)) + 2 * EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2)); if (IS_ERR(handle)) { retval = PTR_ERR(handle); @@ -3805,7 +3807,7 @@ static int ext4_rename2(struct inode *old_dir, struct dentry *old_dentry, { int err; - if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(old_dir))))) return -EIO; if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT)) diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c index db7590178dfc..fb8493a31e94 100644 --- a/fs/ext4/page-io.c +++ b/fs/ext4/page-io.c @@ -158,8 +158,8 @@ static int ext4_end_io(ext4_io_end_t *io) io->handle = NULL; /* Following call will use up the handle */ ret = ext4_convert_unwritten_extents(handle, inode, offset, size); - if (ret < 0 && !ext4_forced_shutdown(EXT4_SB(inode->i_sb))) { - ext4_msg(inode->i_sb, KERN_EMERG, + if (ret < 0 && !ext4_forced_shutdown(EXT4_SB(inode_sb(inode)))) { + ext4_msg(inode_sb(inode), KERN_EMERG, "failed to convert unwritten extents to written " "extents -- potential data loss! " "(inode %lu, offset %llu, size %zd, error %d)", @@ -197,7 +197,7 @@ static void dump_completed_IO(struct inode *inode, struct list_head *head) static void ext4_add_complete_io(ext4_io_end_t *io_end) { struct ext4_inode_info *ei = EXT4_I(io_end->inode); - struct ext4_sb_info *sbi = EXT4_SB(io_end->inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(io_end->inode)); struct workqueue_struct *wq; unsigned long flags; @@ -314,7 +314,8 @@ static void ext4_end_bio(struct bio *bio) if (bio->bi_status) { struct inode *inode = io_end->inode; - ext4_warning(inode->i_sb, "I/O error %d writing to inode %lu " + ext4_warning(inode_sb(inode), + "I/O error %d writing to inode %lu " "(offset %llu size %ld starting block %llu)", bio->bi_status, inode->i_ino, (unsigned long long) io_end->offset, diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c index 9ffa6fad18db..7cfb7bd0fe1d 100644 --- a/fs/ext4/readpage.c +++ b/fs/ext4/readpage.c @@ -112,7 +112,7 @@ int ext4_mpage_readpages(struct address_space *mapping, sector_t last_block_in_file; sector_t blocks[MAX_BUF_PER_PAGE]; unsigned page_block; - struct block_device *bdev = inode->i_sb->s_bdev; + struct block_device *bdev = inode_sb(inode)->s_bdev; int length; unsigned relative_block = 0; struct ext4_map_blocks map; diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c index b6bec270a8e4..c1cf292c62fc 100644 --- a/fs/ext4/resize.c +++ b/fs/ext4/resize.c @@ -776,7 +776,7 @@ static int verify_reserved_gdb(struct super_block *sb, static int add_new_gdb(handle_t *handle, struct inode *inode, ext4_group_t group) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct ext4_super_block *es = EXT4_SB(sb)->s_es; unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb); ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num; @@ -957,7 +957,7 @@ static int add_new_gdb_meta_bg(struct super_block *sb, static int reserve_backup_gdb(handle_t *handle, struct inode *inode, ext4_group_t group) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); int cluster_bits = EXT4_SB(sb)->s_cluster_bits; struct buffer_head **primary; diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 39bf464c35f1..144095b55900 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -467,31 +467,33 @@ void __ext4_error_inode(struct inode *inode, const char *function, { va_list args; struct va_format vaf; - struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; + struct ext4_super_block *es = EXT4_SB(inode_sb(inode))->s_es; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return; es->s_last_error_ino = cpu_to_le32(inode->i_ino); es->s_last_error_block = cpu_to_le64(block); - if (ext4_error_ratelimit(inode->i_sb)) { + if (ext4_error_ratelimit(inode_sb(inode))) { va_start(args, fmt); vaf.fmt = fmt; vaf.va = &args; if (block) printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: " "inode #%lu: block %llu: comm %s: %pV\n", - inode->i_sb->s_id, function, line, inode->i_ino, + inode_sb(inode)->s_id, function, line, + inode->i_ino, block, current->comm, &vaf); else printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: " "inode #%lu: comm %s: %pV\n", - inode->i_sb->s_id, function, line, inode->i_ino, + inode_sb(inode)->s_id, function, line, + inode->i_ino, current->comm, &vaf); va_end(args); } - save_error_info(inode->i_sb, function, line); - ext4_handle_error(inode->i_sb); + save_error_info(inode_sb(inode), function, line); + ext4_handle_error(inode_sb(inode)); } void __ext4_error_file(struct file *file, const char *function, @@ -504,12 +506,12 @@ void __ext4_error_file(struct file *file, const char *function, struct inode *inode = file_inode(file); char pathname[80], *path; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return; - es = EXT4_SB(inode->i_sb)->s_es; + es = EXT4_SB(inode_sb(inode))->s_es; es->s_last_error_ino = cpu_to_le32(inode->i_ino); - if (ext4_error_ratelimit(inode->i_sb)) { + if (ext4_error_ratelimit(inode_sb(inode))) { path = file_path(file, pathname, sizeof(pathname)); if (IS_ERR(path)) path = "(unknown)"; @@ -520,18 +522,20 @@ void __ext4_error_file(struct file *file, const char *function, printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: inode #%lu: " "block %llu: comm %s: path %s: %pV\n", - inode->i_sb->s_id, function, line, inode->i_ino, + inode_sb(inode)->s_id, function, line, + inode->i_ino, block, current->comm, path, &vaf); else printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: inode #%lu: " "comm %s: path %s: %pV\n", - inode->i_sb->s_id, function, line, inode->i_ino, + inode_sb(inode)->s_id, function, line, + inode->i_ino, current->comm, path, &vaf); va_end(args); } - save_error_info(inode->i_sb, function, line); - ext4_handle_error(inode->i_sb); + save_error_info(inode_sb(inode), function, line); + ext4_handle_error(inode_sb(inode)); } const char *ext4_decode_error(struct super_block *sb, int errno, @@ -693,14 +697,14 @@ void __ext4_warning_inode(const struct inode *inode, const char *function, struct va_format vaf; va_list args; - if (!ext4_warning_ratelimit(inode->i_sb)) + if (!ext4_warning_ratelimit(inode_sb(inode))) return; va_start(args, fmt); vaf.fmt = fmt; vaf.va = &args; printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: " - "inode #%lu: comm %s: %pV\n", inode->i_sb->s_id, + "inode #%lu: comm %s: %pV\n", inode_sb(inode)->s_id, function, line, inode->i_ino, current->comm, &vaf); va_end(args); } @@ -840,7 +844,7 @@ static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi) struct inode *inode = orphan_list_entry(l); printk(KERN_ERR " " "inode %s:%lu at %p: mode %o, nlink %d, next %d\n", - inode->i_sb->s_id, inode->i_ino, inode, + inode_sb(inode)->s_id, inode->i_ino, inode, inode->i_mode, inode->i_nlink, NEXT_ORPHAN(inode)); } @@ -1014,7 +1018,7 @@ static void ext4_i_callback(struct rcu_head *head) static void ext4_destroy_inode(struct inode *inode) { if (!list_empty(&(EXT4_I(inode)->i_orphan))) { - ext4_msg(inode->i_sb, KERN_ERR, + ext4_msg(inode_sb(inode), KERN_ERR, "Inode %lu (%p): orphan list check failed!", inode->i_ino, EXT4_I(inode)); print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4, @@ -1223,7 +1227,7 @@ static int ext4_set_context(struct inode *inode, const void *ctx, size_t len, } res2 = ext4_journal_stop(handle); - if (res == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) + if (res == -ENOSPC && ext4_should_retry_alloc(inode_sb(inode), &retries)) goto retry; if (!res) res = res2; @@ -1232,13 +1236,13 @@ static int ext4_set_context(struct inode *inode, const void *ctx, size_t len, static bool ext4_dummy_context(struct inode *inode) { - return DUMMY_ENCRYPTION_ENABLED(EXT4_SB(inode->i_sb)); + return DUMMY_ENCRYPTION_ENABLED(EXT4_SB(inode_sb(inode))); } static unsigned ext4_max_namelen(struct inode *inode) { - return S_ISLNK(inode->i_mode) ? inode->i_sb->s_blocksize : - EXT4_NAME_LEN; + return S_ISLNK(inode->i_mode) ? inode_sb(inode)->s_blocksize : + EXT4_NAME_LEN; } static const struct fscrypt_operations ext4_cryptops = { @@ -2509,7 +2513,7 @@ static void ext4_orphan_cleanup(struct super_block *sb, truncate_inode_pages(inode->i_mapping, inode->i_size); ret = ext4_truncate(inode); if (ret) - ext4_std_error(inode->i_sb, ret); + ext4_std_error(inode_sb(inode), ret); inode_unlock(inode); nr_truncates++; } else { @@ -5674,7 +5678,7 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type, EXT4_GET_BLOCKS_CREATE | EXT4_GET_BLOCKS_METADATA_NOFAIL); } while (IS_ERR(bh) && (PTR_ERR(bh) == -ENOSPC) && - ext4_should_retry_alloc(inode->i_sb, &retries)); + ext4_should_retry_alloc(inode_sb(inode), &retries)); if (IS_ERR(bh)) return PTR_ERR(bh); if (!bh) diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c index dd05af983092..bae9b69192e9 100644 --- a/fs/ext4/symlink.c +++ b/fs/ext4/symlink.c @@ -43,7 +43,7 @@ static const char *ext4_encrypted_get_link(struct dentry *dentry, if (IS_ERR(cpage)) return ERR_CAST(cpage); caddr = page_address(cpage); - max_size = inode->i_sb->s_blocksize; + max_size = inode_sb(inode)->s_blocksize; } paddr = fscrypt_get_symlink(inode, caddr, max_size, done); diff --git a/fs/ext4/sysfs.c b/fs/ext4/sysfs.c index 1205261f130c..d36b4f0a3bf7 100644 --- a/fs/ext4/sysfs.c +++ b/fs/ext4/sysfs.c @@ -52,7 +52,7 @@ struct ext4_attr { static ssize_t session_write_kbytes_show(struct ext4_attr *a, struct ext4_sb_info *sbi, char *buf) { - struct super_block *sb = sbi->s_buddy_cache->i_sb; + struct super_block *sb = inode_sb(sbi->s_buddy_cache); if (!sb->s_bdev->bd_part) return snprintf(buf, PAGE_SIZE, "0\n"); @@ -64,7 +64,7 @@ static ssize_t session_write_kbytes_show(struct ext4_attr *a, static ssize_t lifetime_write_kbytes_show(struct ext4_attr *a, struct ext4_sb_info *sbi, char *buf) { - struct super_block *sb = sbi->s_buddy_cache->i_sb; + struct super_block *sb = inode_sb(sbi->s_buddy_cache); if (!sb->s_bdev->bd_part) return snprintf(buf, PAGE_SIZE, "0\n"); diff --git a/fs/ext4/truncate.h b/fs/ext4/truncate.h index 0cb13badf473..aa73c6ec827b 100644 --- a/fs/ext4/truncate.h +++ b/fs/ext4/truncate.h @@ -25,7 +25,7 @@ static inline unsigned long ext4_blocks_for_truncate(struct inode *inode) { ext4_lblk_t needed; - needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); + needed = inode->i_blocks >> (inode_sb(inode)->s_blocksize_bits - 9); /* Give ourselves just enough room to cope with inodes in which * i_blocks is corrupt: we've seen disk corruptions in the past @@ -41,6 +41,6 @@ static inline unsigned long ext4_blocks_for_truncate(struct inode *inode) if (needed > EXT4_MAX_TRANS_DATA) needed = EXT4_MAX_TRANS_DATA; - return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed; + return EXT4_DATA_TRANS_BLOCKS(inode_sb(inode)) + needed; } diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index 63656dbafdc4..26211c1db4cc 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -65,7 +65,8 @@ #ifdef EXT4_XATTR_DEBUG # define ea_idebug(inode, fmt, ...) \ printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \ - inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__) + inode_sb(inode)->s_id, inode->i_ino, + ##__VA_ARGS__) # define ea_bdebug(bh, fmt, ...) \ printk(KERN_DEBUG "block %pg:%lu: " fmt "\n", \ bh->b_bdev, (unsigned long)bh->b_blocknr, ##__VA_ARGS__) @@ -109,10 +110,10 @@ const struct xattr_handler *ext4_xattr_handlers[] = { }; #define EA_BLOCK_CACHE(inode) (((struct ext4_sb_info *) \ - inode->i_sb->s_fs_info)->s_ea_block_cache) + inode_sb(inode)->s_fs_info)->s_ea_block_cache) #define EA_INODE_CACHE(inode) (((struct ext4_sb_info *) \ - inode->i_sb->s_fs_info)->s_ea_inode_cache) + inode_sb(inode)->s_fs_info)->s_ea_inode_cache) static int ext4_expand_inode_array(struct ext4_xattr_inode_array **ea_inode_array, @@ -129,7 +130,7 @@ static __le32 ext4_xattr_block_csum(struct inode *inode, sector_t block_nr, struct ext4_xattr_header *hdr) { - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); __u32 csum; __le64 dsk_block_nr = cpu_to_le64(block_nr); __u32 dummy_csum = 0; @@ -141,7 +142,7 @@ static __le32 ext4_xattr_block_csum(struct inode *inode, csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum)); offset += sizeof(dummy_csum); csum = ext4_chksum(sbi, csum, (__u8 *)hdr + offset, - EXT4_BLOCK_SIZE(inode->i_sb) - offset); + EXT4_BLOCK_SIZE(inode_sb(inode)) - offset); return cpu_to_le32(csum); } @@ -152,7 +153,7 @@ static int ext4_xattr_block_csum_verify(struct inode *inode, struct ext4_xattr_header *hdr = BHDR(bh); int ret = 1; - if (ext4_has_metadata_csum(inode->i_sb)) { + if (ext4_has_metadata_csum(inode_sb(inode))) { lock_buffer(bh); ret = (hdr->h_checksum == ext4_xattr_block_csum(inode, bh->b_blocknr, hdr)); @@ -164,7 +165,7 @@ static int ext4_xattr_block_csum_verify(struct inode *inode, static void ext4_xattr_block_csum_set(struct inode *inode, struct buffer_head *bh) { - if (ext4_has_metadata_csum(inode->i_sb)) + if (ext4_has_metadata_csum(inode_sb(inode))) BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode, bh->b_blocknr, BHDR(bh)); } @@ -364,17 +365,17 @@ static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino, struct inode *inode; int err; - inode = ext4_iget(parent->i_sb, ea_ino); + inode = ext4_iget(inode_sb(parent), ea_ino); if (IS_ERR(inode)) { err = PTR_ERR(inode); - ext4_error(parent->i_sb, + ext4_error(inode_sb(parent), "error while reading EA inode %lu err=%d", ea_ino, err); return err; } if (is_bad_inode(inode)) { - ext4_error(parent->i_sb, + ext4_error(inode_sb(parent), "error while reading EA inode %lu is_bad_inode", ea_ino); err = -EIO; @@ -382,7 +383,7 @@ static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino, } if (!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL)) { - ext4_error(parent->i_sb, + ext4_error(inode_sb(parent), "EA inode %lu does not have EXT4_EA_INODE_FL flag", ea_ino); err = -EINVAL; @@ -422,7 +423,8 @@ ext4_xattr_inode_verify_hashes(struct inode *ea_inode, u32 hash; /* Verify stored hash matches calculated hash. */ - hash = ext4_xattr_inode_hash(EXT4_SB(ea_inode->i_sb), buffer, size); + hash = ext4_xattr_inode_hash(EXT4_SB(inode_sb(ea_inode)), buffer, + size); if (hash != ext4_xattr_inode_get_hash(ea_inode)) return -EFSCORRUPTED; @@ -506,7 +508,7 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name, goto cleanup; ea_idebug(inode, "reading block %llu", (unsigned long long)EXT4_I(inode)->i_file_acl); - bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); + bh = sb_bread(inode_sb(inode), EXT4_I(inode)->i_file_acl); if (!bh) goto cleanup; ea_bdebug(bh, "b_count=%d, refcount=%d", @@ -563,7 +565,7 @@ ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name, return error; raw_inode = ext4_raw_inode(&iloc); header = IHDR(inode, raw_inode); - end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; + end = (void *)raw_inode + EXT4_SB(inode_sb(inode))->s_inode_size; error = xattr_check_inode(inode, header, end); if (error) goto cleanup; @@ -609,7 +611,7 @@ ext4_xattr_get(struct inode *inode, int name_index, const char *name, { int error; - if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode_sb(inode))))) return -EIO; if (strlen(name) > 255) @@ -670,7 +672,7 @@ ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size) goto cleanup; ea_idebug(inode, "reading block %llu", (unsigned long long)EXT4_I(inode)->i_file_acl); - bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); + bh = sb_bread(inode_sb(inode), EXT4_I(inode)->i_file_acl); error = -EIO; if (!bh) goto cleanup; @@ -708,7 +710,7 @@ ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size) return error; raw_inode = ext4_raw_inode(&iloc); header = IHDR(inode, raw_inode); - end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; + end = (void *)raw_inode + EXT4_SB(inode_sb(inode))->s_inode_size; error = xattr_check_inode(inode, header, end); if (error) goto cleanup; @@ -790,7 +792,7 @@ int ext4_get_inode_usage(struct inode *inode, qsize_t *usage) goto out; raw_inode = ext4_raw_inode(&iloc); header = IHDR(inode, raw_inode); - end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; + end = (void *)raw_inode + EXT4_SB(inode_sb(inode))->s_inode_size; ret = xattr_check_inode(inode, header, end); if (ret) goto out; @@ -802,7 +804,7 @@ int ext4_get_inode_usage(struct inode *inode, qsize_t *usage) } if (EXT4_I(inode)->i_file_acl) { - bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); + bh = sb_bread(inode_sb(inode), EXT4_I(inode)->i_file_acl); if (!bh) { ret = -EIO; goto out; @@ -828,7 +830,7 @@ int ext4_get_inode_usage(struct inode *inode, qsize_t *usage) static inline size_t round_up_cluster(struct inode *inode, size_t length) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); size_t cluster_size = 1 << (EXT4_SB(sb)->s_cluster_bits + inode->i_blkbits); size_t mask = ~(cluster_size - 1); @@ -959,7 +961,8 @@ static int ext4_xattr_ensure_credits(handle_t *handle, struct inode *inode, if (!error) return 0; if (error < 0) { - ext4_warning(inode->i_sb, "Extend journal (error %d)", error); + ext4_warning(inode_sb(inode), "Extend journal (error %d)", + error); return error; } @@ -968,7 +971,8 @@ static int ext4_xattr_ensure_credits(handle_t *handle, struct inode *inode, ext4_xattr_block_csum_set(inode, bh); error = ext4_handle_dirty_metadata(handle, NULL, bh); if (error) { - ext4_warning(inode->i_sb, "Handle metadata (error %d)", + ext4_warning(inode_sb(inode), + "Handle metadata (error %d)", error); return error; } @@ -976,14 +980,15 @@ static int ext4_xattr_ensure_credits(handle_t *handle, struct inode *inode, error = ext4_journal_restart(handle, credits); if (error) { - ext4_warning(inode->i_sb, "Restart journal (error %d)", error); + ext4_warning(inode_sb(inode), "Restart journal (error %d)", + error); return error; } if (bh) { error = ext4_journal_get_write_access(handle, bh); if (error) { - ext4_warning(inode->i_sb, + ext4_warning(inode_sb(inode), "Get write access failed (error %d)", error); return error; @@ -1115,7 +1120,7 @@ static int ext4_xattr_inode_inc_ref_all(handle_t *handle, struct inode *parent, le32_to_cpu(entry->e_hash), &ea_inode); if (err) { - ext4_warning(parent->i_sb, + ext4_warning(inode_sb(parent), "cleanup ea_ino %u iget error %d", ea_ino, err); continue; @@ -1244,7 +1249,7 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode, get_bh(bh); unlock_buffer(bh); - if (ext4_has_feature_ea_inode(inode->i_sb)) + if (ext4_has_feature_ea_inode(inode_sb(inode))) ext4_xattr_inode_dec_ref_all(handle, inode, bh, BFIRST(bh), true /* block_csum */, @@ -1288,12 +1293,12 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode, error = ext4_handle_dirty_metadata(handle, inode, bh); if (IS_SYNC(inode)) ext4_handle_sync(handle); - dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1)); + dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode_sb(inode)), 1)); ea_bdebug(bh, "refcount now=%d; releasing", le32_to_cpu(BHDR(bh)->h_refcount)); } out: - ext4_std_error(inode->i_sb, error); + ext4_std_error(inode_sb(inode), error); return; } @@ -1324,7 +1329,7 @@ static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode, { struct buffer_head *bh = NULL; unsigned long block = 0; - int blocksize = ea_inode->i_sb->s_blocksize; + int blocksize = inode_sb(ea_inode)->s_blocksize; int max_blocks = (bufsize + blocksize - 1) >> ea_inode->i_blkbits; int csize, wsize = 0; int ret = 0; @@ -1341,7 +1346,7 @@ static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode, if (ret <= 0) { ext4_mark_inode_dirty(handle, ea_inode); if (ret == -ENOSPC && - ext4_should_retry_alloc(ea_inode->i_sb, &retries)) { + ext4_should_retry_alloc(inode_sb(ea_inode), &retries)) { ret = 0; goto retry; } @@ -1401,7 +1406,7 @@ static struct inode *ext4_xattr_inode_create(handle_t *handle, * Let the next inode be the goal, so we try and allocate the EA inode * in the same group, or nearby one. */ - ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode, + ea_inode = ext4_new_inode(handle, inode_sb(inode)->s_root->d_inode, S_IFREG | 0600, NULL, inode->i_ino + 1, owner, EXT4_EA_INODE_FL); if (!IS_ERR(ea_inode)) { @@ -1457,7 +1462,7 @@ ext4_xattr_inode_cache_find(struct inode *inode, const void *value, } while (ce) { - ea_inode = ext4_iget(inode->i_sb, ce->e_value); + ea_inode = ext4_iget(inode_sb(inode), ce->e_value); if (!IS_ERR(ea_inode) && !is_bad_inode(ea_inode) && (EXT4_I(ea_inode)->i_flags & EXT4_EA_INODE_FL) && @@ -1491,7 +1496,8 @@ static int ext4_xattr_inode_lookup_create(handle_t *handle, struct inode *inode, u32 hash; int err; - hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len); + hash = ext4_xattr_inode_hash(EXT4_SB(inode_sb(inode)), value, + value_len); ea_inode = ext4_xattr_inode_cache_find(inode, value, value_len, hash); if (ea_inode) { err = ext4_xattr_inode_inc_ref(handle, ea_inode); @@ -1597,7 +1603,7 @@ static int ext4_xattr_set_entry(struct ext4_xattr_info *i, * attribute block so that a long value does not occupy the * whole space and prevent futher entries being added. */ - if (ext4_has_feature_ea_inode(inode->i_sb) && + if (ext4_has_feature_ea_inode(inode_sb(inode)) && new_size && is_block && (min_offs + old_size - new_size) < EXT4_XATTR_BLOCK_RESERVE(inode)) { @@ -1778,7 +1784,7 @@ static int ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i, struct ext4_xattr_block_find *bs) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); int error; ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld", @@ -1821,7 +1827,7 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode, struct ext4_xattr_info *i, struct ext4_xattr_block_find *bs) { - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); struct buffer_head *new_bh = NULL; struct ext4_xattr_search s_copy = bs->s; struct ext4_xattr_search *s = &s_copy; @@ -2158,7 +2164,7 @@ int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i, header = IHDR(inode, raw_inode); is->s.base = is->s.first = IFIRST(header); is->s.here = is->s.first; - is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; + is->s.end = (void *)raw_inode + EXT4_SB(inode_sb(inode))->s_inode_size; if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) { error = xattr_check_inode(inode, header, is->s.end); if (error) @@ -2257,7 +2263,7 @@ static struct buffer_head *ext4_xattr_get_block(struct inode *inode) if (!EXT4_I(inode)->i_file_acl) return NULL; - bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); + bh = sb_bread(inode_sb(inode), EXT4_I(inode)->i_file_acl); if (!bh) return ERR_PTR(-EIO); error = ext4_xattr_check_block(inode, bh); @@ -2317,7 +2323,7 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, goto cleanup; } - credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh, + credits = __ext4_xattr_set_credits(inode_sb(inode), inode, bh, value_len, flags & XATTR_CREATE); brelse(bh); @@ -2334,7 +2340,7 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) { struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc); - memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); + memset(raw_inode, 0, EXT4_SB(inode_sb(inode))->s_inode_size); ext4_clear_inode_state(inode, EXT4_STATE_NEW); } @@ -2371,9 +2377,9 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i)) goto cleanup; - if (ext4_has_feature_ea_inode(inode->i_sb) && + if (ext4_has_feature_ea_inode(inode_sb(inode)) && (EXT4_XATTR_SIZE(i.value_len) > - EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize))) + EXT4_XATTR_MIN_LARGE_EA_SIZE(inode_sb(inode)->s_blocksize))) i.in_inode = 1; retry_inode: error = ext4_xattr_ibody_set(handle, inode, &i, &is); @@ -2396,7 +2402,7 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, * Xattr does not fit in the block, store at * external inode if possible. */ - if (ext4_has_feature_ea_inode(inode->i_sb) && + if (ext4_has_feature_ea_inode(inode_sb(inode)) && !i.in_inode) { i.in_inode = 1; goto retry_inode; @@ -2405,7 +2411,7 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, } } if (!error) { - ext4_xattr_update_super_block(handle, inode->i_sb); + ext4_xattr_update_super_block(handle, inode_sb(inode)); inode->i_ctime = current_time(inode); if (!value) no_expand = 0; @@ -2434,7 +2440,7 @@ int ext4_xattr_set_credits(struct inode *inode, size_t value_len, *credits = 0; - if (!EXT4_SB(inode->i_sb)->s_journal) + if (!EXT4_SB(inode_sb(inode))->s_journal) return 0; down_read(&EXT4_I(inode)->xattr_sem); @@ -2443,7 +2449,8 @@ int ext4_xattr_set_credits(struct inode *inode, size_t value_len, if (IS_ERR(bh)) { err = PTR_ERR(bh); } else { - *credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh, + *credits = __ext4_xattr_set_credits(inode_sb(inode), inode, + bh, value_len, is_create); brelse(bh); err = 0; @@ -2466,7 +2473,7 @@ ext4_xattr_set(struct inode *inode, int name_index, const char *name, const void *value, size_t value_len, int flags) { handle_t *handle; - struct super_block *sb = inode->i_sb; + struct super_block *sb = inode_sb(inode); int error, retries = 0; int credits; @@ -2677,7 +2684,7 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize, { struct ext4_xattr_ibody_header *header; struct buffer_head *bh; - struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + struct ext4_sb_info *sbi = EXT4_SB(inode_sb(inode)); static unsigned int mnt_count; size_t min_offs; size_t ifree, bfree; @@ -2700,7 +2707,7 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize, */ base = IFIRST(header); - end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; + end = (void *)raw_inode + EXT4_SB(inode_sb(inode))->s_inode_size; min_offs = end - base; total_ino = sizeof(struct ext4_xattr_ibody_header); @@ -2717,7 +2724,7 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize, * EA block can hold new_extra_isize bytes. */ if (EXT4_I(inode)->i_file_acl) { - bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); + bh = sb_bread(inode_sb(inode), EXT4_I(inode)->i_file_acl); error = -EIO; if (!bh) goto cleanup; @@ -2744,7 +2751,7 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize, goto cleanup; } } else { - bfree = inode->i_sb->s_blocksize; + bfree = inode_sb(inode)->s_blocksize; } error = ext4_xattr_make_inode_space(handle, inode, raw_inode, @@ -2769,7 +2776,8 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize, cleanup: if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) { - ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.", + ext4_warning(inode_sb(inode), + "Unable to expand inode %lu. Delete some EAs or run e2fsck.", inode->i_ino); mnt_count = le16_to_cpu(sbi->s_es->s_mnt_count); } @@ -2849,7 +2857,7 @@ int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode, goto cleanup; } - if (ext4_has_feature_ea_inode(inode->i_sb) && + if (ext4_has_feature_ea_inode(inode_sb(inode)) && ext4_test_inode_state(inode, EXT4_STATE_XATTR)) { error = ext4_get_inode_loc(inode, &iloc); @@ -2876,7 +2884,7 @@ int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode, } if (EXT4_I(inode)->i_file_acl) { - bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); + bh = sb_bread(inode_sb(inode), EXT4_I(inode)->i_file_acl); if (!bh) { EXT4_ERROR_INODE(inode, "block %llu read error", EXT4_I(inode)->i_file_acl); @@ -2890,7 +2898,7 @@ int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode, goto cleanup; } - if (ext4_has_feature_ea_inode(inode->i_sb)) { + if (ext4_has_feature_ea_inode(inode_sb(inode))) { for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) { if (!entry->e_value_inum) @@ -3036,7 +3044,7 @@ ext4_xattr_block_cache_find(struct inode *inode, while (ce) { struct buffer_head *bh; - bh = sb_bread(inode->i_sb, ce->e_value); + bh = sb_bread(inode_sb(inode), ce->e_value); if (!bh) { EXT4_ERROR_INODE(inode, "block %lu read error", (unsigned long)ce->e_value); diff --git a/fs/ext4/xattr_user.c b/fs/ext4/xattr_user.c index d4546184b34b..d2d0b8d2c871 100644 --- a/fs/ext4/xattr_user.c +++ b/fs/ext4/xattr_user.c @@ -23,7 +23,7 @@ ext4_xattr_user_get(const struct xattr_handler *handler, struct dentry *unused, struct inode *inode, const char *name, void *buffer, size_t size) { - if (!test_opt(inode->i_sb, XATTR_USER)) + if (!test_opt(inode_sb(inode), XATTR_USER)) return -EOPNOTSUPP; return ext4_xattr_get(inode, EXT4_XATTR_INDEX_USER, name, buffer, size); @@ -35,7 +35,7 @@ ext4_xattr_user_set(const struct xattr_handler *handler, const char *name, const void *value, size_t size, int flags) { - if (!test_opt(inode->i_sb, XATTR_USER)) + if (!test_opt(inode_sb(inode), XATTR_USER)) return -EOPNOTSUPP; return ext4_xattr_set(inode, EXT4_XATTR_INDEX_USER, name, value, size, flags); -- 2.15.1