| Message ID | 20230608135653.2918540-17-eblake@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | qemu patches for 64-bit NBD extensions | expand |
On 08.06.23 16:56, Eric Blake wrote: > The NBD spec states that if the client negotiates extended headers, > the server must avoid NBD_REPLY_TYPE_BLOCK_STATUS and instead use > NBD_REPLY_TYPE_BLOCK_STATUS_EXT which supports 64-bit lengths, even if > the reply does not need more than 32 bits. As of this patch, > client->mode is still never NBD_MODE_EXTENDED, so the code added here > does not take effect until the next patch enables negotiation. > > For now, all metacontexts that we know how to export never populate > more than 32 bits of information, so we don't have to worry about > NBD_REP_ERR_EXT_HEADER_REQD or filtering during handshake, and we > always send all zeroes for the upper 32 bits of status during > NBD_CMD_BLOCK_STATUS. > > Note that we previously had some interesting size-juggling on call > chains, such as: > > nbd_co_send_block_status(uint32_t length) > -> blockstatus_to_extents(uint32_t bytes) > -> bdrv_block_status_above(bytes, &uint64_t num) > -> nbd_extent_array_add(uint64_t num) > -> store num in 32-bit length > > But we were lucky that it never overflowed: bdrv_block_status_above > never sets num larger than bytes, and we had previously been capping > 'bytes' at 32 bits (since the protocol does not allow sending a larger > request without extended headers). This patch adds some assertions > that ensure we continue to avoid overflowing 32 bits for a narrow [..] > @@ -2162,19 +2187,23 @@ static void nbd_extent_array_convert_to_be(NBDExtentArray *ea) > * would result in an incorrect range reported to the client) > */ > static int nbd_extent_array_add(NBDExtentArray *ea, > - uint32_t length, uint32_t flags) > + uint64_t length, uint32_t flags) > { > assert(ea->can_add); > > if (!length) { > return 0; > } > + if (!ea->extended) { > + assert(length <= UINT32_MAX); > + } > > /* Extend previous extent if flags are the same */ > if (ea->count > 0 && flags == ea->extents[ea->count - 1].flags) { > - uint64_t sum = (uint64_t)length + ea->extents[ea->count - 1].length; > + uint64_t sum = length + ea->extents[ea->count - 1].length; > > - if (sum <= UINT32_MAX) { > + assert(sum >= length); > + if (sum <= UINT32_MAX || ea->extended) { that "if" and uint64_t sum was to avoid overflow. I think, we can't just assert, instead include the check into if: if (sum >= length && (sum <= UINT32_MAX || ea->extended) { ... } with this: Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
On Tue, Jun 27, 2023 at 04:23:49PM +0300, Vladimir Sementsov-Ogievskiy wrote: > On 08.06.23 16:56, Eric Blake wrote: > > The NBD spec states that if the client negotiates extended headers, > > the server must avoid NBD_REPLY_TYPE_BLOCK_STATUS and instead use > > NBD_REPLY_TYPE_BLOCK_STATUS_EXT which supports 64-bit lengths, even if > > the reply does not need more than 32 bits. As of this patch, > > client->mode is still never NBD_MODE_EXTENDED, so the code added here > > does not take effect until the next patch enables negotiation. > > > > For now, all metacontexts that we know how to export never populate > > more than 32 bits of information, so we don't have to worry about > > NBD_REP_ERR_EXT_HEADER_REQD or filtering during handshake, and we > > always send all zeroes for the upper 32 bits of status during > > NBD_CMD_BLOCK_STATUS. > > > > Note that we previously had some interesting size-juggling on call > > chains, such as: > > > > nbd_co_send_block_status(uint32_t length) > > -> blockstatus_to_extents(uint32_t bytes) > > -> bdrv_block_status_above(bytes, &uint64_t num) > > -> nbd_extent_array_add(uint64_t num) > > -> store num in 32-bit length > > > > But we were lucky that it never overflowed: bdrv_block_status_above > > never sets num larger than bytes, and we had previously been capping > > 'bytes' at 32 bits (since the protocol does not allow sending a larger > > request without extended headers). This patch adds some assertions > > that ensure we continue to avoid overflowing 32 bits for a narrow > > > [..] > > > @@ -2162,19 +2187,23 @@ static void nbd_extent_array_convert_to_be(NBDExtentArray *ea) > > * would result in an incorrect range reported to the client) > > */ > > static int nbd_extent_array_add(NBDExtentArray *ea, > > - uint32_t length, uint32_t flags) > > + uint64_t length, uint32_t flags) > > { > > assert(ea->can_add); > > > > if (!length) { > > return 0; > > } > > + if (!ea->extended) { > > + assert(length <= UINT32_MAX); > > + } > > > > /* Extend previous extent if flags are the same */ > > if (ea->count > 0 && flags == ea->extents[ea->count - 1].flags) { > > - uint64_t sum = (uint64_t)length + ea->extents[ea->count - 1].length; > > + uint64_t sum = length + ea->extents[ea->count - 1].length; > > > > - if (sum <= UINT32_MAX) { > > + assert(sum >= length); > > + if (sum <= UINT32_MAX || ea->extended) { > > that "if" and uint64_t sum was to avoid overflow. I think, we can't just assert, instead include the check into if: > > if (sum >= length && (sum <= UINT32_MAX || ea->extended) { Why? The assertion is stating that there was no overflow, because we are in control of ea->extents[ea->count - 1].length (it came from local code performing block status, and our block layer guarantees that no block status returns more than 2^63 bytes because we don't support images larger than off_t). At best, all I need is a comment why the assertion is valid. > > ... > > } > > with this: > Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru> > > -- > Best regards, > Vladimir >
On 04.08.23 22:36, Eric Blake wrote: > On Tue, Jun 27, 2023 at 04:23:49PM +0300, Vladimir Sementsov-Ogievskiy wrote: >> On 08.06.23 16:56, Eric Blake wrote: >>> The NBD spec states that if the client negotiates extended headers, >>> the server must avoid NBD_REPLY_TYPE_BLOCK_STATUS and instead use >>> NBD_REPLY_TYPE_BLOCK_STATUS_EXT which supports 64-bit lengths, even if >>> the reply does not need more than 32 bits. As of this patch, >>> client->mode is still never NBD_MODE_EXTENDED, so the code added here >>> does not take effect until the next patch enables negotiation. >>> >>> For now, all metacontexts that we know how to export never populate >>> more than 32 bits of information, so we don't have to worry about >>> NBD_REP_ERR_EXT_HEADER_REQD or filtering during handshake, and we >>> always send all zeroes for the upper 32 bits of status during >>> NBD_CMD_BLOCK_STATUS. >>> >>> Note that we previously had some interesting size-juggling on call >>> chains, such as: >>> >>> nbd_co_send_block_status(uint32_t length) >>> -> blockstatus_to_extents(uint32_t bytes) >>> -> bdrv_block_status_above(bytes, &uint64_t num) >>> -> nbd_extent_array_add(uint64_t num) >>> -> store num in 32-bit length >>> >>> But we were lucky that it never overflowed: bdrv_block_status_above >>> never sets num larger than bytes, and we had previously been capping >>> 'bytes' at 32 bits (since the protocol does not allow sending a larger >>> request without extended headers). This patch adds some assertions >>> that ensure we continue to avoid overflowing 32 bits for a narrow >> >> >> [..] >> >>> @@ -2162,19 +2187,23 @@ static void nbd_extent_array_convert_to_be(NBDExtentArray *ea) >>> * would result in an incorrect range reported to the client) >>> */ >>> static int nbd_extent_array_add(NBDExtentArray *ea, >>> - uint32_t length, uint32_t flags) >>> + uint64_t length, uint32_t flags) >>> { >>> assert(ea->can_add); >>> >>> if (!length) { >>> return 0; >>> } >>> + if (!ea->extended) { >>> + assert(length <= UINT32_MAX); >>> + } >>> >>> /* Extend previous extent if flags are the same */ >>> if (ea->count > 0 && flags == ea->extents[ea->count - 1].flags) { >>> - uint64_t sum = (uint64_t)length + ea->extents[ea->count - 1].length; >>> + uint64_t sum = length + ea->extents[ea->count - 1].length; >>> >>> - if (sum <= UINT32_MAX) { >>> + assert(sum >= length); >>> + if (sum <= UINT32_MAX || ea->extended) { >> >> that "if" and uint64_t sum was to avoid overflow. I think, we can't just assert, instead include the check into if: >> >> if (sum >= length && (sum <= UINT32_MAX || ea->extended) { > > Why? The assertion is stating that there was no overflow, because we > are in control of ea->extents[ea->count - 1].length (it came from > local code performing block status, and our block layer guarantees > that no block status returns more than 2^63 bytes because we don't > support images larger than off_t). At best, all I need is a comment > why the assertion is valid. OK. Small comment would be good. Keep my r-b. The only my point is that you make this small "extent API" block-layer dependent. But I'm not sure that is the only dependency, and I don't insist anyway. > >> >> ... >> >> } >> >> with this: >> Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru> >> >> -- >> Best regards, >> Vladimir >> >
diff --git a/nbd/server.c b/nbd/server.c index 84c848a31d3..3010ff0dca4 100644 --- a/nbd/server.c +++ b/nbd/server.c @@ -2111,20 +2111,24 @@ static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client, } typedef struct NBDExtentArray { - NBDExtent32 *extents; + NBDExtent64 *extents; unsigned int nb_alloc; unsigned int count; uint64_t total_length; + bool extended; bool can_add; bool converted_to_be; } NBDExtentArray; -static NBDExtentArray *nbd_extent_array_new(unsigned int nb_alloc) +static NBDExtentArray *nbd_extent_array_new(unsigned int nb_alloc, + NBDMode mode) { NBDExtentArray *ea = g_new0(NBDExtentArray, 1); + assert(mode >= NBD_MODE_STRUCTURED); ea->nb_alloc = nb_alloc; - ea->extents = g_new(NBDExtent32, nb_alloc); + ea->extents = g_new(NBDExtent64, nb_alloc); + ea->extended = mode >= NBD_MODE_EXTENDED; ea->can_add = true; return ea; @@ -2143,15 +2147,36 @@ static void nbd_extent_array_convert_to_be(NBDExtentArray *ea) int i; assert(!ea->converted_to_be); + assert(ea->extended); ea->can_add = false; ea->converted_to_be = true; for (i = 0; i < ea->count; i++) { - ea->extents[i].flags = cpu_to_be32(ea->extents[i].flags); - ea->extents[i].length = cpu_to_be32(ea->extents[i].length); + ea->extents[i].length = cpu_to_be64(ea->extents[i].length); + ea->extents[i].flags = cpu_to_be64(ea->extents[i].flags); } } +/* Further modifications of the array after conversion are abandoned */ +static NBDExtent32 *nbd_extent_array_convert_to_narrow(NBDExtentArray *ea) +{ + int i; + NBDExtent32 *extents = g_new(NBDExtent32, ea->count); + + assert(!ea->converted_to_be); + assert(!ea->extended); + ea->can_add = false; + ea->converted_to_be = true; + + for (i = 0; i < ea->count; i++) { + assert((ea->extents[i].length | ea->extents[i].flags) <= UINT32_MAX); + extents[i].length = cpu_to_be32(ea->extents[i].length); + extents[i].flags = cpu_to_be32(ea->extents[i].flags); + } + + return extents; +} + /* * Add extent to NBDExtentArray. If extent can't be added (no available space), * return -1. @@ -2162,19 +2187,23 @@ static void nbd_extent_array_convert_to_be(NBDExtentArray *ea) * would result in an incorrect range reported to the client) */ static int nbd_extent_array_add(NBDExtentArray *ea, - uint32_t length, uint32_t flags) + uint64_t length, uint32_t flags) { assert(ea->can_add); if (!length) { return 0; } + if (!ea->extended) { + assert(length <= UINT32_MAX); + } /* Extend previous extent if flags are the same */ if (ea->count > 0 && flags == ea->extents[ea->count - 1].flags) { - uint64_t sum = (uint64_t)length + ea->extents[ea->count - 1].length; + uint64_t sum = length + ea->extents[ea->count - 1].length; - if (sum <= UINT32_MAX) { + assert(sum >= length); + if (sum <= UINT32_MAX || ea->extended) { ea->extents[ea->count - 1].length = sum; ea->total_length += length; return 0; @@ -2187,7 +2216,7 @@ static int nbd_extent_array_add(NBDExtentArray *ea, } ea->total_length += length; - ea->extents[ea->count] = (NBDExtent32) {.length = length, .flags = flags}; + ea->extents[ea->count] = (NBDExtent64) {.length = length, .flags = flags}; ea->count++; return 0; @@ -2256,20 +2285,39 @@ nbd_co_send_extents(NBDClient *client, NBDRequest *request, NBDExtentArray *ea, bool last, uint32_t context_id, Error **errp) { NBDReply hdr; - NBDStructuredMeta chunk; - struct iovec iov[] = { - {.iov_base = &hdr}, - {.iov_base = &chunk, .iov_len = sizeof(chunk)}, - {.iov_base = ea->extents, .iov_len = ea->count * sizeof(ea->extents[0])} - }; - - nbd_extent_array_convert_to_be(ea); + NBDStructuredMeta meta; + NBDExtendedMeta meta_ext; + g_autofree NBDExtent32 *extents = NULL; + uint16_t type; + struct iovec iov[] = { {.iov_base = &hdr}, {0}, {0} }; + + if (client->mode >= NBD_MODE_EXTENDED) { + type = NBD_REPLY_TYPE_BLOCK_STATUS_EXT; + + iov[1].iov_base = &meta_ext; + iov[1].iov_len = sizeof(meta_ext); + stl_be_p(&meta_ext.context_id, context_id); + stl_be_p(&meta_ext.count, ea->count); + + nbd_extent_array_convert_to_be(ea); + iov[2].iov_base = ea->extents; + iov[2].iov_len = ea->count * sizeof(ea->extents[0]); + } else { + type = NBD_REPLY_TYPE_BLOCK_STATUS; + + iov[1].iov_base = &meta; + iov[1].iov_len = sizeof(meta); + stl_be_p(&meta.context_id, context_id); + + extents = nbd_extent_array_convert_to_narrow(ea); + iov[2].iov_base = extents; + iov[2].iov_len = ea->count * sizeof(extents[0]); + } trace_nbd_co_send_extents(request->cookie, ea->count, context_id, ea->total_length, last); - set_be_chunk(client, iov, 3, last ? NBD_REPLY_FLAG_DONE : 0, - NBD_REPLY_TYPE_BLOCK_STATUS, request); - stl_be_p(&chunk.context_id, context_id); + set_be_chunk(client, iov, 3, last ? NBD_REPLY_FLAG_DONE : 0, type, + request); return nbd_co_send_iov(client, iov, 3, errp); } @@ -2278,13 +2326,14 @@ nbd_co_send_extents(NBDClient *client, NBDRequest *request, NBDExtentArray *ea, static int coroutine_fn nbd_co_send_block_status(NBDClient *client, NBDRequest *request, BlockBackend *blk, uint64_t offset, - uint32_t length, bool dont_fragment, + uint64_t length, bool dont_fragment, bool last, uint32_t context_id, Error **errp) { int ret; unsigned int nb_extents = dont_fragment ? 1 : NBD_MAX_BLOCK_STATUS_EXTENTS; - g_autoptr(NBDExtentArray) ea = nbd_extent_array_new(nb_extents); + g_autoptr(NBDExtentArray) ea = + nbd_extent_array_new(nb_extents, client->mode); if (context_id == NBD_META_ID_BASE_ALLOCATION) { ret = blockstatus_to_extents(blk, offset, length, ea); @@ -2307,11 +2356,12 @@ static void bitmap_to_extents(BdrvDirtyBitmap *bitmap, int64_t start, dirty_start, dirty_count; int64_t end = offset + length; bool full = false; + int64_t bound = es->extended ? INT64_MAX : INT32_MAX; bdrv_dirty_bitmap_lock(bitmap); for (start = offset; - bdrv_dirty_bitmap_next_dirty_area(bitmap, start, end, INT32_MAX, + bdrv_dirty_bitmap_next_dirty_area(bitmap, start, end, bound, &dirty_start, &dirty_count); start = dirty_start + dirty_count) { @@ -2335,12 +2385,13 @@ static int coroutine_fn nbd_co_send_bitmap(NBDClient *client, NBDRequest *request, BdrvDirtyBitmap *bitmap, uint64_t offset, - uint32_t length, bool dont_fragment, + uint64_t length, bool dont_fragment, bool last, uint32_t context_id, Error **errp) { unsigned int nb_extents = dont_fragment ? 1 : NBD_MAX_BLOCK_STATUS_EXTENTS; - g_autoptr(NBDExtentArray) ea = nbd_extent_array_new(nb_extents); + g_autoptr(NBDExtentArray) ea = + nbd_extent_array_new(nb_extents, client->mode); bitmap_to_extents(bitmap, offset, length, ea); @@ -2637,7 +2688,8 @@ static coroutine_fn int nbd_handle_request(NBDClient *client, return nbd_send_generic_reply(client, request, -EINVAL, "need non-zero length", errp); } - assert(request->len <= UINT32_MAX); + assert(client->mode >= NBD_MODE_EXTENDED || + request->len <= UINT32_MAX); if (client->export_meta.count) { bool dont_fragment = request->flags & NBD_CMD_FLAG_REQ_ONE; int contexts_remaining = client->export_meta.count;
The NBD spec states that if the client negotiates extended headers, the server must avoid NBD_REPLY_TYPE_BLOCK_STATUS and instead use NBD_REPLY_TYPE_BLOCK_STATUS_EXT which supports 64-bit lengths, even if the reply does not need more than 32 bits. As of this patch, client->mode is still never NBD_MODE_EXTENDED, so the code added here does not take effect until the next patch enables negotiation. For now, all metacontexts that we know how to export never populate more than 32 bits of information, so we don't have to worry about NBD_REP_ERR_EXT_HEADER_REQD or filtering during handshake, and we always send all zeroes for the upper 32 bits of status during NBD_CMD_BLOCK_STATUS. Note that we previously had some interesting size-juggling on call chains, such as: nbd_co_send_block_status(uint32_t length) -> blockstatus_to_extents(uint32_t bytes) -> bdrv_block_status_above(bytes, &uint64_t num) -> nbd_extent_array_add(uint64_t num) -> store num in 32-bit length But we were lucky that it never overflowed: bdrv_block_status_above never sets num larger than bytes, and we had previously been capping 'bytes' at 32 bits (since the protocol does not allow sending a larger request without extended headers). This patch adds some assertions that ensure we continue to avoid overflowing 32 bits for a narrow client, while fully utilizing 64-bits all the way through when the client understands that. Signed-off-by: Eric Blake <eblake@redhat.com> --- v4: split conversion to big-endian across two helper functions rather than in-place union [Vladimir] --- nbd/server.c | 104 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 78 insertions(+), 26 deletions(-)