btrfs: send: add support for fs-verity

Preserve the fs-verity status of a btrfs file across send/recv.

There is no facility for installing the Merkle tree contents directly on
the receiving filesystem, so we package up the parameters used to enable
verity found in the verity descriptor. This gives the receive side
enough information to properly enable verity again. Note that this means
that receive will have to re-compute the whole Merkle tree, similar to
how compression worked before encoded_write.

Since the file becomes read-only after verity is enabled, it is
important that verity is added to the send stream after any file writes.
Therefore, when we process a verity item, merely note that it happened,
then actually create the command in the send stream during
'finish_inode_if_needed'.

This also creates V3 of the send stream format, without any format
changes besides adding the new commands and attributes.

Signed-off-by: Boris Burkov <boris@bur.io>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index f2d556accf346b23561ff50ba842c083a6ece9d2..e9f60d746068453cd2162a08cea2b28b7f4c528a 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -4103,6 +4103,7 @@ static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
 
 extern const struct fsverity_operations btrfs_verityops;
 int btrfs_drop_verity_items(struct btrfs_inode *inode);
+int btrfs_get_verity_descriptor(struct inode *inode, void *buf, size_t buf_size);
 
 BTRFS_SETGET_FUNCS(verity_descriptor_encryption, struct btrfs_verity_descriptor_item,
                   encryption, 8);
@@ -4120,6 +4121,12 @@ static inline int btrfs_drop_verity_items(struct btrfs_inode *inode)
        return 0;
 }
 
+static inline int btrfs_get_verity_descriptor(struct inode *inode, void *buf,
+                                             size_t buf_size)
+{
+       return -EPERM;
+}
+
 #endif
 
 /* Sanity test specific functions */

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index e7671afcee4f0e90d6ce9114edb5d41f2ea8be34..36320e00ff6e91fc5026627cb37e7ee028670244 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/compat.h>
 #include <linux/crc32c.h>
+#include <linux/fsverity.h>
 
 #include "send.h"
 #include "ctree.h"
@@ -127,6 +128,8 @@ struct send_ctx {
        bool cur_inode_new_gen;
        bool cur_inode_deleted;
        bool ignore_cur_inode;
+       bool cur_inode_needs_verity;
+       void *verity_descriptor;
 
        u64 send_progress;
 
@@ -624,6 +627,7 @@ static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len)
                return tlv_put(sctx, attr, &__tmp, sizeof(__tmp));      \
        }
 
+TLV_PUT_DEFINE_INT(8)
 TLV_PUT_DEFINE_INT(32)
 TLV_PUT_DEFINE_INT(64)
 
@@ -4886,6 +4890,84 @@ static int process_all_new_xattrs(struct send_ctx *sctx)
        return ret;
 }
 
+static int send_verity(struct send_ctx *sctx, struct fs_path *path,
+                      struct fsverity_descriptor *desc)
+{
+       int ret;
+
+       ret = begin_cmd(sctx, BTRFS_SEND_C_ENABLE_VERITY);
+       if (ret < 0)
+               goto out;
+
+       TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, path);
+       TLV_PUT_U8(sctx, BTRFS_SEND_A_VERITY_ALGORITHM,
+                       le8_to_cpu(desc->hash_algorithm));
+       TLV_PUT_U32(sctx, BTRFS_SEND_A_VERITY_BLOCK_SIZE,
+                       1U << le8_to_cpu(desc->log_blocksize));
+       TLV_PUT(sctx, BTRFS_SEND_A_VERITY_SALT_DATA, desc->salt,
+                       le8_to_cpu(desc->salt_size));
+       TLV_PUT(sctx, BTRFS_SEND_A_VERITY_SIG_DATA, desc->signature,
+                       le32_to_cpu(desc->sig_size));
+
+       ret = send_cmd(sctx);
+
+tlv_put_failure:
+out:
+       return ret;
+}
+
+static int process_verity(struct send_ctx *sctx)
+{
+       int ret = 0;
+       struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
+       struct inode *inode;
+       struct fs_path *p;
+
+       inode = btrfs_iget(fs_info->sb, sctx->cur_ino, sctx->send_root);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+
+       ret = btrfs_get_verity_descriptor(inode, NULL, 0);
+       if (ret < 0)
+               goto iput;
+
+       if (ret > FS_VERITY_MAX_DESCRIPTOR_SIZE) {
+               ret = -EMSGSIZE;
+               goto iput;
+       }
+       if (!sctx->verity_descriptor) {
+               sctx->verity_descriptor = kvmalloc(FS_VERITY_MAX_DESCRIPTOR_SIZE,
+                                                  GFP_KERNEL);
+               if (!sctx->verity_descriptor) {
+                       ret = -ENOMEM;
+                       goto iput;
+               }
+       }
+
+       ret = btrfs_get_verity_descriptor(inode, sctx->verity_descriptor, ret);
+       if (ret < 0)
+               goto iput;
+
+       p = fs_path_alloc();
+       if (!p) {
+               ret = -ENOMEM;
+               goto iput;
+       }
+       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
+       if (ret < 0)
+               goto free_path;
+
+       ret = send_verity(sctx, p, sctx->verity_descriptor);
+       if (ret < 0)
+               goto free_path;
+
+free_path:
+       fs_path_free(p);
+iput:
+       iput(inode);
+       return ret;
+}
+
 static inline u64 max_send_read_size(const struct send_ctx *sctx)
 {
        return sctx->send_max_size - SZ_16K;
@@ -6377,6 +6459,11 @@ static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
                if (ret < 0)
                        goto out;
        }
+       if (sctx->cur_inode_needs_verity) {
+               ret = process_verity(sctx);
+               if (ret < 0)
+                       goto out;
+       }
 
        ret = send_capabilities(sctx);
        if (ret < 0)
@@ -6785,6 +6872,17 @@ static int changed_extent(struct send_ctx *sctx,
        return ret;
 }
 
+static int changed_verity(struct send_ctx *sctx, enum btrfs_compare_tree_result result)
+{
+       int ret = 0;
+
+       if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
+               if (result == BTRFS_COMPARE_TREE_NEW)
+                       sctx->cur_inode_needs_verity = true;
+       }
+       return ret;
+}
+
 static int dir_changed(struct send_ctx *sctx, u64 dir)
 {
        u64 orig_gen, new_gen;
@@ -6939,6 +7037,9 @@ static int changed_cb(struct btrfs_path *left_path,
                        ret = changed_xattr(sctx, result);
                else if (key->type == BTRFS_EXTENT_DATA_KEY)
                        ret = changed_extent(sctx, result);
+               else if (key->type == BTRFS_VERITY_DESC_ITEM_KEY &&
+                        key->offset == 0)
+                       ret = changed_verity(sctx, result);
        }
 
 out:
@@ -8036,6 +8137,7 @@ out:
                kvfree(sctx->clone_roots);
                kfree(sctx->send_buf_pages);
                kvfree(sctx->send_buf);
+               kvfree(sctx->verity_descriptor);
 
                name_cache_free(sctx);
 

diff --git a/fs/btrfs/send.h b/fs/btrfs/send.h
index 4bb4e6a638cb4a4d50a30591704821a203fdbc62..0a4537775e0c375c1139fea75d8bb22aa7373609 100644 (file)
--- a/fs/btrfs/send.h
+++ b/fs/btrfs/send.h
@@ -92,8 +92,11 @@ enum btrfs_send_cmd {
        BTRFS_SEND_C_ENCODED_WRITE      = 25,
        BTRFS_SEND_C_MAX_V2             = 25,
 
+       /* Version 3 */
+       BTRFS_SEND_C_ENABLE_VERITY      = 26,
+       BTRFS_SEND_C_MAX_V3             = 26,
        /* End */
-       BTRFS_SEND_C_MAX                = 25,
+       BTRFS_SEND_C_MAX                = 26,
 };
 
 /* attributes in send stream */
@@ -160,8 +163,14 @@ enum {
        BTRFS_SEND_A_ENCRYPTION         = 31,
        BTRFS_SEND_A_MAX_V2             = 31,
 
-       /* End */
-       BTRFS_SEND_A_MAX                = 31,
+       /* Version 3 */
+       BTRFS_SEND_A_VERITY_ALGORITHM   = 32,
+       BTRFS_SEND_A_VERITY_BLOCK_SIZE  = 33,
+       BTRFS_SEND_A_VERITY_SALT_DATA   = 34,
+       BTRFS_SEND_A_VERITY_SIG_DATA    = 35,
+       BTRFS_SEND_A_MAX_V3             = 35,
+
+       __BTRFS_SEND_A_MAX              = 35,
 };
 
 long btrfs_ioctl_send(struct inode *inode, struct btrfs_ioctl_send_args *arg);

diff --git a/fs/btrfs/verity.c b/fs/btrfs/verity.c
index 90eb5c2830a9273c9e3c3c717b5243b79224343f..ee00e33c309e0f821fe4bd0602b3c867c4504ccf 100644 (file)
--- a/fs/btrfs/verity.c
+++ b/fs/btrfs/verity.c
@@ -659,8 +659,7 @@ rollback:
  *
  * Returns the size on success or a negative error code on failure.
  */
-static int btrfs_get_verity_descriptor(struct inode *inode, void *buf,
-                                      size_t buf_size)
+int btrfs_get_verity_descriptor(struct inode *inode, void *buf, size_t buf_size)
 {
        u64 true_size;
        int ret = 0;

diff --git a/fs/verity/fsverity_private.h b/fs/verity/fsverity_private.h
index 629785c95007641865a2b32165f382774ac18753..dbe1ce5b450a80873fc751273fef20350510cd79 100644 (file)
--- a/fs/verity/fsverity_private.h
+++ b/fs/verity/fsverity_private.h
@@ -70,8 +70,6 @@ struct fsverity_info {
        const struct inode *inode;
 };
 
-/* Arbitrary limit to bound the kmalloc() size.  Can be changed. */
-#define FS_VERITY_MAX_DESCRIPTOR_SIZE  16384
 
 #define FS_VERITY_MAX_SIGNATURE_SIZE   (FS_VERITY_MAX_DESCRIPTOR_SIZE - \
                                         sizeof(struct fsverity_descriptor))

diff --git a/include/linux/fsverity.h b/include/linux/fsverity.h
index 7af030fa3c366cb18cd1ca794d65d68e95268c9a..40f14e5fed9de902901846a45392a8b9b3b674b2 100644 (file)
--- a/include/linux/fsverity.h
+++ b/include/linux/fsverity.h
@@ -22,6 +22,9 @@
  */
 #define FS_VERITY_MAX_DIGEST_SIZE      SHA512_DIGEST_SIZE
 
+/* Arbitrary limit to bound the kmalloc() size.  Can be changed. */
+#define FS_VERITY_MAX_DESCRIPTOR_SIZE  16384
+
 /* Verity operations for filesystems */
 struct fsverity_operations {