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

[hujianyang <hujianyang@huawei.com>]

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;
>