fs crypto: move per-file encryption from f2fs tree to fs/crypto

[deliverable/linux.git] / fs / f2fs / file.c

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 0e2a2bde26351c26eec3de13d6b43a9ffbb17940..04ab1e4fc1dfe79de8c73f5308d9dadc2df2eb19 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -421,7 +421,7 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
        int err;
 
        if (f2fs_encrypted_inode(inode)) {
-               err = f2fs_get_encryption_info(inode);
+               err = fscrypt_get_encryption_info(inode);
                if (err)
                        return 0;
                if (!f2fs_encrypted_inode(inode))
@@ -443,10 +443,10 @@ static int f2fs_file_open(struct inode *inode, struct file *filp)
        int ret = generic_file_open(inode, filp);
 
        if (!ret && f2fs_encrypted_inode(inode)) {
-               ret = f2fs_get_encryption_info(inode);
+               ret = fscrypt_get_encryption_info(inode);
                if (ret)
                        return -EACCES;
-               if (!f2fs_encrypted_inode(inode))
+               if (!fscrypt_has_encryption_key(inode))
                        return -ENOKEY;
        }
        return ret;
@@ -526,7 +526,8 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
 truncate_out:
        f2fs_wait_on_page_writeback(page, DATA, true);
        zero_user(page, offset, PAGE_CACHE_SIZE - offset);
-       if (!cache_only || !f2fs_encrypted_inode(inode) || !S_ISREG(inode->i_mode))
+       if (!cache_only || !f2fs_encrypted_inode(inode) ||
+                                       !S_ISREG(inode->i_mode))
                set_page_dirty(page);
        f2fs_put_page(page, 1);
        return 0;
@@ -674,7 +675,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 
        if (attr->ia_valid & ATTR_SIZE) {
                if (f2fs_encrypted_inode(inode) &&
-                               f2fs_get_encryption_info(inode))
+                               fscrypt_get_encryption_info(inode))
                        return -EACCES;
 
                if (attr->ia_size <= i_size_read(inode)) {
@@ -857,10 +858,8 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src,
        } else {
                new_addr = dn.data_blkaddr;
                if (!is_checkpointed_data(sbi, new_addr)) {
-                       dn.data_blkaddr = NULL_ADDR;
                        /* do not invalidate this block address */
-                       set_data_blkaddr(&dn);
-                       f2fs_update_extent_cache(&dn);
+                       f2fs_update_data_blkaddr(&dn, NULL_ADDR);
                        do_replace = true;
                }
                f2fs_put_dnode(&dn);
@@ -911,9 +910,7 @@ static int __exchange_data_block(struct inode *inode, pgoff_t src,
 
 err_out:
        if (!get_dnode_of_data(&dn, src, LOOKUP_NODE)) {
-               dn.data_blkaddr = new_addr;
-               set_data_blkaddr(&dn);
-               f2fs_update_extent_cache(&dn);
+               f2fs_update_data_blkaddr(&dn, new_addr);
                f2fs_put_dnode(&dn);
        }
        return ret;
@@ -1053,12 +1050,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
 
                        if (dn.data_blkaddr != NEW_ADDR) {
                                invalidate_blocks(sbi, dn.data_blkaddr);
-
-                               dn.data_blkaddr = NEW_ADDR;
-                               set_data_blkaddr(&dn);
-
-                               dn.data_blkaddr = NULL_ADDR;
-                               f2fs_update_extent_cache(&dn);
+                               f2fs_update_data_blkaddr(&dn, NEW_ADDR);
                        }
                        f2fs_put_dnode(&dn);
                        f2fs_unlock_op(sbi);
@@ -1538,39 +1530,30 @@ static bool uuid_is_nonzero(__u8 u[16])
 
 static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
 {
-#ifdef CONFIG_F2FS_FS_ENCRYPTION
-       struct f2fs_encryption_policy policy;
+       struct fscrypt_policy policy;
        struct inode *inode = file_inode(filp);
 
-       if (copy_from_user(&policy, (struct f2fs_encryption_policy __user *)arg,
-                               sizeof(policy)))
+       if (copy_from_user(&policy, (struct fscrypt_policy __user *)arg,
+                                                       sizeof(policy)))
                return -EFAULT;
 
        f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
-       return f2fs_process_policy(&policy, inode);
-#else
-       return -EOPNOTSUPP;
-#endif
+       return fscrypt_process_policy(inode, &policy);
 }
 
 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
 {
-#ifdef CONFIG_F2FS_FS_ENCRYPTION
-       struct f2fs_encryption_policy policy;
+       struct fscrypt_policy policy;
        struct inode *inode = file_inode(filp);
        int err;
 
-       err = f2fs_get_policy(inode, &policy);
+       err = fscrypt_get_policy(inode, &policy);
        if (err)
                return err;
 
-       if (copy_to_user((struct f2fs_encryption_policy __user *)arg, &policy,
-                                                       sizeof(policy)))
+       if (copy_to_user((struct fscrypt_policy __user *)arg, &policy, sizeof(policy)))
                return -EFAULT;
        return 0;
-#else
-       return -EOPNOTSUPP;
-#endif
 }
 
 static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
@@ -1882,8 +1865,8 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        ssize_t ret;
 
        if (f2fs_encrypted_inode(inode) &&
-                               !f2fs_has_encryption_key(inode) &&
-                               f2fs_get_encryption_info(inode))
+                               !fscrypt_has_encryption_key(inode) &&
+                               fscrypt_get_encryption_info(inode))
                return -EACCES;
 
        inode_lock(inode);