Re: [f2fs-dev] [PATCH 14/18] f2fs crypto: add filename encryption for f2fs_lookup

hujianyang
2015-05-11T02:53:24Z

Hi Jaegeuk,

While compiling git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
branch dev(commit 5af6e74892a f2fs crypto: remove checking key context during lookup),
I saw an error:

fs/f2fs/dir.c: In function ‘find_in_level’:
fs/f2fs/dir.c:163: error: unknown field ‘len’ specified in initializer
fs/f2fs/dir.c:163: warning: excess elements in struct initializer
fs/f2fs/dir.c:163: warning: (near initialization for ‘name’)

I think it's related to this patch.
If there is anything wrong in my configuration, please let me know.

Thanks,
Hu

On 2015/5/9 12:20, Jaegeuk Kim wrote:
> 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>
> ---
> fs/f2fs/dir.c | 79 ++++++++++++++++++++++++++++++++------------------------
> fs/f2fs/f2fs.h | 9 ++++---
> fs/f2fs/inline.c | 9 ++++---
> 3 files changed, 56 insertions(+), 41 deletions(-)
>
> diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
> index ab6455d..5e10d9d 100644
> --- 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 963616f..6898331 100644
> --- 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 dd51d3f..38e75fb 100644
> --- 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;
>