For destinations, especially NBD, which have a preferred block size, adjust our write strategy so we always write whole blocks / zeroes of the preferred size. --- copy/file-ops.c | 8 ++++ copy/main.c | 82 ++++++++++++++++++++++++++++++++++++- copy/multi-thread-copying.c | 2 + copy/nbd-ops.c | 21 ++++++++++ copy/nbdcopy.h | 5 +++ copy/null-ops.c | 7 ++++ copy/pipe-ops.c | 7 ++++ copy/synch-copying.c | 2 + 8 files changed, 132 insertions(+), 2 deletions(-) diff --git a/copy/file-ops.c b/copy/file-ops.c index 847043417..3daf55484 100644 --- a/copy/file-ops.c +++ b/copy/file-ops.c @@ -369,6 +369,13 @@ file_is_read_only (struct rw *rw) return false; } +static uint64_t +file_get_preferred_block_size (struct rw *rw) +{ + /* XXX Could return the filesystem block size here. */ + return 4096; +} + static bool file_can_extents (struct rw *rw) { @@ -726,6 +733,7 @@ static struct rw_ops file_ops = { .ops_name = "file_ops", .close = file_close, .is_read_only = file_is_read_only, + .get_preferred_block_size = file_get_preferred_block_size, .can_extents = file_can_extents, .can_multi_conn = file_can_multi_conn, .start_multi_conn = file_start_multi_conn, diff --git a/copy/main.c b/copy/main.c index 67788b5d9..82537bafc 100644 --- a/copy/main.c +++ b/copy/main.c @@ -38,12 +38,15 @@ #include <libnbd.h> +#include "isaligned.h" #include "ispowerof2.h" #include "human-size.h" +#include "rounding.h" #include "version.h" #include "nbdcopy.h" bool allocated; /* --allocated flag */ +uint64_t blocksize; /* destination block size */ unsigned connections = 4; /* --connections */ bool destination_is_zero; /* --destination-is-zero flag */ bool extents = true; /* ! --no-extents flag */ @@ -367,6 +370,29 @@ main (int argc, char *argv[]) if (threads < connections) connections = threads; + /* Check the destination preferred block size. */ + blocksize = dst->ops->get_preferred_block_size (dst); + if (!is_power_of_2 (blocksize)) { + fprintf (stderr, "%s: error: " + "destination block size is not a power of 2: %" PRIu64 "\n", + prog, blocksize); + exit (EXIT_FAILURE); + } + if (request_size < blocksize) { + fprintf (stderr, "%s: error: " + "request size (%u) < destination block size (%" PRIu64 "), " + "use the --request-size option to pick a larger request size" + "\n", + prog, request_size, blocksize); + exit (EXIT_FAILURE); + } + if (blocksize > THREAD_WORK_SIZE) { + fprintf (stderr, "%s: error: " + "destination block size is too large for nbdcopy: %" PRIu64 "\n", + prog, blocksize); + exit (EXIT_FAILURE); + } + /* Truncate the destination to the same size as the source. Only * has an effect on regular files. */ @@ -392,9 +418,10 @@ main (int argc, char *argv[]) print_rw (src, "nbdcopy: src", stderr); print_rw (dst, "nbdcopy: dst", stderr); fprintf (stderr, "nbdcopy: connections=%u requests=%u threads=%u " - "synchronous=%s\n", + "synchronous=%s blocksize=%" PRIu64 "\n", connections, max_requests, threads, - synchronous ? "true" : "false"); + synchronous ? "true" : "false", + blocksize); } /* If multi-conn is enabled on either side, then at this point we @@ -537,6 +564,57 @@ default_get_extents (struct rw *rw, uintptr_t index, } } +/* Reading extents from the source drives writes and zeroes to the + * destination. We need to adjust the extents list so that any + * extents smaller than the destination block size are eliminated. + */ +void +adjust_extents_for_blocksize (extent_list *exts) +{ + size_t i, j; + uint64_t end; + + if (blocksize <= 1) + return; + + /* Note we iterate [0..len-2] because the very last extent is + * permitted to be shorter than a whole block. + */ + for (i = 0; i < exts->len - 1; ++i) { + assert (IS_ALIGNED (exts->ptr[i].offset, blocksize)); + if (IS_ALIGNED (exts->ptr[i].length, blocksize)) + continue; + + if (!exts->ptr[i].zero) /* data */ { + /* Data extent: round the length up to the next block, delete + * any completely overlapped extents, and if still needed move + * up the start of the next extent. + */ + exts->ptr[i].length = ROUND_UP (exts->ptr[i].length, blocksize); + end = exts->ptr[i].offset + exts->ptr[i].length; + + for (j = i+1; j < exts->len && exts->ptr[j].offset < end; ++j) { + if (exts->ptr[j].offset + exts->ptr[j].length <= end) + extent_list_remove (exts, j); + if (exts->ptr[j].offset < end) + exts->ptr[j].offset = end; + } + } + else { + /* Zero extent: Round the length down to blocksize, and if now + * zero-length, remove it. + */ + exts->ptr[i].length = ROUND_DOWN (exts->ptr[i].length, blocksize); + if (i+1 < exts->len) + exts->ptr[i+1].offset = exts->ptr[i].offset + exts->ptr[i].length; + if (exts->ptr[i].length == 0) { + extent_list_remove (exts, i); + i--; + } + } + } +} + /* Implementations of get_polling_fd and asynch_notify_* for backends * which don't support polling. */ diff --git a/copy/multi-thread-copying.c b/copy/multi-thread-copying.c index b17ca598b..b436ba779 100644 --- a/copy/multi-thread-copying.c +++ b/copy/multi-thread-copying.c @@ -154,6 +154,8 @@ worker_thread (void *indexp) else default_get_extents (src, index, offset, count, &exts); + adjust_extents_for_blocksize (&exts); + for (i = 0; i < exts.len; ++i) { struct command *command; struct buffer *buffer; diff --git a/copy/nbd-ops.c b/copy/nbd-ops.c index dfc62f203..1134ddd4e 100644 --- a/copy/nbd-ops.c +++ b/copy/nbd-ops.c @@ -195,6 +195,26 @@ nbd_ops_is_read_only (struct rw *rw) return false; } +static uint64_t +nbd_ops_get_preferred_block_size (struct rw *rw) +{ + struct rw_nbd *rwn = (struct rw_nbd *) rw; + struct nbd_handle *nbd; + int64_t r; + + if (rwn->handles.len == 0) + return 4096; + + nbd = rwn->handles.ptr[0]; + r = nbd_get_block_size (nbd, LIBNBD_SIZE_PREFERRED); + if (r == -1) { + fprintf (stderr, "%s: %s\n", rw->name, nbd_get_error ()); + exit (EXIT_FAILURE); + } + + return r == 0 ? 4096 : (uint64_t) r; +} + static bool nbd_ops_can_extents (struct rw *rw) { @@ -491,6 +511,7 @@ static struct rw_ops nbd_ops = { .ops_name = "nbd_ops", .close = nbd_ops_close, .is_read_only = nbd_ops_is_read_only, + .get_preferred_block_size = nbd_ops_get_preferred_block_size, .can_extents = nbd_ops_can_extents, .can_multi_conn = nbd_ops_can_multi_conn, .start_multi_conn = nbd_ops_start_multi_conn, diff --git a/copy/nbdcopy.h b/copy/nbdcopy.h index e7fe1eab2..c6505a1d4 100644 --- a/copy/nbdcopy.h +++ b/copy/nbdcopy.h @@ -120,6 +120,9 @@ struct rw_ops { /* Return true if this is a read-only connection. */ bool (*is_read_only) (struct rw *rw); + /* Read the preferred block size. */ + uint64_t (*get_preferred_block_size) (struct rw *rw); + /* For source only, does it support reading extents? */ bool (*can_extents) (struct rw *rw); @@ -206,12 +209,14 @@ struct rw_ops { extern void default_get_extents (struct rw *rw, uintptr_t index, uint64_t offset, uint64_t count, extent_list *ret); +extern void adjust_extents_for_blocksize (extent_list *exts); extern void get_polling_fd_not_supported (struct rw *rw, uintptr_t index, int *fd_rtn, int *direction_rtn); extern void asynch_notify_read_write_not_supported (struct rw *rw, uintptr_t index); extern bool allocated; +extern uint64_t blocksize; extern unsigned connections; extern bool destination_is_zero; extern bool extents; diff --git a/copy/null-ops.c b/copy/null-ops.c index a38666d62..5e87f3502 100644 --- a/copy/null-ops.c +++ b/copy/null-ops.c @@ -66,6 +66,12 @@ null_is_read_only (struct rw *rw) return false; } +static uint64_t +null_get_preferred_block_size (struct rw *rw) +{ + return 1; +} + static bool null_can_extents (struct rw *rw) { @@ -154,6 +160,7 @@ static struct rw_ops null_ops = { .ops_name = "null_ops", .close = null_close, .is_read_only = null_is_read_only, + .get_preferred_block_size = null_get_preferred_block_size, .can_extents = null_can_extents, .can_multi_conn = null_can_multi_conn, .start_multi_conn = null_start_multi_conn, diff --git a/copy/pipe-ops.c b/copy/pipe-ops.c index f9b8599a3..f2a1f0090 100644 --- a/copy/pipe-ops.c +++ b/copy/pipe-ops.c @@ -72,6 +72,12 @@ pipe_is_read_only (struct rw *rw) return false; } +static uint64_t +pipe_get_preferred_block_size (struct rw *rw) +{ + return 1; +} + static bool pipe_can_extents (struct rw *rw) { @@ -165,6 +171,7 @@ static struct rw_ops pipe_ops = { .close = pipe_close, .is_read_only = pipe_is_read_only, + .get_preferred_block_size = pipe_get_preferred_block_size, .can_extents = pipe_can_extents, .can_multi_conn = pipe_can_multi_conn, .start_multi_conn = pipe_start_multi_conn, diff --git a/copy/synch-copying.c b/copy/synch-copying.c index c9899c343..8d6c4d3d0 100644 --- a/copy/synch-copying.c +++ b/copy/synch-copying.c @@ -70,6 +70,8 @@ synch_copying (void) else default_get_extents (src, 0, offset, count, &exts); + adjust_extents_for_blocksize (&exts); + for (i = 0; i < exts.len; ++i) { assert (exts.ptr[i].length <= count); -- 2.32.0