Merge tag 'fsverity-for-linus' of git://git.kernel.org/pub/scm/fs/fscrypt/fscrypt

Pull fs-verity support from Eric Biggers:
 "fs-verity is a filesystem feature that provides Merkle tree based
  hashing (similar to dm-verity) for individual readonly files, mainly
  for the purpose of efficient authenticity verification.

  This pull request includes:

   (a) The fs/verity/ support layer and documentation.

   (b) fs-verity support for ext4 and f2fs.

  Compared to the original fs-verity patchset from last year, the UAPI
  to enable fs-verity on a file has been greatly simplified. Lots of
  other things were cleaned up too.

  fs-verity is planned to be used by two different projects on Android;
  most of the userspace code is in place already. Another userspace tool
  ("fsverity-utils"), and xfstests, are also available. e2fsprogs and
  f2fs-tools already have fs-verity support. Other people have shown
  interest in using fs-verity too.

  I've tested this on ext4 and f2fs with xfstests, both the existing
  tests and the new fs-verity tests. This has also been in linux-next
  since July 30 with no reported issues except a couple minor ones I
  found myself and folded in fixes for.

  Ted and I will be co-maintaining fs-verity"

* tag 'fsverity-for-linus' of git://git.kernel.org/pub/scm/fs/fscrypt/fscrypt:
  f2fs: add fs-verity support
  ext4: update on-disk format documentation for fs-verity
  ext4: add fs-verity read support
  ext4: add basic fs-verity support
  fs-verity: support builtin file signatures
  fs-verity: add SHA-512 support
  fs-verity: implement FS_IOC_MEASURE_VERITY ioctl
  fs-verity: implement FS_IOC_ENABLE_VERITY ioctl
  fs-verity: add data verification hooks for ->readpages()
  fs-verity: add the hook for file ->setattr()
  fs-verity: add the hook for file ->open()
  fs-verity: add inode and superblock fields
  fs-verity: add Kconfig and the helper functions for hashing
  fs: uapi: define verity bit for FS_IOC_GETFLAGS
  fs-verity: add UAPI header
  fs-verity: add MAINTAINERS file entry
  fs-verity: add a documentation file

1 files changed, 42 insertions, 1 deletions

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 6a7349f9ac15..39fffc19e00c 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -496,6 +496,10 @@ static int f2fs_file_open(struct inode *inode, struct file *filp)
         if (err)
                 return err;
 
+        err = fsverity_file_open(inode, filp);
+        if (err)
+                return err;
+
         filp->f_mode |= FMODE_NOWAIT;
 
         return dquot_file_open(inode, filp);
@@ -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)
@@ -1705,7 +1713,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 |            \
@@ -1750,6 +1759,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))
@@ -3103,6 +3114,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)))))
@@ -3171,6 +3206,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;
         }
@@ -3290,6 +3329,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;