btrfs: add send stream v2 definitions
Subsystems (3)
PATCH v7 11/15 btrfs: add send stream v2 definitions
In reply to a message not in the archiveFrom: Omar Sandoval <[email protected]>
This adds the definitions of the new commands for send stream version 2 and their respective attributes: fallocate, FS_IOC_SETFLAGS (a.k.a. chattr), and encoded writes. It also documents two changes to the send stream format in v2: the receiver shouldn't assume a maximum command size, and the DATA attribute is encoded differently to allow for writes larger than 64k. These will be implemented in subsequent changes, and then the ioctl will accept the new flags.
--- fs/btrfs/send.c | 2 +- fs/btrfs/send.h | 30 +++++++++++++++++++++++++++++- include/uapi/linux/btrfs.h | 13 +++++++++++++ 3 files changed, 43 insertions(+), 2 deletions(-)
fs/btrfs/send.c +1 -1
@@ -7267,7 +7267,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) sctx->clone_roots_cnt = arg->clone_sources_count; - sctx->send_max_size =BTRFS_SEND_BUF_SIZE ; + sctx->send_max_size =BTRFS_SEND_BUF_SIZE_V1 ; sctx->send_buf =kvmalloc (sctx->send_max_size,GFP_KERNEL );if (!sctx->send_buf) { ret = -ENOMEM ;
fs/btrfs/send.h +29 -1
@@ -12,7 +12,11 @@#define BTRFS_SEND_STREAM_MAGIC "btrfs-stream"#define BTRFS_SEND_STREAM_VERSION 1 -#define BTRFS_SEND_BUF_SIZE SZ_64K +/* +* In send stream v1, no command is larger than 64k. In send stream v2, no limit +* should be assumed. +*/ +#define BTRFS_SEND_BUF_SIZE_V1 SZ_64Kenum btrfs_tlv_type {BTRFS_TLV_U8 ,
@@ -76,6 +80,13 @@ enum btrfs_send_cmd {BTRFS_SEND_C_END ,BTRFS_SEND_C_UPDATE_EXTENT , + +/* The following commands were added in send stream v2. */ + +BTRFS_SEND_C_FALLOCATE , +BTRFS_SEND_C_SETFLAGS , +BTRFS_SEND_C_ENCODED_WRITE , + __BTRFS_SEND_C_MAX, };#define BTRFS_SEND_C_MAX (__BTRFS_SEND_C_MAX - 1)
@@ -106,6 +117,11 @@ enum {BTRFS_SEND_A_PATH_LINK ,BTRFS_SEND_A_FILE_OFFSET , +/* +* In send stream v2, this attribute is special: it must be the last +* attribute in a command, its header contains only the type, and its +* length is implicitly the remaining length of the command. +*/ BTRFS_SEND_A_DATA , BTRFS_SEND_A_CLONE_UUID,
@@ -114,6 +130,18 @@ enum {BTRFS_SEND_A_CLONE_OFFSET ,BTRFS_SEND_A_CLONE_LEN , +/* The following attributes were added in send stream v2. */ + +BTRFS_SEND_A_FALLOCATE_MODE , + +BTRFS_SEND_A_SETFLAGS_FLAGS , + +BTRFS_SEND_A_UNENCODED_FILE_LEN , +BTRFS_SEND_A_UNENCODED_LEN , +BTRFS_SEND_A_UNENCODED_OFFSET , +BTRFS_SEND_A_COMPRESSION , +BTRFS_SEND_A_ENCRYPTION , + __BTRFS_SEND_A_MAX, };#define BTRFS_SEND_A_MAX (__BTRFS_SEND_A_MAX - 1)
include/uapi/linux/btrfs.h +13 -0
@@ -770,6 +770,19 @@ struct btrfs_ioctl_received_subvol_args {*/ #define BTRFS_SEND_FLAG_OMIT_END_CMD 0x4 +/* +* Use version 2 of the send stream, which adds new commands and supports larger +* writes. +*/ +#define BTRFS_SEND_FLAG_STREAM_V2 0x8 + +/* +* Send compressed data using the ENCODED_WRITE command instead of decompressing +* the data and sending it with the WRITE command. This requires +* BTRFS_SEND_FLAG_STREAM_V2. +*/ +#define BTRFS_SEND_FLAG_COMPRESSED 0x10 +#define BTRFS_SEND_FLAG_MASK \ (BTRFS_SEND_FLAG_NO_FILE_DATA | \ BTRFS_SEND_FLAG_OMIT_STREAM_HEADER | \
Signature · 1 line
2.30.0
PATCH v7 12/15 btrfs: send: write larger chunks when using stream v2
In reply to a message not in the archiveFrom: Omar Sandoval <[email protected]>
The length field of the send stream TLV header is 16 bits. This means that the maximum amount of data that can be sent for one write is 64k minus one. However, encoded writes must be able to send the maximum compressed extent (128k) in one command. To support this, send stream version 2 encodes the DATA attribute differently: it has no length field, and the length is implicitly up to the end of containing command (which has a 32-bit length field). Although this is necessary for encoded writes, normal writes can benefit from it, too.
For v2, let's bump up the send buffer to the maximum compressed extent size plus 16k for the other metadata (144k total). Since this will most likely be vmalloc'd (and always will be after the next commit), we round it up to the next page since we might as well use the rest of the page on systems with >16k pages.
--- fs/btrfs/send.c | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-)
fs/btrfs/send.c +26 -8
@@ -4915,14 +4915,27 @@ static inline u64 max_send_read_size(const struct send_ctx *sctx)static int put_data_header (struct send_ctx *sctx,u32 len) { -struct btrfs_tlv_header *hdr; +if (sctx->flags &BTRFS_SEND_FLAG_STREAM_V2 ) { +/* +* In v2, the data attribute header doesn't include a length; it +* is implicitly to the end of the command. +*/ +if (sctx->send_max_size - sctx->send_size <2 + len) +return -EOVERFLOW ; +put_unaligned_le16 (BTRFS_SEND_A_DATA , + sctx->send_buf + sctx->send_size); + sctx->send_size +=2 ; + }else { +struct btrfs_tlv_header *hdr; -if (sctx->send_max_size - sctx->send_size <sizeof (*hdr) + len) -return -EOVERFLOW ; - hdr = (struct btrfs_tlv_header *)(sctx->send_buf + sctx->send_size); -put_unaligned_le16 (BTRFS_SEND_A_DATA , &hdr->tlv_type); -put_unaligned_le16 (len, &hdr->tlv_len); - sctx->send_size +=sizeof (*hdr); +if (sctx->send_max_size - sctx->send_size <sizeof (*hdr) + len) +return -EOVERFLOW ; + hdr = (struct btrfs_tlv_header *)(sctx->send_buf + + sctx->send_size); +put_unaligned_le16 (BTRFS_SEND_A_DATA , &hdr->tlv_type); +put_unaligned_le16 (len, &hdr->tlv_len); + sctx->send_size +=sizeof (*hdr); + }return 0 ; }
@@ -7267,7 +7280,12 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) sctx->clone_roots_cnt = arg->clone_sources_count; - sctx->send_max_size =BTRFS_SEND_BUF_SIZE_V1 ; +if (sctx->flags &BTRFS_SEND_FLAG_STREAM_V2 ) { + sctx->send_max_size =ALIGN (SZ_16K +BTRFS_MAX_COMPRESSED , +PAGE_SIZE ); + }else { + sctx->send_max_size =BTRFS_SEND_BUF_SIZE_V1 ; + } sctx->send_buf =kvmalloc (sctx->send_max_size,GFP_KERNEL );if (!sctx->send_buf) { ret = -ENOMEM ;
Signature · 1 line
2.30.0
PATCH v7 14/15 btrfs: send: send compressed extents with encoded writes
In reply to a message not in the archiveFrom: Omar Sandoval <[email protected]>
Now that all of the pieces are in place, we can use the ENCODED_WRITE command to send compressed extents when appropriate.
--- fs/btrfs/ctree.h | 4 + fs/btrfs/inode.c | 6 +- fs/btrfs/send.c | 230 +++++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 220 insertions(+), 20 deletions(-)
fs/btrfs/ctree.h +4 -0
@@ -3157,6 +3157,10 @@ int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct page *locked_pageint btrfs_writepage_cow_fixup (struct page *page,u64 start,u64 end);void btrfs_writepage_endio_finish_ordered (struct page *page,u64 start,u64 end,int uptodate); +int encoded_iov_compression_from_btrfs (unsigned int compress_type); +int btrfs_encoded_read_regular_fill_pages (struct inode *inode,u64 offset, +u64 disk_io_size, +struct page **pages);ssize_t btrfs_encoded_read (struct kiocb *iocb,struct iov_iter *iter);ssize_t btrfs_do_encoded_write (struct kiocb *iocb,struct iov_iter *from,struct encoded_iov *encoded);
fs/btrfs/inode.c +3 -3
@@ -9984,7 +9984,7 @@ void btrfs_set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end) } } -static int encoded_iov_compression_from_btrfs (unsigned int compress_type) +int encoded_iov_compression_from_btrfs (unsigned int compress_type) {switch (compress_type) {case BTRFS_COMPRESS_NONE :
@@ -10190,8 +10190,8 @@ static void btrfs_encoded_read_endio(struct bio *bio)bio_put (bio); } -static int btrfs_encoded_read_regular_fill_pages (struct inode *inode,u64 offset, -u64 disk_io_size,struct page **pages) +int btrfs_encoded_read_regular_fill_pages (struct inode *inode,u64 offset, +u64 disk_io_size,struct page **pages) {struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_encoded_read_private priv = {
fs/btrfs/send.c +213 -17
292 lines not on this page · raw message
Signature · 1 line
2.30.0
PATCH v7 15/15 btrfs: send: enable support for stream v2 and compressed writes
In reply to a message not in the archiveFrom: Omar Sandoval <[email protected]>
Now that the new support is implemented, allow the ioctl to accept the flags and update the version in sysfs.
--- fs/btrfs/send.c | 10 +++++++++- fs/btrfs/send.h | 2 +- include/uapi/linux/btrfs.h | 4 +++- 3 files changed, 13 insertions(+), 3 deletions(-)
fs/btrfs/send.c +9 -1
@@ -671,7 +671,10 @@ static int send_header(struct send_ctx *sctx)struct btrfs_stream_header hdr;strcpy (hdr.magic,BTRFS_SEND_STREAM_MAGIC ); - hdr.version =cpu_to_le32 (BTRFS_SEND_STREAM_VERSION ); +if (sctx->flags &BTRFS_SEND_FLAG_STREAM_V2 ) + hdr.version =cpu_to_le32 (2 ); +else + hdr.version =cpu_to_le32 (1 );return write_buf (sctx->send_filp, &hdr,sizeof (hdr), &sctx->send_off);
@@ -7446,6 +7449,11 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg) ret = -EINVAL ; goto out; } +if ((arg->flags &BTRFS_SEND_FLAG_COMPRESSED ) && + !(arg->flags &BTRFS_SEND_FLAG_STREAM_V2 )) { + ret = -EINVAL ; + goto out; + } sctx =kzalloc (sizeof (struct send_ctx ),GFP_KERNEL );if (!sctx) {
fs/btrfs/send.h +1 -1
@@ -10,7 +10,7 @@#include "ctree.h" #define BTRFS_SEND_STREAM_MAGIC "btrfs-stream" -#define BTRFS_SEND_STREAM_VERSION 1 +#define BTRFS_SEND_STREAM_VERSION 2/* * In send stream v1, no command is larger than 64k. In send stream v2, no limit
include/uapi/linux/btrfs.h +3 -1
@@ -786,7 +786,9 @@ struct btrfs_ioctl_received_subvol_args {#define BTRFS_SEND_FLAG_MASK \ (BTRFS_SEND_FLAG_NO_FILE_DATA | \ BTRFS_SEND_FLAG_OMIT_STREAM_HEADER | \ - BTRFS_SEND_FLAG_OMIT_END_CMD) + BTRFS_SEND_FLAG_OMIT_END_CMD | \ + BTRFS_SEND_FLAG_STREAM_V2 | \ + BTRFS_SEND_FLAG_COMPRESSED)struct btrfs_ioctl_send_args {__s64 send_fd;/* in */
Signature · 1 line
2.30.0
Please ignore 11-15. I fat fingered format-patch, these are part of the other series.
PATCH v7 13/15 btrfs: send: allocate send buffer with alloc_page() and vmap() for v2
In reply to a message not in the archiveFrom: Omar Sandoval <[email protected]>
For encoded writes, we need the raw pages for reading compressed data directly via a bio. So, replace kvmalloc() with vmap() so we have access to the raw pages. 144k is large enough that it usually gets allocated with vmalloc(), anyways.
--- fs/btrfs/send.c | 33 +++++++++++++++++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-)
fs/btrfs/send.c +31 -2
@@ -81,6 +81,7 @@ struct send_ctx {char *send_buf;u32 send_size;u32 send_max_size; +struct page **send_buf_pages;u64 total_send_size;u64 cmd_send_size[BTRFS_SEND_C_MAX +1 ];u64 flags;/* 'flags' member of btrfs_ioctl_send_args is u64 */
@@ -7203,6 +7204,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)struct btrfs_root *clone_root;struct send_ctx *sctx =NULL ;u32 i; +u32 send_buf_num_pages =0 ;u64 *clone_sources_tmp =NULL ;int clone_sources_to_rollback =0 ;size_t alloc_size;
@@ -7283,10 +7285,28 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)if (sctx->flags &BTRFS_SEND_FLAG_STREAM_V2 ) { sctx->send_max_size =ALIGN (SZ_16K +BTRFS_MAX_COMPRESSED ,PAGE_SIZE ); + send_buf_num_pages = sctx->send_max_size >>PAGE_SHIFT ; + sctx->send_buf_pages =kcalloc (send_buf_num_pages, +sizeof (*sctx->send_buf_pages), +GFP_KERNEL ); +if (!sctx->send_buf_pages) { + send_buf_num_pages =0 ; + ret = -ENOMEM ; + goto out; + } +for (i =0 ; i < send_buf_num_pages; i++) { + sctx->send_buf_pages[i] =alloc_page (GFP_KERNEL ); +if (!sctx->send_buf_pages[i]) { + ret = -ENOMEM ; + goto out; + } + } + sctx->send_buf =vmap (sctx->send_buf_pages, send_buf_num_pages, +VM_MAP ,PAGE_KERNEL ); }else { sctx->send_max_size =BTRFS_SEND_BUF_SIZE_V1 ; + sctx->send_buf =kvmalloc (sctx->send_max_size,GFP_KERNEL ); } - sctx->send_buf =kvmalloc (sctx->send_max_size,GFP_KERNEL );if (!sctx->send_buf) { ret = -ENOMEM ; goto out;
@@ -7495,7 +7515,16 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)fput (sctx->send_filp);kvfree (sctx->clone_roots); -kvfree (sctx->send_buf); +if (sctx->flags &BTRFS_SEND_FLAG_STREAM_V2 ) { +vunmap (sctx->send_buf); +for (i =0 ; i < send_buf_num_pages; i++) { +if (sctx->send_buf_pages[i]) +__free_page (sctx->send_buf_pages[i]); + } +kfree (sctx->send_buf_pages); + }else { +kvfree (sctx->send_buf); + }name_cache_free (sctx);
Signature · 1 line
2.30.0