| Message ID | d37fc365eda31317abe6ef89be534d6b5effc0b7.1630515568.git.osandov@fb.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | None | expand |
On 1.09.21 г. 20:01, Omar Sandoval wrote: > From: Boris Burkov <boris@bur.io> > > Send stream v2 can emit fallocate commands, so receive must support them > as well. The implementation simply passes along the arguments to the > syscall. Note that mode is encoded as a u32 in send stream but fallocate > takes an int, so there is a unsigned->signed conversion there. > > Signed-off-by: Boris Burkov <boris@bur.io> Reviewed-by: Nikolay Borisov <nborisov@suse.com> However, kernel support for this hasn't landed, the kernel counterpart patches add definitions but don't actually implement the code. BY the looks of it it would seem that the proper send stream versioning could be added first before any of this code lands. In this case we can simply have the encoded writes stuff as protocol version 2 and leave the rest of the commands for v3 for example.
On Thu, Oct 21, 2021 at 05:21:00PM +0300, Nikolay Borisov wrote: > > > On 1.09.21 г. 20:01, Omar Sandoval wrote: > > From: Boris Burkov <boris@bur.io> > > > > Send stream v2 can emit fallocate commands, so receive must support them > > as well. The implementation simply passes along the arguments to the > > syscall. Note that mode is encoded as a u32 in send stream but fallocate > > takes an int, so there is a unsigned->signed conversion there. > > > > Signed-off-by: Boris Burkov <boris@bur.io> > > Reviewed-by: Nikolay Borisov <nborisov@suse.com> > > However, kernel support for this hasn't landed, the kernel counterpart > patches add definitions but don't actually implement the code. BY the > looks of it it would seem that the proper send stream versioning could > be added first before any of this code lands. In this case we can simply > have the encoded writes stuff as protocol version 2 and leave the rest > of the commands for v3 for example. The original idea for this was to minimize protocol revisions. This way, when we get around to implementing fallocate on the send side, we wouldn't need another update on the receive side. I still like that idea since the receive side is so trivial.
diff --git a/cmds/receive-dump.c b/cmds/receive-dump.c index 20ec2b70..acc0ba32 100644 --- a/cmds/receive-dump.c +++ b/cmds/receive-dump.c @@ -329,6 +329,14 @@ static int print_encoded_write(const char *path, const void *data, u64 offset, unencoded_offset, compression, encryption); } +static int print_fallocate(const char *path, int mode, u64 offset, u64 len, + void *user) +{ + return PRINT_DUMP(user, path, "fallocate", + "mode=%d offset=%llu len=%llu", + mode, offset, len); +} + struct btrfs_send_ops btrfs_print_send_ops = { .subvol = print_subvol, .snapshot = print_snapshot, @@ -352,4 +360,5 @@ struct btrfs_send_ops btrfs_print_send_ops = { .utimes = print_utimes, .update_extent = print_update_extent, .encoded_write = print_encoded_write, + .fallocate = print_fallocate, }; diff --git a/cmds/receive.c b/cmds/receive.c index 2eebcfd1..953d7217 100644 --- a/cmds/receive.c +++ b/cmds/receive.c @@ -1264,6 +1264,30 @@ static int process_encoded_write(const char *path, const void *data, u64 offset, compression); } +static int process_fallocate(const char *path, int mode, u64 offset, u64 len, + void *user) +{ + int ret; + struct btrfs_receive *rctx = user; + char full_path[PATH_MAX]; + + ret = path_cat_out(full_path, rctx->full_subvol_path, path); + if (ret < 0) { + error("fallocate: path invalid: %s", path); + return ret; + } + ret = open_inode_for_write(rctx, full_path); + if (ret < 0) + return ret; + ret = fallocate(rctx->write_fd, mode, offset, len); + if (ret < 0) { + ret = -errno; + error("fallocate: fallocate on %s failed: %m", path); + return ret; + } + return 0; +} + static struct btrfs_send_ops send_ops = { .subvol = process_subvol, .snapshot = process_snapshot, @@ -1287,6 +1311,7 @@ static struct btrfs_send_ops send_ops = { .utimes = process_utimes, .update_extent = process_update_extent, .encoded_write = process_encoded_write, + .fallocate = process_fallocate, }; static int do_receive(struct btrfs_receive *rctx, const char *tomnt, diff --git a/common/send-stream.c b/common/send-stream.c index 044e101b..bc41396e 100644 --- a/common/send-stream.c +++ b/common/send-stream.c @@ -369,6 +369,7 @@ static int read_and_process_cmd(struct btrfs_send_stream *sctx) u64 unencoded_offset; int len; int xattr_len; + int fallocate_mode; ret = read_cmd(sctx); if (ret) @@ -514,6 +515,14 @@ static int read_and_process_cmd(struct btrfs_send_stream *sctx) case BTRFS_SEND_C_END: ret = 1; break; + case BTRFS_SEND_C_FALLOCATE: + TLV_GET_STRING(sctx, BTRFS_SEND_A_PATH, &path); + TLV_GET_U32(sctx, BTRFS_SEND_A_FALLOCATE_MODE, &fallocate_mode); + TLV_GET_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, &offset); + TLV_GET_U64(sctx, BTRFS_SEND_A_SIZE, &tmp); + ret = sctx->ops->fallocate(path, fallocate_mode, offset, tmp, + sctx->user); + break; } tlv_get_failed: diff --git a/common/send-stream.h b/common/send-stream.h index 607bc007..a58739bb 100644 --- a/common/send-stream.h +++ b/common/send-stream.h @@ -70,6 +70,8 @@ struct btrfs_send_ops { u64 len, u64 unencoded_file_len, u64 unencoded_len, u64 unencoded_offset, u32 compression, u32 encryption, void *user); + int (*fallocate)(const char *path, int mode, u64 offset, u64 len, + void *user); }; int btrfs_read_and_process_send_stream(int fd,