f2fs crypto: add filename encryption for f2fs_lookup

This patch implements filename encryption support for f2fs_lookup.

Note that, f2fs_find_entry should be outside of f2fs_(un)lock_op().

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index ab6455de52f354f6cabfaa1b311ef34b545c3d23..5e10d9d8099c654e1e33364d835d973e4af17edb 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -76,20 +76,10 @@ static unsigned long dir_block_index(unsigned int level,
        return bidx;
 }
 
-static bool early_match_name(size_t namelen, f2fs_hash_t namehash,
-                               struct f2fs_dir_entry *de)
-{
-       if (le16_to_cpu(de->name_len) != namelen)
-               return false;
-
-       if (de->hash_code != namehash)
-               return false;
-
-       return true;
-}
-
 static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
-                               struct qstr *name, int *max_slots,
+                               struct f2fs_filename *fname,
+                               f2fs_hash_t namehash,
+                               int *max_slots,
                                struct page **res_page)
 {
        struct f2fs_dentry_block *dentry_blk;
@@ -99,8 +89,7 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
        dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);
 
        make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
-       de = find_target_dentry(name, max_slots, &d);
-
+       de = find_target_dentry(fname, namehash, max_slots, &d);
        if (de)
                *res_page = dentry_page;
        else
@@ -114,13 +103,15 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
        return de;
 }
 
-struct f2fs_dir_entry *find_target_dentry(struct qstr *name, int *max_slots,
-                                               struct f2fs_dentry_ptr *d)
+struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *fname,
+                       f2fs_hash_t namehash, int *max_slots,
+                       struct f2fs_dentry_ptr *d)
 {
        struct f2fs_dir_entry *de;
        unsigned long bit_pos = 0;
-       f2fs_hash_t namehash = f2fs_dentry_hash(name);
        int max_len = 0;
+       struct f2fs_str de_name = FSTR_INIT(NULL, 0);
+       struct f2fs_str *name = &fname->disk_name;
 
        if (max_slots)
                *max_slots = 0;
@@ -132,8 +123,18 @@ struct f2fs_dir_entry *find_target_dentry(struct qstr *name, int *max_slots,
                }
 
                de = &d->dentry[bit_pos];
-               if (early_match_name(name->len, namehash, de) &&
-                       !memcmp(d->filename[bit_pos], name->name, name->len))
+
+               /* encrypted case */
+               de_name.name = d->filename[bit_pos];
+               de_name.len = le16_to_cpu(de->name_len);
+
+               /* show encrypted name */
+               if (fname->hash) {
+                       if (de->hash_code == fname->hash)
+                               goto found;
+               } else if (de_name.len == name->len &&
+                       de->hash_code == namehash &&
+                       !memcmp(de_name.name, name->name, name->len))
                        goto found;
 
                if (max_slots && max_len > *max_slots)
@@ -155,16 +156,21 @@ found:
 }
 
 static struct f2fs_dir_entry *find_in_level(struct inode *dir,
-                       unsigned int level, struct qstr *name,
-                       f2fs_hash_t namehash, struct page **res_page)
+                                       unsigned int level,
+                                       struct f2fs_filename *fname,
+                                       struct page **res_page)
 {
-       int s = GET_DENTRY_SLOTS(name->len);
+       struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
+       int s = GET_DENTRY_SLOTS(name.len);
        unsigned int nbucket, nblock;
        unsigned int bidx, end_block;
        struct page *dentry_page;
        struct f2fs_dir_entry *de = NULL;
        bool room = false;
        int max_slots;
+       f2fs_hash_t namehash;
+
+       namehash = f2fs_dentry_hash(&name);
 
        f2fs_bug_on(F2FS_I_SB(dir), level > MAX_DIR_HASH_DEPTH);
 
@@ -183,7 +189,8 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,
                        continue;
                }
 
-               de = find_in_block(dentry_page, name, &max_slots, res_page);
+               de = find_in_block(dentry_page, fname, namehash, &max_slots,
+                                                               res_page);
                if (de)
                        break;
 
@@ -211,30 +218,34 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
 {
        unsigned long npages = dir_blocks(dir);
        struct f2fs_dir_entry *de = NULL;
-       f2fs_hash_t name_hash;
        unsigned int max_depth;
        unsigned int level;
+       struct f2fs_filename fname;
+       int err;
 
        *res_page = NULL;
 
-       if (f2fs_has_inline_dentry(dir))
-               return find_in_inline_dir(dir, child, res_page);
+       err = f2fs_fname_setup_filename(dir, child, 1, &fname);
+       if (err)
+               return NULL;
+
+       if (f2fs_has_inline_dentry(dir)) {
+               de = find_in_inline_dir(dir, &fname, res_page);
+               goto out;
+       }
 
        if (npages == 0)
-               return NULL;
+               goto out;
 
-       name_hash = f2fs_dentry_hash(child);
        max_depth = F2FS_I(dir)->i_current_depth;
 
        for (level = 0; level < max_depth; level++) {
-               de = find_in_level(dir, level, child, name_hash, res_page);
+               de = find_in_level(dir, level, &fname, res_page);
                if (de)
                        break;
        }
-       if (!de && F2FS_I(dir)->chash != name_hash) {
-               F2FS_I(dir)->chash = name_hash;
-               F2FS_I(dir)->clevel = level - 1;
-       }
+out:
+       f2fs_fname_free_filename(&fname);
        return de;
 }
 

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index b478a6fa92a7d25cb220365cdeea4c1d79e0d613..6f4d1dbac2f481e9974dc0c95f5842a412094c00 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1584,8 +1584,9 @@ struct dentry *f2fs_get_parent(struct dentry *child);
  */
 extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
 void set_de_type(struct f2fs_dir_entry *, umode_t);
-struct f2fs_dir_entry *find_target_dentry(struct qstr *, int *,
-                       struct f2fs_dentry_ptr *);
+
+struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *,
+                       f2fs_hash_t, int *, struct f2fs_dentry_ptr *);
 bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
                        unsigned int, struct f2fs_str *);
 void do_make_empty_dir(struct inode *, struct inode *,
@@ -1931,8 +1932,8 @@ int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
 int f2fs_convert_inline_inode(struct inode *);
 int f2fs_write_inline_data(struct inode *, struct page *);
 bool recover_inline_data(struct inode *, struct page *);
-struct f2fs_dir_entry *find_in_inline_dir(struct inode *, struct qstr *,
-                                                       struct page **);
+struct f2fs_dir_entry *find_in_inline_dir(struct inode *,
+                               struct f2fs_filename *, struct page **);
 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **);
 int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
 int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *,

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index dd51d3f262b7a365a5b4f3eb296a49eef347c60e..38e75fb1e48812b38d477a13a53f0469fb95bbd3 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -284,23 +284,26 @@ process_inline:
 }
 
 struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
-                               struct qstr *name, struct page **res_page)
+                       struct f2fs_filename *fname, struct page **res_page)
 {
        struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
        struct f2fs_inline_dentry *inline_dentry;
+       struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
        struct f2fs_dir_entry *de;
        struct f2fs_dentry_ptr d;
        struct page *ipage;
+       f2fs_hash_t namehash;
 
        ipage = get_node_page(sbi, dir->i_ino);
        if (IS_ERR(ipage))
                return NULL;
 
+       namehash = f2fs_dentry_hash(&name);
+
        inline_dentry = inline_data_addr(ipage);
 
        make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
-       de = find_target_dentry(name, NULL, &d);
-
+       de = find_target_dentry(fname, namehash, NULL, &d);
        unlock_page(ipage);
        if (de)
                *res_page = ipage;