f2fs crypto: add filename encryption for f2fs_readdir (d8c6822a) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/f2fs/dir.c

+45 −12

Original line number	Original line	Diff line number	Diff line
	@@ -98,7 +98,7 @@ static struct f2fs_dir_entry find_in_block(struct page dentry_page,

	dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);		dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);

	make_dentry_ptr(&d, (void *)dentry_blk, 1);		make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
	de = find_target_dentry(name, max_slots, &d);		de = find_target_dentry(name, max_slots, &d);

	if (de)		if (de)
	@@ -356,7 +356,7 @@ static int make_empty_dir(struct inode *inode,

	dentry_blk = kmap_atomic(dentry_page);		dentry_blk = kmap_atomic(dentry_page);

	make_dentry_ptr(&d, (void *)dentry_blk, 1);		make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
	do_make_empty_dir(inode, parent, &d);		do_make_empty_dir(inode, parent, &d);

	kunmap_atomic(dentry_blk);		kunmap_atomic(dentry_blk);
	@@ -588,7 +588,7 @@ int __f2fs_add_link(struct inode dir, const struct qstr name,
	}		}
	}		}

	make_dentry_ptr(&d, (void *)dentry_blk, 1);		make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
	f2fs_update_dentry(ino, mode, &d, &new_name, dentry_hash, bit_pos);		f2fs_update_dentry(ino, mode, &d, &new_name, dentry_hash, bit_pos);

	set_page_dirty(dentry_page);		set_page_dirty(dentry_page);
	@@ -750,11 +750,12 @@ bool f2fs_empty_dir(struct inode *dir)
	}		}

	bool f2fs_fill_dentries(struct dir_context ctx, struct f2fs_dentry_ptr d,		bool f2fs_fill_dentries(struct dir_context ctx, struct f2fs_dentry_ptr d,
	unsigned int start_pos)		unsigned int start_pos, struct f2fs_str *fstr)
	{		{
	unsigned char d_type = DT_UNKNOWN;		unsigned char d_type = DT_UNKNOWN;
	unsigned int bit_pos;		unsigned int bit_pos;
	struct f2fs_dir_entry *de = NULL;		struct f2fs_dir_entry *de = NULL;
			struct f2fs_str de_name = FSTR_INIT(NULL, 0);

	bit_pos = ((unsigned long)ctx->pos % d->max);		bit_pos = ((unsigned long)ctx->pos % d->max);

	@@ -768,8 +769,24 @@ bool f2fs_fill_dentries(struct dir_context ctx, struct f2fs_dentry_ptr d,
	d_type = f2fs_filetype_table[de->file_type];		d_type = f2fs_filetype_table[de->file_type];
	else		else
	d_type = DT_UNKNOWN;		d_type = DT_UNKNOWN;
	if (!dir_emit(ctx, d->filename[bit_pos],
	le16_to_cpu(de->name_len),		/* encrypted case */
			de_name.name = d->filename[bit_pos];
			de_name.len = le16_to_cpu(de->name_len);

			if (f2fs_encrypted_inode(d->inode)) {
			int save_len = fstr->len;
			int ret;

			ret = f2fs_fname_disk_to_usr(d->inode, &de->hash_code,
			&de_name, fstr);
			de_name = *fstr;
			fstr->len = save_len;
			if (ret < 0)
			return true;
			}

			if (!dir_emit(ctx, de_name.name, de_name.len,
	le32_to_cpu(de->ino), d_type))		le32_to_cpu(de->ino), d_type))
	return true;		return true;

	@@ -788,9 +805,24 @@ static int f2fs_readdir(struct file file, struct dir_context ctx)
	struct file_ra_state *ra = &file->f_ra;		struct file_ra_state *ra = &file->f_ra;
	unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);		unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
	struct f2fs_dentry_ptr d;		struct f2fs_dentry_ptr d;
			struct f2fs_str fstr = FSTR_INIT(NULL, 0);
			int err = 0;

	if (f2fs_has_inline_dentry(inode))		err = f2fs_setup_fname_crypto(inode);
	return f2fs_read_inline_dir(file, ctx);		if (err)
			return err;

			if (f2fs_encrypted_inode(inode)) {
			err = f2fs_fname_crypto_alloc_buffer(inode, F2FS_NAME_LEN,
			&fstr);
			if (err < 0)
			return err;
			}

			if (f2fs_has_inline_dentry(inode)) {
			err = f2fs_read_inline_dir(file, ctx, &fstr);
			goto out;
			}

	/* readahead for multi pages of dir */		/* readahead for multi pages of dir */
	if (npages - n > 1 && !ra_has_index(ra, n))		if (npages - n > 1 && !ra_has_index(ra, n))
	@@ -804,9 +836,9 @@ static int f2fs_readdir(struct file file, struct dir_context ctx)

	dentry_blk = kmap(dentry_page);		dentry_blk = kmap(dentry_page);

	make_dentry_ptr(&d, (void *)dentry_blk, 1);		make_dentry_ptr(inode, &d, (void *)dentry_blk, 1);

	if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK))		if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK, &fstr))
	goto stop;		goto stop;

	ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;		ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;
	@@ -819,8 +851,9 @@ static int f2fs_readdir(struct file file, struct dir_context ctx)
	kunmap(dentry_page);		kunmap(dentry_page);
	f2fs_put_page(dentry_page, 1);		f2fs_put_page(dentry_page, 1);
	}		}
			out:
	return 0;		f2fs_fname_crypto_free_buffer(&fstr);
			return err;
	}		}

	const struct file_operations f2fs_dir_operations = {		const struct file_operations f2fs_dir_operations = {

fs/f2fs/f2fs.h

+8 −4

Original line number	Original line	Diff line number	Diff line
	@@ -277,15 +277,18 @@ struct f2fs_filename {
	#define fname_len(p) ((p)->disk_name.len)		#define fname_len(p) ((p)->disk_name.len)

	struct f2fs_dentry_ptr {		struct f2fs_dentry_ptr {
			struct inode *inode;
	const void *bitmap;		const void *bitmap;
	struct f2fs_dir_entry *dentry;		struct f2fs_dir_entry *dentry;
	__u8 (*filename)[F2FS_SLOT_LEN];		__u8 (*filename)[F2FS_SLOT_LEN];
	int max;		int max;
	};		};

	static inline void make_dentry_ptr(struct f2fs_dentry_ptr *d,		static inline void make_dentry_ptr(struct inode *inode,
	void *src, int type)		struct f2fs_dentry_ptr d, void src, int type)
	{		{
			d->inode = inode;

	if (type == 1) {		if (type == 1) {
	struct f2fs_dentry_block t = (struct f2fs_dentry_block )src;		struct f2fs_dentry_block t = (struct f2fs_dentry_block )src;
	d->max = NR_DENTRY_IN_BLOCK;		d->max = NR_DENTRY_IN_BLOCK;
	@@ -1584,7 +1587,7 @@ void set_de_type(struct f2fs_dir_entry *, umode_t);
	struct f2fs_dir_entry find_target_dentry(struct qstr , int *,		struct f2fs_dir_entry find_target_dentry(struct qstr , int *,
	struct f2fs_dentry_ptr *);		struct f2fs_dentry_ptr *);
	bool f2fs_fill_dentries(struct dir_context , struct f2fs_dentry_ptr ,		bool f2fs_fill_dentries(struct dir_context , struct f2fs_dentry_ptr ,
	unsigned int);		unsigned int, struct f2fs_str *);
	void do_make_empty_dir(struct inode , struct inode ,		void do_make_empty_dir(struct inode , struct inode ,
	struct f2fs_dentry_ptr *);		struct f2fs_dentry_ptr *);
	struct page init_inode_metadata(struct inode , struct inode *,		struct page init_inode_metadata(struct inode , struct inode *,
	@@ -1937,7 +1940,8 @@ int f2fs_add_inline_entry(struct inode , const struct qstr , struct inode *,
	void f2fs_delete_inline_entry(struct f2fs_dir_entry , struct page ,		void f2fs_delete_inline_entry(struct f2fs_dir_entry , struct page ,
	struct inode , struct inode );		struct inode , struct inode );
	bool f2fs_empty_inline_dir(struct inode *);		bool f2fs_empty_inline_dir(struct inode *);
	int f2fs_read_inline_dir(struct file , struct dir_context );		int f2fs_read_inline_dir(struct file , struct dir_context ,
			struct f2fs_str *);

	/*		/*
	* crypto support		* crypto support

fs/f2fs/inline.c

+7 −6

Original line number	Original line	Diff line number	Diff line
	@@ -298,7 +298,7 @@ struct f2fs_dir_entry find_in_inline_dir(struct inode dir,

	inline_dentry = inline_data_addr(ipage);		inline_dentry = inline_data_addr(ipage);

	make_dentry_ptr(&d, (void *)inline_dentry, 2);		make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
	de = find_target_dentry(name, NULL, &d);		de = find_target_dentry(name, NULL, &d);

	unlock_page(ipage);		unlock_page(ipage);
	@@ -342,7 +342,7 @@ int make_empty_inline_dir(struct inode inode, struct inode parent,

	dentry_blk = inline_data_addr(ipage);		dentry_blk = inline_data_addr(ipage);

	make_dentry_ptr(&d, (void *)dentry_blk, 2);		make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
	do_make_empty_dir(inode, parent, &d);		do_make_empty_dir(inode, parent, &d);

	set_page_dirty(ipage);		set_page_dirty(ipage);
	@@ -446,7 +446,7 @@ int f2fs_add_inline_entry(struct inode dir, const struct qstr name,
	f2fs_wait_on_page_writeback(ipage, NODE);		f2fs_wait_on_page_writeback(ipage, NODE);

	name_hash = f2fs_dentry_hash(name);		name_hash = f2fs_dentry_hash(name);
	make_dentry_ptr(&d, (void *)dentry_blk, 2);		make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
	f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);		f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);

	set_page_dirty(ipage);		set_page_dirty(ipage);
	@@ -523,7 +523,8 @@ bool f2fs_empty_inline_dir(struct inode *dir)
	return true;		return true;
	}		}

	int f2fs_read_inline_dir(struct file file, struct dir_context ctx)		int f2fs_read_inline_dir(struct file file, struct dir_context ctx,
			struct f2fs_str *fstr)
	{		{
	struct inode *inode = file_inode(file);		struct inode *inode = file_inode(file);
	struct f2fs_inline_dentry *inline_dentry = NULL;		struct f2fs_inline_dentry *inline_dentry = NULL;
	@@ -539,9 +540,9 @@ int f2fs_read_inline_dir(struct file file, struct dir_context ctx)

	inline_dentry = inline_data_addr(ipage);		inline_dentry = inline_data_addr(ipage);

	make_dentry_ptr(&d, (void *)inline_dentry, 2);		make_dentry_ptr(inode, &d, (void *)inline_dentry, 2);

	if (!f2fs_fill_dentries(ctx, &d, 0))		if (!f2fs_fill_dentries(ctx, &d, 0, fstr))
	ctx->pos = NR_INLINE_DENTRY;		ctx->pos = NR_INLINE_DENTRY;

	f2fs_put_page(ipage, 1);		f2fs_put_page(ipage, 1);