Every filesystem that supports fs-verity keeps a private runtime inode flag meaning Merkle tree is currently being built *_VERITY_IN_PROGRESS. They all serve the same two purposes: reject a concurrent enable with -EBUSY and let the write paths recognize the special writes done while the tree is under construction. Hoist this flag into the VFS as a new inode state flag, I_VERITY_BUILDING, and manage its lifetime in the generic fs-verity enable path. The flag is set after ->begin_enable_verity() succeeds and cleared after ->end_enable_verity() returns (both on the success and the rollback paths). Add the concurrent-enable guard. A new helper, fsverity_is_building(), is provided for filesystems to query the flag. No filesystem uses it yet; the per-fs flags are converted in following patches. Signed-off-by: Andrey Albershteyn --- fs/verity/enable.c | 22 +++++++++++++++++++--- include/linux/fs.h | 6 ++++++ include/linux/fsverity.h | 21 +++++++++++++++++++++ 3 files changed, 46 insertions(+), 3 deletions(-) diff --git a/fs/verity/enable.c b/fs/verity/enable.c index fe8493280b77..65d3571c62b5 100644 --- a/fs/verity/enable.c +++ b/fs/verity/enable.c @@ -229,13 +229,23 @@ static int enable_verity(struct file *filp, /* * Start enabling verity on this file, serialized by the inode lock. - * Fail if verity is already enabled or is already being enabled. + * Fail if verity is already enabled or is already being enabled. Set + * I_VERITY_BUILDING inode runtime flag which will be cleared when + * enablement succeeded or rolled back. */ inode_lock(inode); - if (IS_VERITY(inode)) + if (IS_VERITY(inode)) { err = -EEXIST; - else + } else if (inode_state_read_once(inode) & I_VERITY_BUILDING) { + err = -EBUSY; + } else { err = vops->begin_enable_verity(filp); + if (!err) { + spin_lock(&inode->i_lock); + inode_state_set(inode, I_VERITY_BUILDING); + spin_unlock(&inode->i_lock); + } + } inode_unlock(inode); if (err) goto out; @@ -291,6 +301,9 @@ static int enable_verity(struct file *filp, */ inode_lock(inode); err = vops->end_enable_verity(filp, desc, desc_size, params.tree_size); + spin_lock(&inode->i_lock); + inode_state_clear(inode, I_VERITY_BUILDING); + spin_unlock(&inode->i_lock); inode_unlock(inode); if (err) { fsverity_err(inode, "%ps() failed with err %d", @@ -317,6 +330,9 @@ static int enable_verity(struct file *filp, rollback: inode_lock(inode); (void)vops->end_enable_verity(filp, NULL, 0, params.tree_size); + spin_lock(&inode->i_lock); + inode_state_clear(inode, I_VERITY_BUILDING); + spin_unlock(&inode->i_lock); inode_unlock(inode); goto out; } diff --git a/include/linux/fs.h b/include/linux/fs.h index 99caef43ff3c..7c90ce09f797 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -707,6 +707,11 @@ is_uncached_acl(struct posix_acl *acl) * I_LRU_ISOLATING Inode is pinned being isolated from LRU without holding * i_count. * + * I_VERITY_BUILDING fs-verity is being enabled on the inode: the Merkle + * tree is under construction. The file is effectively + * read-only to userspace; the only writes happening are + * for the fs-verity metadata. + * * Q: What is the difference between I_WILL_FREE and I_FREEING? * * __I_{SYNC,NEW,LRU_ISOLATING} are used to derive unique addresses to wait @@ -741,6 +746,7 @@ enum inode_state_flags_enum { I_SYNC_QUEUED = (1U << 17), I_PINNING_NETFS_WB = (1U << 18), I_METADATA_WRITEBACK = (1U << 19), + I_VERITY_BUILDING = (1U << 20), }; #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC) diff --git a/include/linux/fsverity.h b/include/linux/fsverity.h index 61fe96ccdff6..c72edec57e30 100644 --- a/include/linux/fsverity.h +++ b/include/linux/fsverity.h @@ -164,6 +164,22 @@ static inline bool fsverity_active(const struct inode *inode) return false; } +/** + * fsverity_is_building() - is fs-verity being enabled on the inode + * @inode: inode to check + * + * This checks whether the inode's Merkle tree is currently being built. + * While this is the case the file is read-only to userspace and the only writes + * allowed are for the fs-verity metadata. This becomes false when fsverity + * metadata is fully created and written to disk or building failed. + * + * Return: true if fs-verity is being enabled on the inode + */ +static inline bool fsverity_is_building(const struct inode *inode) +{ + return inode_state_read_once((struct inode *)inode) & I_VERITY_BUILDING; +} + struct fsverity_info *__fsverity_get_info(const struct inode *inode); /** * fsverity_get_info - get fsverity information for an inode @@ -217,6 +233,11 @@ static inline bool fsverity_active(const struct inode *inode) return false; } +static inline bool fsverity_is_building(const struct inode *inode) +{ + return false; +} + static inline struct fsverity_info *fsverity_get_info(const struct inode *inode) { return NULL; -- 2.54.0