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

[Jaegeuk Kim]

Hi Hujianynag,

I just fixed it up, and rebased the dev branch.
Could you check them out?

Thanks,

On Mon, May 11, 2015 at 10:52:48AM +0800, hujianyang wrote:
> 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@xxxxxxxxxx>
> > ---
> >  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;
> > 
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/