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

This patch adds the renamed functions moved from the f2fs crypto files.

1. definitions for per-file encryption used by ext4 and f2fs.

2. crypto.c for encrypt/decrypt functions
 a. IO preparation:
  - fscrypt_get_ctx / fscrypt_release_ctx
 b. before IOs:
  - fscrypt_encrypt_page
  - fscrypt_decrypt_page
  - fscrypt_zeroout_range
 c. after IOs:
  - fscrypt_decrypt_bio_pages
  - fscrypt_pullback_bio_page
  - fscrypt_restore_control_page

3. policy.c supporting context management.
 a. For ioctls:
  - fscrypt_process_policy
  - fscrypt_get_policy
 b. For context permission
  - fscrypt_has_permitted_context
  - fscrypt_inherit_context

4. keyinfo.c to handle permissions
  - fscrypt_get_encryption_info
  - fscrypt_free_encryption_info

5. fname.c to support filename encryption
 a. general wrapper functions
  - fscrypt_fname_disk_to_usr
  - fscrypt_fname_usr_to_disk
  - fscrypt_setup_filename
  - fscrypt_free_filename

 b. specific filename handling functions
  - fscrypt_fname_alloc_buffer
  - fscrypt_fname_free_buffer

6. Makefile and Kconfig

Cc: Al Viro <viro@ftp.linux.org.uk>
Signed-off-by: Michael Halcrow <mhalcrow@google.com>
Signed-off-by: Ildar Muslukhov <ildarm@google.com>
Signed-off-by: Uday Savagaonkar <savagaon@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

1 files changed, 22 insertions, 22 deletions

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 8f09da0552ac..f82e28b121a8 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -77,7 +77,7 @@ static unsigned long dir_block_index(unsigned int level,
 }
 
 static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
-                                struct f2fs_filename *fname,
+                                struct fscrypt_name *fname,
                                 f2fs_hash_t namehash,
                                 int *max_slots,
                                 struct page **res_page)
@@ -103,15 +103,15 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
         return de;
 }
 
-struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *fname,
+struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,
                         f2fs_hash_t namehash, int *max_slots,
                         struct f2fs_dentry_ptr *d)
 {
         struct f2fs_dir_entry *de;
         unsigned long bit_pos = 0;
         int max_len = 0;
-        struct f2fs_str de_name = FSTR_INIT(NULL, 0);
-        struct f2fs_str *name = &fname->disk_name;
+        struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
+        struct fscrypt_str *name = &fname->disk_name;
 
         if (max_slots)
                 *max_slots = 0;
@@ -157,7 +157,7 @@ found:
 
 static struct f2fs_dir_entry *find_in_level(struct inode *dir,
                                         unsigned int level,
-                                        struct f2fs_filename *fname,
+                                        struct fscrypt_name *fname,
                                         struct page **res_page)
 {
         struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
@@ -218,12 +218,12 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
         struct f2fs_dir_entry *de = NULL;
         unsigned int max_depth;
         unsigned int level;
-        struct f2fs_filename fname;
+        struct fscrypt_name fname;
         int err;
 
         *res_page = NULL;
 
-        err = f2fs_fname_setup_filename(dir, child, 1, &fname);
+        err = fscrypt_setup_filename(dir, child, 1, &fname);
         if (err)
                 return NULL;
 
@@ -251,7 +251,7 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
                         break;
         }
 out:
-        f2fs_fname_free_filename(&fname);
+        fscrypt_free_filename(&fname);
         return de;
 }
 
@@ -413,7 +413,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
                         goto put_error;
 
                 if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {
-                        err = f2fs_inherit_context(dir, inode, page);
+                        err = fscrypt_inherit_context(dir, inode, page, false);
                         if (err)
                                 goto put_error;
                 }
@@ -536,11 +536,11 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
         struct f2fs_dentry_block *dentry_blk = NULL;
         struct f2fs_dentry_ptr d;
         struct page *page = NULL;
-        struct f2fs_filename fname;
+        struct fscrypt_name fname;
         struct qstr new_name;
         int slots, err;
 
-        err = f2fs_fname_setup_filename(dir, name, 0, &fname);
+        err = fscrypt_setup_filename(dir, name, 0, &fname);
         if (err)
                 return err;
 
@@ -639,7 +639,7 @@ fail:
         kunmap(dentry_page);
         f2fs_put_page(dentry_page, 1);
 out:
-        f2fs_fname_free_filename(&fname);
+        fscrypt_free_filename(&fname);
         f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
         return err;
 }
@@ -781,12 +781,12 @@ bool f2fs_empty_dir(struct inode *dir)
 }
 
 bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
-                                unsigned int start_pos, struct f2fs_str *fstr)
+                        unsigned int start_pos, struct fscrypt_str *fstr)
 {
         unsigned char d_type = DT_UNKNOWN;
         unsigned int bit_pos;
         struct f2fs_dir_entry *de = NULL;
-        struct f2fs_str de_name = FSTR_INIT(NULL, 0);
+        struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
 
         bit_pos = ((unsigned long)ctx->pos % d->max);
 
@@ -820,8 +820,9 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
 
                         memcpy(de_name.name, d->filename[bit_pos], de_name.len);
 
-                        ret = f2fs_fname_disk_to_usr(d->inode, &de->hash_code,
-                                                        &de_name, fstr);
+                        ret = fscrypt_fname_disk_to_usr(d->inode,
+                                                (u32)de->hash_code, 0,
+                                                &de_name, fstr);
                         kfree(de_name.name);
                         if (ret < 0)
                                 return true;
@@ -849,16 +850,15 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
         struct file_ra_state *ra = &file->f_ra;
         unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
         struct f2fs_dentry_ptr d;
-        struct f2fs_str fstr = FSTR_INIT(NULL, 0);
+        struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
         int err = 0;
 
         if (f2fs_encrypted_inode(inode)) {
-                err = f2fs_get_encryption_info(inode);
+                err = fscrypt_get_encryption_info(inode);
                 if (err)
                         return err;
 
-                err = f2fs_fname_crypto_alloc_buffer(inode, F2FS_NAME_LEN,
-                                                                &fstr);
+                err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
                 if (err < 0)
                         return err;
         }
@@ -898,14 +898,14 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx)
                 f2fs_put_page(dentry_page, 1);
         }
 out:
-        f2fs_fname_crypto_free_buffer(&fstr);
+        fscrypt_fname_free_buffer(&fstr);
         return err;
 }
 
 static int f2fs_dir_open(struct inode *inode, struct file *filp)
 {
         if (f2fs_encrypted_inode(inode))
-                return f2fs_get_encryption_info(inode) ? -EACCES : 0;
+                return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
         return 0;
 }