Commit 95ae251f authored by Eric Biggers's avatar Eric Biggers
Browse files

f2fs: add fs-verity support 



Add fs-verity support to f2fs.  fs-verity is a filesystem feature that
enables transparent integrity protection and authentication of read-only
files.  It uses a dm-verity like mechanism at the file level: a Merkle
tree is used to verify any block in the file in log(filesize) time.  It
is implemented mainly by helper functions in fs/verity/.  See
Documentation/filesystems/fsverity.rst for the full documentation.

The f2fs support for fs-verity consists of:

- Adding a filesystem feature flag and an inode flag for fs-verity.

- Implementing the fsverity_operations to support enabling verity on an
  inode and reading/writing the verity metadata.

- Updating ->readpages() to verify data as it's read from verity files
  and to support reading verity metadata pages.

- Updating ->write_begin(), ->write_end(), and ->writepages() to support
  writing verity metadata pages.

- Calling the fs-verity hooks for ->open(), ->setattr(), and ->ioctl().

Like ext4, f2fs stores the verity metadata (Merkle tree and
fsverity_descriptor) past the end of the file, starting at the first 64K
boundary beyond i_size.  This approach works because (a) verity files
are readonly, and (b) pages fully beyond i_size aren't visible to
userspace but can be read/written internally by f2fs with only some
relatively small changes to f2fs.  Extended attributes cannot be used
because (a) f2fs limits the total size of an inode's xattr entries to
4096 bytes, which wouldn't be enough for even a single Merkle tree
block, and (b) f2fs encryption doesn't encrypt xattrs, yet the verity
metadata *must* be encrypted when the file is because it contains hashes
of the plaintext data.

Acked-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
Acked-by: default avatarChao Yu <yuchao0@huawei.com>
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
parent 84fb7ca4

fs/f2fs/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -8,3 +8,4 @@ f2fs-$(CONFIG_F2FS_STAT_FS) += debug.o 
f2fs-$(CONFIG_F2FS_FS_XATTR) += xattr.o

f2fs-$(CONFIG_F2FS_FS_POSIX_ACL) += acl.o

f2fs-$(CONFIG_F2FS_IO_TRACE) += trace.o

f2fs-$(CONFIG_FS_VERITY) += verity.o

fs/f2fs/data.c

+65 −10
Original line number Diff line number Diff line
@@ -74,6 +74,7 @@ static enum count_type __read_io_type(struct page *page) 
enum bio_post_read_step {

	STEP_INITIAL = 0,

	STEP_DECRYPT,

	STEP_VERITY,

};



struct bio_post_read_ctx {
@@ -120,8 +121,23 @@ static void decrypt_work(struct work_struct *work) 
	bio_post_read_processing(ctx);

}



static void verity_work(struct work_struct *work)

{

	struct bio_post_read_ctx *ctx =

		container_of(work, struct bio_post_read_ctx, work);



	fsverity_verify_bio(ctx->bio);



	bio_post_read_processing(ctx);

}



static void bio_post_read_processing(struct bio_post_read_ctx *ctx)

{

	/*

	 * We use different work queues for decryption and for verity because

	 * verity may require reading metadata pages that need decryption, and

	 * we shouldn't recurse to the same workqueue.

	 */

	switch (++ctx->cur_step) {

	case STEP_DECRYPT:

		if (ctx->enabled_steps & (1 << STEP_DECRYPT)) {
@@ -131,6 +147,14 @@ static void bio_post_read_processing(struct bio_post_read_ctx *ctx) 
		}

		ctx->cur_step++;

		/* fall-through */

	case STEP_VERITY:

		if (ctx->enabled_steps & (1 << STEP_VERITY)) {

			INIT_WORK(&ctx->work, verity_work);

			fsverity_enqueue_verify_work(&ctx->work);

			return;

		}

		ctx->cur_step++;

		/* fall-through */

	default:

		__read_end_io(ctx->bio);

	}
@@ -608,8 +632,15 @@ out: 
	up_write(&io->io_rwsem);

}



static inline bool f2fs_need_verity(const struct inode *inode, pgoff_t idx)

{

	return fsverity_active(inode) &&

	       idx < DIV_ROUND_UP(inode->i_size, PAGE_SIZE);

}



static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,

					unsigned nr_pages, unsigned op_flag)

				      unsigned nr_pages, unsigned op_flag,

				      pgoff_t first_idx)

{

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct bio *bio;
@@ -625,6 +656,10 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr, 


	if (f2fs_encrypted_file(inode))

		post_read_steps |= 1 << STEP_DECRYPT;



	if (f2fs_need_verity(inode, first_idx))

		post_read_steps |= 1 << STEP_VERITY;



	if (post_read_steps) {

		ctx = mempool_alloc(bio_post_read_ctx_pool, GFP_NOFS);

		if (!ctx) {
@@ -646,7 +681,7 @@ static int f2fs_submit_page_read(struct inode *inode, struct page *page, 
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct bio *bio;



	bio = f2fs_grab_read_bio(inode, blkaddr, 1, 0);

	bio = f2fs_grab_read_bio(inode, blkaddr, 1, 0, page->index);

	if (IS_ERR(bio))

		return PTR_ERR(bio);
@@ -1569,6 +1604,15 @@ out: 
	return ret;

}



static inline loff_t f2fs_readpage_limit(struct inode *inode)

{

	if (IS_ENABLED(CONFIG_FS_VERITY) &&

	    (IS_VERITY(inode) || f2fs_verity_in_progress(inode)))

		return inode->i_sb->s_maxbytes;



	return i_size_read(inode);

}



static int f2fs_read_single_page(struct inode *inode, struct page *page,

					unsigned nr_pages,

					struct f2fs_map_blocks *map,
@@ -1587,7 +1631,7 @@ static int f2fs_read_single_page(struct inode *inode, struct page *page, 


	block_in_file = (sector_t)page_index(page);

	last_block = block_in_file + nr_pages;

	last_block_in_file = (i_size_read(inode) + blocksize - 1) >>

	last_block_in_file = (f2fs_readpage_limit(inode) + blocksize - 1) >>

							blkbits;

	if (last_block > last_block_in_file)

		last_block = last_block_in_file;
@@ -1632,6 +1676,11 @@ got_it: 
	} else {

zero_out:

		zero_user_segment(page, 0, PAGE_SIZE);

		if (f2fs_need_verity(inode, page->index) &&

		    !fsverity_verify_page(page)) {

			ret = -EIO;

			goto out;

		}

		if (!PageUptodate(page))

			SetPageUptodate(page);

		unlock_page(page);
@@ -1650,7 +1699,7 @@ submit_and_realloc: 
	}

	if (bio == NULL) {

		bio = f2fs_grab_read_bio(inode, block_nr, nr_pages,

				is_readahead ? REQ_RAHEAD : 0);

				is_readahead ? REQ_RAHEAD : 0, page->index);

		if (IS_ERR(bio)) {

			ret = PTR_ERR(bio);

			bio = NULL;
@@ -2052,7 +2101,7 @@ static int __write_data_page(struct page *page, bool *submitted, 
	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))

		goto redirty_out;



	if (page->index < end_index)

	if (page->index < end_index || f2fs_verity_in_progress(inode))

		goto write;



	/*
@@ -2427,7 +2476,8 @@ static void f2fs_write_failed(struct address_space *mapping, loff_t to) 
	struct inode *inode = mapping->host;

	loff_t i_size = i_size_read(inode);



	if (to > i_size) {

	/* In the fs-verity case, f2fs_end_enable_verity() does the truncate */

	if (to > i_size && !f2fs_verity_in_progress(inode)) {

		down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);

		down_write(&F2FS_I(inode)->i_mmap_sem);
@@ -2458,7 +2508,8 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi, 
	 * the block addresses when there is no need to fill the page.

	 */

	if (!f2fs_has_inline_data(inode) && len == PAGE_SIZE &&

			!is_inode_flag_set(inode, FI_NO_PREALLOC))

	    !is_inode_flag_set(inode, FI_NO_PREALLOC) &&

	    !f2fs_verity_in_progress(inode))

		return 0;



	/* f2fs_lock_op avoids race between write CP and convert_inline_page */
@@ -2597,7 +2648,8 @@ repeat: 
	if (len == PAGE_SIZE || PageUptodate(page))

		return 0;



	if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode)) {

	if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode) &&

	    !f2fs_verity_in_progress(inode)) {

		zero_user_segment(page, len, PAGE_SIZE);

		return 0;

	}
@@ -2660,7 +2712,8 @@ static int f2fs_write_end(struct file *file, 


	set_page_dirty(page);



	if (pos + copied > i_size_read(inode))

	if (pos + copied > i_size_read(inode) &&

	    !f2fs_verity_in_progress(inode))

		f2fs_i_size_write(inode, pos + copied);

unlock_out:

	f2fs_put_page(page, 1);
@@ -3104,7 +3157,9 @@ void f2fs_clear_page_cache_dirty_tag(struct page *page) 


int __init f2fs_init_post_read_processing(void)

{

	bio_post_read_ctx_cache = KMEM_CACHE(bio_post_read_ctx, 0);

	bio_post_read_ctx_cache =

		kmem_cache_create("f2fs_bio_post_read_ctx",

				  sizeof(struct bio_post_read_ctx), 0, 0, NULL);

	if (!bio_post_read_ctx_cache)

		goto fail;

	bio_post_read_ctx_pool =

fs/f2fs/f2fs.h

+17 −3
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include <crypto/hash.h>



#include <linux/fscrypt.h>

#include <linux/fsverity.h>



#ifdef CONFIG_F2FS_CHECK_FS

#define f2fs_bug_on(sbi, condition)	BUG_ON(condition)
@@ -151,7 +152,7 @@ struct f2fs_mount_info { 
#define F2FS_FEATURE_QUOTA_INO		0x0080

#define F2FS_FEATURE_INODE_CRTIME	0x0100

#define F2FS_FEATURE_LOST_FOUND		0x0200

#define F2FS_FEATURE_VERITY		0x0400	/* reserved */

#define F2FS_FEATURE_VERITY		0x0400

#define F2FS_FEATURE_SB_CHKSUM		0x0800



#define __F2FS_HAS_FEATURE(raw_super, mask)				\
@@ -630,7 +631,7 @@ enum { 
#define FADVISE_ENC_NAME_BIT	0x08

#define FADVISE_KEEP_SIZE_BIT	0x10

#define FADVISE_HOT_BIT		0x20

#define FADVISE_VERITY_BIT	0x40	/* reserved */

#define FADVISE_VERITY_BIT	0x40



#define FADVISE_MODIFIABLE_BITS	(FADVISE_COLD_BIT | FADVISE_HOT_BIT)
@@ -650,6 +651,8 @@ enum { 
#define file_is_hot(inode)	is_file(inode, FADVISE_HOT_BIT)

#define file_set_hot(inode)	set_file(inode, FADVISE_HOT_BIT)

#define file_clear_hot(inode)	clear_file(inode, FADVISE_HOT_BIT)

#define file_is_verity(inode)	is_file(inode, FADVISE_VERITY_BIT)

#define file_set_verity(inode)	set_file(inode, FADVISE_VERITY_BIT)



#define DEF_DIR_LEVEL		0
@@ -2412,6 +2415,7 @@ enum { 
	FI_PROJ_INHERIT,	/* indicate file inherits projectid */

	FI_PIN_FILE,		/* indicate file should not be gced */

	FI_ATOMIC_REVOKE_REQUEST, /* request to drop atomic data */

	FI_VERITY_IN_PROGRESS,	/* building fs-verity Merkle tree */

};



static inline void __mark_inode_dirty_flag(struct inode *inode,
@@ -2451,6 +2455,12 @@ static inline void clear_inode_flag(struct inode *inode, int flag) 
	__mark_inode_dirty_flag(inode, flag, false);

}



static inline bool f2fs_verity_in_progress(struct inode *inode)

{

	return IS_ENABLED(CONFIG_FS_VERITY) &&

	       is_inode_flag_set(inode, FI_VERITY_IN_PROGRESS);

}



static inline void set_acl_inode(struct inode *inode, umode_t mode)

{

	F2FS_I(inode)->i_acl_mode = mode;
@@ -3521,6 +3531,9 @@ void f2fs_exit_sysfs(void); 
int f2fs_register_sysfs(struct f2fs_sb_info *sbi);

void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi);



/* verity.c */

extern const struct fsverity_operations f2fs_verityops;



/*

 * crypto support

 */
@@ -3543,7 +3556,7 @@ static inline void f2fs_set_encrypted_inode(struct inode *inode) 
 */

static inline bool f2fs_post_read_required(struct inode *inode)

{

	return f2fs_encrypted_file(inode);

	return f2fs_encrypted_file(inode) || fsverity_active(inode);

}



#define F2FS_FEATURE_FUNCS(name, flagname) \
@@ -3561,6 +3574,7 @@ F2FS_FEATURE_FUNCS(flexible_inline_xattr, FLEXIBLE_INLINE_XATTR); 
F2FS_FEATURE_FUNCS(quota_ino, QUOTA_INO);

F2FS_FEATURE_FUNCS(inode_crtime, INODE_CRTIME);

F2FS_FEATURE_FUNCS(lost_found, LOST_FOUND);

F2FS_FEATURE_FUNCS(verity, VERITY);

F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);



#ifdef CONFIG_BLK_DEV_ZONED

fs/f2fs/file.c

+42 −1
Original line number Diff line number Diff line
@@ -493,6 +493,10 @@ static int f2fs_file_open(struct inode *inode, struct file *filp) 
{

	int err = fscrypt_file_open(inode, filp);



	if (err)

		return err;



	err = fsverity_file_open(inode, filp);

	if (err)

		return err;
@@ -778,6 +782,10 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 
	if (err)

		return err;



	err = fsverity_prepare_setattr(dentry, attr);

	if (err)

		return err;



	if (is_quota_modification(inode, attr)) {

		err = dquot_initialize(inode);

		if (err)
@@ -1712,7 +1720,8 @@ static const struct { 
		FS_PROJINHERIT_FL |	\

		FS_ENCRYPT_FL |		\

		FS_INLINE_DATA_FL |	\

		FS_NOCOW_FL)

		FS_NOCOW_FL |		\

		FS_VERITY_FL)



#define F2FS_SETTABLE_FS_FL (		\

		FS_SYNC_FL |		\
@@ -1757,6 +1766,8 @@ static int f2fs_ioc_getflags(struct file *filp, unsigned long arg) 


	if (IS_ENCRYPTED(inode))

		fsflags |= FS_ENCRYPT_FL;

	if (IS_VERITY(inode))

		fsflags |= FS_VERITY_FL;

	if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode))

		fsflags |= FS_INLINE_DATA_FL;

	if (is_inode_flag_set(inode, FI_PIN_FILE))
@@ -3077,6 +3088,30 @@ static int f2fs_ioc_resize_fs(struct file *filp, unsigned long arg) 
	return ret;

}



static int f2fs_ioc_enable_verity(struct file *filp, unsigned long arg)

{

	struct inode *inode = file_inode(filp);



	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);



	if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) {

		f2fs_warn(F2FS_I_SB(inode),

			  "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem.\n",

			  inode->i_ino);

		return -EOPNOTSUPP;

	}



	return fsverity_ioctl_enable(filp, (const void __user *)arg);

}



static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg)

{

	if (!f2fs_sb_has_verity(F2FS_I_SB(file_inode(filp))))

		return -EOPNOTSUPP;



	return fsverity_ioctl_measure(filp, (void __user *)arg);

}



long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
@@ -3135,6 +3170,10 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 
		return f2fs_ioc_precache_extents(filp, arg);

	case F2FS_IOC_RESIZE_FS:

		return f2fs_ioc_resize_fs(filp, arg);

	case FS_IOC_ENABLE_VERITY:

		return f2fs_ioc_enable_verity(filp, arg);

	case FS_IOC_MEASURE_VERITY:

		return f2fs_ioc_measure_verity(filp, arg);

	default:

		return -ENOTTY;

	}
@@ -3249,6 +3288,8 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
	case F2FS_IOC_SET_PIN_FILE:

	case F2FS_IOC_PRECACHE_EXTENTS:

	case F2FS_IOC_RESIZE_FS:

	case FS_IOC_ENABLE_VERITY:

	case FS_IOC_MEASURE_VERITY:

		break;

	default:

		return -ENOIOCTLCMD;

fs/f2fs/inode.c

+4 −1
Original line number Diff line number Diff line
@@ -46,9 +46,11 @@ void f2fs_set_inode_flags(struct inode *inode) 
		new_fl |= S_DIRSYNC;

	if (file_is_encrypt(inode))

		new_fl |= S_ENCRYPTED;

	if (file_is_verity(inode))

		new_fl |= S_VERITY;

	inode_set_flags(inode, new_fl,

			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|

			S_ENCRYPTED);

			S_ENCRYPTED|S_VERITY);

}



static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
@@ -733,6 +735,7 @@ no_delete: 
	}

out_clear:

	fscrypt_put_encryption_info(inode);

	fsverity_cleanup_inode(inode);

	clear_inode(inode);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE