ext4: use IS_ENCRYPTED() to check encryption status

This commit removes the ext4 specific ext4_encrypted_inode() and makes
use of the generic IS_ENCRYPTED() macro to check for the encryption
status of an inode.

Reviewed-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Chandan Rajendra <chandan@linux.vnet.ibm.com>
Signed-off-by: Eric Biggers <ebiggers@google.com>

diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index f93f9881ec184c351e69af715a849d1a01562b95..fb7a64ea5679fe5e837b183260f7fbbf5f824220 100644 (file)
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -111,7 +111,7 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx)
        int dir_has_error = 0;
        struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
 
-       if (ext4_encrypted_inode(inode)) {
+       if (IS_ENCRYPTED(inode)) {
                err = fscrypt_get_encryption_info(inode);
                if (err && err != -ENOKEY)
                        return err;
@@ -138,7 +138,7 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx)
                        return err;
        }
 
-       if (ext4_encrypted_inode(inode)) {
+       if (IS_ENCRYPTED(inode)) {
                err = fscrypt_fname_alloc_buffer(inode, EXT4_NAME_LEN, &fstr);
                if (err < 0)
                        return err;
@@ -245,7 +245,7 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx)
                        offset += ext4_rec_len_from_disk(de->rec_len,
                                        sb->s_blocksize);
                        if (le32_to_cpu(de->inode)) {
-                               if (!ext4_encrypted_inode(inode)) {
+                               if (!IS_ENCRYPTED(inode)) {
                                        if (!dir_emit(ctx, de->name,
                                            de->name_len,
                                            le32_to_cpu(de->inode),
@@ -613,7 +613,7 @@ finished:
 
 static int ext4_dir_open(struct inode * inode, struct file * filp)
 {
-       if (ext4_encrypted_inode(inode))
+       if (IS_ENCRYPTED(inode))
                return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
        return 0;
 }

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 185a05d3257e822136dabffa2a9cb4c58c8473ff..afdb9ad8be0e0beac0482b415c3ec77178f980eb 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -2279,11 +2279,6 @@ extern unsigned ext4_free_clusters_after_init(struct super_block *sb,
                                              struct ext4_group_desc *gdp);
 ext4_fsblk_t ext4_inode_to_goal_block(struct inode *);
 
-static inline bool ext4_encrypted_inode(struct inode *inode)
-{
-       return ext4_test_inode_flag(inode, EXT4_INODE_ENCRYPT);
-}
-
 #ifdef CONFIG_EXT4_FS_ENCRYPTION
 static inline int ext4_fname_setup_filename(struct inode *dir,
                        const struct qstr *iname,

diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h
index 15b6dd7337805ba51bc39606d6ab6c9212ba5db7..a1ac7e9245ecc46efaceda18901f513922937376 100644 (file)
--- a/fs/ext4/ext4_jbd2.h
+++ b/fs/ext4/ext4_jbd2.h
@@ -411,7 +411,7 @@ static inline int ext4_inode_journal_mode(struct inode *inode)
            (ext4_test_inode_flag(inode, EXT4_INODE_JOURNAL_DATA) &&
            !test_opt(inode->i_sb, DELALLOC))) {
                /* We do not support data journalling for encrypted data */
-               if (S_ISREG(inode->i_mode) && ext4_encrypted_inode(inode))
+               if (S_ISREG(inode->i_mode) && IS_ENCRYPTED(inode))
                        return EXT4_INODE_ORDERED_DATA_MODE;  /* ordered */
                return EXT4_INODE_JOURNAL_DATA_MODE;    /* journal data */
        }

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 240b6dea5441b2c3e58c73c4db90c5b3123e3422..79d986dbf5af551533dd95d5ec61e4f53ca586fc 100644 (file)
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -3631,7 +3631,7 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
                max_zeroout = sbi->s_extent_max_zeroout_kb >>
                        (inode->i_sb->s_blocksize_bits - 10);
 
-       if (ext4_encrypted_inode(inode))
+       if (IS_ENCRYPTED(inode))
                max_zeroout = 0;
 
        /*
@@ -4818,7 +4818,7 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
         * leave it disabled for encrypted inodes for now.  This is a
         * bug we should fix....
         */
-       if (ext4_encrypted_inode(inode) &&
+       if (IS_ENCRYPTED(inode) &&
            (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE |
                     FALLOC_FL_ZERO_RANGE)))
                return -EOPNOTSUPP;

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 7ff14a1adba3c17f2f901e029ba1d709539300a6..f3e17a8c84b40e2162745de3c78573fbe74c8920 100644 (file)
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -771,7 +771,7 @@ struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir,
        if (unlikely(ext4_forced_shutdown(sbi)))
                return ERR_PTR(-EIO);
 
-       if ((ext4_encrypted_inode(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) &&
+       if ((IS_ENCRYPTED(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) &&
            (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) &&
            !(i_flags & EXT4_EA_INODE_FL)) {
                err = fscrypt_get_encryption_info(dir);

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 34d7e0703cc6f1677010416f1671df883c85a669..71bd2d28f58deb9f37d1170f3fceeef0b6c843b2 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -415,7 +415,7 @@ int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
 {
        int ret;
 
-       if (ext4_encrypted_inode(inode))
+       if (IS_ENCRYPTED(inode))
                return fscrypt_zeroout_range(inode, lblk, pblk, len);
 
        ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS);
@@ -1217,8 +1217,7 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
                    (block_start < from || block_end > to)) {
                        ll_rw_block(REQ_OP_READ, 0, 1, &bh);
                        *wait_bh++ = bh;
-                       decrypt = ext4_encrypted_inode(inode) &&
-                               S_ISREG(inode->i_mode);
+                       decrypt = IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode);
                }
        }
        /*
@@ -3881,7 +3880,7 @@ static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
        ssize_t ret;
 
 #ifdef CONFIG_EXT4_FS_ENCRYPTION
-       if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode))
+       if (IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode))
                return 0;
 #endif
 
@@ -4065,8 +4064,7 @@ static int __ext4_block_zero_page_range(handle_t *handle,
                /* Uhhuh. Read error. Complain and punt. */
                if (!buffer_uptodate(bh))
                        goto unlock;
-               if (S_ISREG(inode->i_mode) &&
-                   ext4_encrypted_inode(inode)) {
+               if (S_ISREG(inode->i_mode) && IS_ENCRYPTED(inode)) {
                        /* We expect the key to be set. */
                        BUG_ON(!fscrypt_has_encryption_key(inode));
                        BUG_ON(blocksize != PAGE_SIZE);
@@ -4142,7 +4140,7 @@ static int ext4_block_truncate_page(handle_t *handle,
        struct inode *inode = mapping->host;
 
        /* If we are processing an encrypted inode during orphan list handling */
-       if (ext4_encrypted_inode(inode) && !fscrypt_has_encryption_key(inode))
+       if (IS_ENCRYPTED(inode) && !fscrypt_has_encryption_key(inode))
                return 0;
 
        blocksize = inode->i_sb->s_blocksize;
@@ -4722,7 +4720,7 @@ static bool ext4_should_use_dax(struct inode *inode)
                return false;
        if (ext4_has_inline_data(inode))
                return false;
-       if (ext4_encrypted_inode(inode))
+       if (ext4_test_inode_flag(inode, EXT4_INODE_ENCRYPT))
                return false;
        return true;
 }
@@ -5072,7 +5070,7 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
                        ret = -EFSCORRUPTED;
                        goto bad_inode;
                }
-               if (ext4_encrypted_inode(inode)) {
+               if (IS_ENCRYPTED(inode)) {
                        inode->i_op = &ext4_encrypted_symlink_inode_operations;
                        ext4_set_aops(inode);
                } else if (ext4_inode_is_fast_symlink(inode)) {

diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c
index 2f5be02fc6f6a2194f45adb5429f658c2d0a184a..1083a9f3f16a169cf594bbceab6f4164635d199a 100644 (file)
--- a/fs/ext4/move_extent.c
+++ b/fs/ext4/move_extent.c
@@ -592,8 +592,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, __u64 orig_blk,
                return -EOPNOTSUPP;
        }
 
-       if (ext4_encrypted_inode(orig_inode) ||
-           ext4_encrypted_inode(donor_inode)) {
+       if (IS_ENCRYPTED(orig_inode) || IS_ENCRYPTED(donor_inode)) {
                ext4_msg(orig_inode->i_sb, KERN_ERR,
                         "Online defrag not supported for encrypted files");
                return -EOPNOTSUPP;

diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 2b928eb07fa24292786904568232820390847464..be6cb69beb12a47b3568104f2f3e7e66adf7dd59 100644 (file)
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -621,7 +621,7 @@ static struct stats dx_show_leaf(struct inode *dir,
 
                                name  = de->name;
                                len = de->name_len;
-                               if (ext4_encrypted_inode(dir))
+                               if (IS_ENCRYPTED(dir))
                                        res = fscrypt_get_encryption_info(dir);
                                if (res) {
                                        printk(KERN_WARNING "Error setting up"
@@ -986,7 +986,7 @@ static int htree_dirblock_to_tree(struct file *dir_file,
                                           EXT4_DIR_REC_LEN(0));
 #ifdef CONFIG_EXT4_FS_ENCRYPTION
        /* Check if the directory is encrypted */
-       if (ext4_encrypted_inode(dir)) {
+       if (IS_ENCRYPTED(dir)) {
                err = fscrypt_get_encryption_info(dir);
                if (err < 0) {
                        brelse(bh);
@@ -1015,7 +1015,7 @@ static int htree_dirblock_to_tree(struct file *dir_file,
                        continue;
                if (de->inode == 0)
                        continue;
-               if (!ext4_encrypted_inode(dir)) {
+               if (!IS_ENCRYPTED(dir)) {
                        tmp_str.name = de->name;
                        tmp_str.len = de->name_len;
                        err = ext4_htree_store_dirent(dir_file,
@@ -1578,7 +1578,7 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi
                                         ino);
                        return ERR_PTR(-EFSCORRUPTED);
                }
-               if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
+               if (!IS_ERR(inode) && IS_ENCRYPTED(dir) &&
                    (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
                    !fscrypt_has_permitted_context(dir, inode)) {
                        ext4_warning(inode->i_sb,

diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 2aa62d58d8dd87e095bcb61f84aa78ef755463a1..c398b55da85414883f58b0cbbcef5ed78c3793d8 100644 (file)
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -477,8 +477,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
 
        bh = head = page_buffers(page);
 
-       if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode) &&
-           nr_to_submit) {
+       if (IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode) && nr_to_submit) {
                gfp_t gfp_flags = GFP_NOFS;
 
        retry_encrypt:

diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index 6aa282ee455a929aa2b5927e39d0f20c7bd33acd..52d3ff5a9db187eb42f505c89a69c3e17d030ed8 100644 (file)
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -242,8 +242,7 @@ int ext4_mpage_readpages(struct address_space *mapping,
                if (bio == NULL) {
                        struct fscrypt_ctx *ctx = NULL;
 
-                       if (ext4_encrypted_inode(inode) &&
-                           S_ISREG(inode->i_mode)) {
+                       if (IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode)) {
                                ctx = fscrypt_get_ctx(inode, GFP_NOFS);
                                if (IS_ERR(ctx))
                                        goto set_error_page;