ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

block/nbd: merge NBDClientSession struct back to BDRVNBDState 

No reason to keep it separate, it differs from others block driver
behavior and therefore confuses. Instead of generic
  'state = (State*)bs->opaque' we have to use special helper.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20190611102720.86114-4-vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2019-06-11 13:27:20 +03:00 committed by Eric Blake
parent 86f8cdf3db
commit 611ae1d716
1 changed files with 94 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

197
block/nbd.c
View File

@ -53,7 +53,7 @@ typedef struct {
bool receiving; /* waiting for connection_co? */ bool receiving; /* waiting for connection_co? */
} NBDClientRequest; } NBDClientRequest;
typedef struct NBDClientSession { typedef struct BDRVNBDState {
QIOChannelSocket *sioc; /* The master data channel */ QIOChannelSocket *sioc; /* The master data channel */
QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */ QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */
NBDExportInfo info; NBDExportInfo info;
@ -67,24 +67,13 @@ typedef struct NBDClientSession {
NBDReply reply; NBDReply reply;
BlockDriverState *bs; BlockDriverState *bs;
bool quit; bool quit;
} NBDClientSession;
typedef struct BDRVNBDState {
NBDClientSession client;
/* For nbd_refresh_filename() */ /* For nbd_refresh_filename() */
SocketAddress *saddr; SocketAddress *saddr;
char *export, *tlscredsid; char *export, *tlscredsid;
} BDRVNBDState; } BDRVNBDState;
static NBDClientSession *nbd_get_client_session(BlockDriverState *bs) static void nbd_recv_coroutines_wake_all(BDRVNBDState *s)
{
BDRVNBDState *s = bs->opaque;
return &s->client;
}
static void nbd_recv_coroutines_wake_all(NBDClientSession *s)
{ {
int i; int i;
@ -99,14 +88,15 @@ static void nbd_recv_coroutines_wake_all(NBDClientSession *s)
static void nbd_client_detach_aio_context(BlockDriverState *bs) static void nbd_client_detach_aio_context(BlockDriverState *bs)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc));
qio_channel_detach_aio_context(QIO_CHANNEL(s->ioc));
} }
static void nbd_client_attach_aio_context_bh(void *opaque) static void nbd_client_attach_aio_context_bh(void *opaque)
{ {
BlockDriverState *bs = opaque; BlockDriverState *bs = opaque;
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
/* /*
* The node is still drained, so we know the coroutine has yielded in * The node is still drained, so we know the coroutine has yielded in
@ -114,15 +104,16 @@ static void nbd_client_attach_aio_context_bh(void *opaque)
* entered for the first time. Both places are safe for entering the * entered for the first time. Both places are safe for entering the
* coroutine. * coroutine.
*/ */
qemu_aio_coroutine_enter(bs->aio_context, client->connection_co); qemu_aio_coroutine_enter(bs->aio_context, s->connection_co);
bdrv_dec_in_flight(bs); bdrv_dec_in_flight(bs);
} }
static void nbd_client_attach_aio_context(BlockDriverState *bs, static void nbd_client_attach_aio_context(BlockDriverState *bs,
AioContext *new_context) AioContext *new_context)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
qio_channel_attach_aio_context(QIO_CHANNEL(client->ioc), new_context);
qio_channel_attach_aio_context(QIO_CHANNEL(s->ioc), new_context);
bdrv_inc_in_flight(bs); bdrv_inc_in_flight(bs);
@ -136,26 +127,26 @@ static void nbd_client_attach_aio_context(BlockDriverState *bs,
static void nbd_teardown_connection(BlockDriverState *bs) static void nbd_teardown_connection(BlockDriverState *bs)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
assert(client->ioc); assert(s->ioc);
/* finish any pending coroutines */ /* finish any pending coroutines */
qio_channel_shutdown(client->ioc, qio_channel_shutdown(s->ioc,
QIO_CHANNEL_SHUTDOWN_BOTH, QIO_CHANNEL_SHUTDOWN_BOTH,
NULL); NULL);
BDRV_POLL_WHILE(bs, client->connection_co); BDRV_POLL_WHILE(bs, s->connection_co);
nbd_client_detach_aio_context(bs); nbd_client_detach_aio_context(bs);
object_unref(OBJECT(client->sioc)); object_unref(OBJECT(s->sioc));
client->sioc = NULL; s->sioc = NULL;
object_unref(OBJECT(client->ioc)); object_unref(OBJECT(s->ioc));
client->ioc = NULL; s->ioc = NULL;
} }
static coroutine_fn void nbd_connection_entry(void *opaque) static coroutine_fn void nbd_connection_entry(void *opaque)
{ {
NBDClientSession *s = opaque; BDRVNBDState *s = opaque;
uint64_t i; uint64_t i;
int ret = 0; int ret = 0;
Error *local_err = NULL; Error *local_err = NULL;
@ -223,7 +214,7 @@ static int nbd_co_send_request(BlockDriverState *bs,
NBDRequest *request, NBDRequest *request,
QEMUIOVector *qiov) QEMUIOVector *qiov)
{ {
NBDClientSession *s = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
int rc, i; int rc, i;
qemu_co_mutex_lock(&s->send_mutex); qemu_co_mutex_lock(&s->send_mutex);
@ -298,7 +289,7 @@ static inline uint64_t payload_advance64(uint8_t **payload)
return ldq_be_p(*payload - 8); return ldq_be_p(*payload - 8);
} }
static int nbd_parse_offset_hole_payload(NBDClientSession *client, static int nbd_parse_offset_hole_payload(BDRVNBDState *s,
NBDStructuredReplyChunk *chunk, NBDStructuredReplyChunk *chunk,
uint8_t *payload, uint64_t orig_offset, uint8_t *payload, uint64_t orig_offset,
QEMUIOVector *qiov, Error **errp) QEMUIOVector *qiov, Error **errp)
@ -321,8 +312,8 @@ static int nbd_parse_offset_hole_payload(NBDClientSession *client,
" region"); " region");
return -EINVAL; return -EINVAL;
} }
if (client->info.min_block && if (s->info.min_block &&
!QEMU_IS_ALIGNED(hole_size, client->info.min_block)) { !QEMU_IS_ALIGNED(hole_size, s->info.min_block)) {
trace_nbd_structured_read_compliance("hole"); trace_nbd_structured_read_compliance("hole");
} }
@ -336,7 +327,7 @@ static int nbd_parse_offset_hole_payload(NBDClientSession *client,
* Based on our request, we expect only one extent in reply, for the * Based on our request, we expect only one extent in reply, for the
* base:allocation context. * base:allocation context.
*/ */
static int nbd_parse_blockstatus_payload(NBDClientSession *client, static int nbd_parse_blockstatus_payload(BDRVNBDState *s,
NBDStructuredReplyChunk *chunk, NBDStructuredReplyChunk *chunk,
uint8_t *payload, uint64_t orig_length, uint8_t *payload, uint64_t orig_length,
NBDExtent *extent, Error **errp) NBDExtent *extent, Error **errp)
@ -351,11 +342,11 @@ static int nbd_parse_blockstatus_payload(NBDClientSession *client,
} }
context_id = payload_advance32(&payload); context_id = payload_advance32(&payload);
if (client->info.context_id != context_id) { if (s->info.context_id != context_id) {
error_setg(errp, "Protocol error: unexpected context id %d for " error_setg(errp, "Protocol error: unexpected context id %d for "
"NBD_REPLY_TYPE_BLOCK_STATUS, when negotiated context " "NBD_REPLY_TYPE_BLOCK_STATUS, when negotiated context "
"id is %d", context_id, "id is %d", context_id,
client->info.context_id); s->info.context_id);
return -EINVAL; return -EINVAL;
} }
@ -380,14 +371,14 @@ static int nbd_parse_blockstatus_payload(NBDClientSession *client,
* up to the full block and change the status to fully-allocated * up to the full block and change the status to fully-allocated
* (always a safe status, even if it loses information). * (always a safe status, even if it loses information).
*/ */
if (client->info.min_block && !QEMU_IS_ALIGNED(extent->length, if (s->info.min_block && !QEMU_IS_ALIGNED(extent->length,
client->info.min_block)) { s->info.min_block)) {
trace_nbd_parse_blockstatus_compliance("extent length is unaligned"); trace_nbd_parse_blockstatus_compliance("extent length is unaligned");
if (extent->length > client->info.min_block) { if (extent->length > s->info.min_block) {
extent->length = QEMU_ALIGN_DOWN(extent->length, extent->length = QEMU_ALIGN_DOWN(extent->length,
client->info.min_block); s->info.min_block);
} else { } else {
extent->length = client->info.min_block; extent->length = s->info.min_block;
extent->flags = 0; extent->flags = 0;
} }
} }
@ -453,7 +444,7 @@ static int nbd_parse_error_payload(NBDStructuredReplyChunk *chunk,
return 0; return 0;
} }
static int nbd_co_receive_offset_data_payload(NBDClientSession *s, static int nbd_co_receive_offset_data_payload(BDRVNBDState *s,
uint64_t orig_offset, uint64_t orig_offset,
QEMUIOVector *qiov, Error **errp) QEMUIOVector *qiov, Error **errp)
{ {
@ -498,7 +489,7 @@ static int nbd_co_receive_offset_data_payload(NBDClientSession *s,
#define NBD_MAX_MALLOC_PAYLOAD 1000 #define NBD_MAX_MALLOC_PAYLOAD 1000
static coroutine_fn int nbd_co_receive_structured_payload( static coroutine_fn int nbd_co_receive_structured_payload(
NBDClientSession *s, void **payload, Error **errp) BDRVNBDState *s, void **payload, Error **errp)
{ {
int ret; int ret;
uint32_t len; uint32_t len;
@ -548,7 +539,7 @@ static coroutine_fn int nbd_co_receive_structured_payload(
* corresponding to the server's error reply), and errp is unchanged. * corresponding to the server's error reply), and errp is unchanged.
*/ */
static coroutine_fn int nbd_co_do_receive_one_chunk( static coroutine_fn int nbd_co_do_receive_one_chunk(
NBDClientSession *s, uint64_t handle, bool only_structured, BDRVNBDState *s, uint64_t handle, bool only_structured,
int *request_ret, QEMUIOVector *qiov, void **payload, Error **errp) int *request_ret, QEMUIOVector *qiov, void **payload, Error **errp)
{ {
int ret; int ret;
@ -641,7 +632,7 @@ static coroutine_fn int nbd_co_do_receive_one_chunk(
* Return value is a fatal error code or normal nbd reply error code * Return value is a fatal error code or normal nbd reply error code
*/ */
static coroutine_fn int nbd_co_receive_one_chunk( static coroutine_fn int nbd_co_receive_one_chunk(
NBDClientSession *s, uint64_t handle, bool only_structured, BDRVNBDState *s, uint64_t handle, bool only_structured,
int *request_ret, QEMUIOVector *qiov, NBDReply *reply, void **payload, int *request_ret, QEMUIOVector *qiov, NBDReply *reply, void **payload,
Error **errp) Error **errp)
{ {
@ -709,7 +700,7 @@ static void nbd_iter_request_error(NBDReplyChunkIter *iter, int ret)
* nbd_reply_chunk_iter_receive * nbd_reply_chunk_iter_receive
* The pointer stored in @payload requires g_free() to free it. * The pointer stored in @payload requires g_free() to free it.
*/ */
static bool nbd_reply_chunk_iter_receive(NBDClientSession *s, static bool nbd_reply_chunk_iter_receive(BDRVNBDState *s,
NBDReplyChunkIter *iter, NBDReplyChunkIter *iter,
uint64_t handle, uint64_t handle,
QEMUIOVector *qiov, NBDReply *reply, QEMUIOVector *qiov, NBDReply *reply,
@ -776,7 +767,7 @@ break_loop:
return false; return false;
} }
static int nbd_co_receive_return_code(NBDClientSession *s, uint64_t handle, static int nbd_co_receive_return_code(BDRVNBDState *s, uint64_t handle,
int *request_ret, Error **errp) int *request_ret, Error **errp)
{ {
NBDReplyChunkIter iter; NBDReplyChunkIter iter;
@ -790,7 +781,7 @@ static int nbd_co_receive_return_code(NBDClientSession *s, uint64_t handle,
return iter.ret; return iter.ret;
} }
static int nbd_co_receive_cmdread_reply(NBDClientSession *s, uint64_t handle, static int nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t handle,
uint64_t offset, QEMUIOVector *qiov, uint64_t offset, QEMUIOVector *qiov,
int *request_ret, Error **errp) int *request_ret, Error **errp)
{ {
@ -842,7 +833,7 @@ static int nbd_co_receive_cmdread_reply(NBDClientSession *s, uint64_t handle,
return iter.ret; return iter.ret;
} }
static int nbd_co_receive_blockstatus_reply(NBDClientSession *s, static int nbd_co_receive_blockstatus_reply(BDRVNBDState *s,
uint64_t handle, uint64_t length, uint64_t handle, uint64_t length,
NBDExtent *extent, NBDExtent *extent,
int *request_ret, Error **errp) int *request_ret, Error **errp)
@ -907,7 +898,7 @@ static int nbd_co_request(BlockDriverState *bs, NBDRequest *request,
{ {
int ret, request_ret; int ret, request_ret;
Error *local_err = NULL; Error *local_err = NULL;
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
assert(request->type != NBD_CMD_READ); assert(request->type != NBD_CMD_READ);
if (write_qiov) { if (write_qiov) {
@ -921,7 +912,7 @@ static int nbd_co_request(BlockDriverState *bs, NBDRequest *request,
return ret; return ret;
} }
ret = nbd_co_receive_return_code(client, request->handle, ret = nbd_co_receive_return_code(s, request->handle,
&request_ret, &local_err); &request_ret, &local_err);
if (local_err) { if (local_err) {
trace_nbd_co_request_fail(request->from, request->len, request->handle, trace_nbd_co_request_fail(request->from, request->len, request->handle,
@ -938,7 +929,7 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
{ {
int ret, request_ret; int ret, request_ret;
Error *local_err = NULL; Error *local_err = NULL;
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
NBDRequest request = { NBDRequest request = {
.type = NBD_CMD_READ, .type = NBD_CMD_READ,
.from = offset, .from = offset,
@ -957,13 +948,13 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
* advertised size because the block layer rounded size up, then * advertised size because the block layer rounded size up, then
* truncate the request to the server and tail-pad with zero. * truncate the request to the server and tail-pad with zero.
*/ */
if (offset >= client->info.size) { if (offset >= s->info.size) {
assert(bytes < BDRV_SECTOR_SIZE); assert(bytes < BDRV_SECTOR_SIZE);
qemu_iovec_memset(qiov, 0, 0, bytes); qemu_iovec_memset(qiov, 0, 0, bytes);
return 0; return 0;
} }
if (offset + bytes > client->info.size) { if (offset + bytes > s->info.size) {
uint64_t slop = offset + bytes - client->info.size; uint64_t slop = offset + bytes - s->info.size;
assert(slop < BDRV_SECTOR_SIZE); assert(slop < BDRV_SECTOR_SIZE);
qemu_iovec_memset(qiov, bytes - slop, 0, slop); qemu_iovec_memset(qiov, bytes - slop, 0, slop);
@ -975,7 +966,7 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
return ret; return ret;
} }
ret = nbd_co_receive_cmdread_reply(client, request.handle, offset, qiov, ret = nbd_co_receive_cmdread_reply(s, request.handle, offset, qiov,
&request_ret, &local_err); &request_ret, &local_err);
if (local_err) { if (local_err) {
trace_nbd_co_request_fail(request.from, request.len, request.handle, trace_nbd_co_request_fail(request.from, request.len, request.handle,
@ -990,16 +981,16 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
static int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset, static int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov, int flags) uint64_t bytes, QEMUIOVector *qiov, int flags)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
NBDRequest request = { NBDRequest request = {
.type = NBD_CMD_WRITE, .type = NBD_CMD_WRITE,
.from = offset, .from = offset,
.len = bytes, .len = bytes,
}; };
assert(!(client->info.flags & NBD_FLAG_READ_ONLY)); assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
if (flags & BDRV_REQ_FUA) { if (flags & BDRV_REQ_FUA) {
assert(client->info.flags & NBD_FLAG_SEND_FUA); assert(s->info.flags & NBD_FLAG_SEND_FUA);
request.flags |= NBD_CMD_FLAG_FUA; request.flags |= NBD_CMD_FLAG_FUA;
} }
@ -1014,20 +1005,20 @@ static int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
static int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, static int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
int bytes, BdrvRequestFlags flags) int bytes, BdrvRequestFlags flags)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
NBDRequest request = { NBDRequest request = {
.type = NBD_CMD_WRITE_ZEROES, .type = NBD_CMD_WRITE_ZEROES,
.from = offset, .from = offset,
.len = bytes, .len = bytes,
}; };
assert(!(client->info.flags & NBD_FLAG_READ_ONLY)); assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
if (!(client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) { if (!(s->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) {
return -ENOTSUP; return -ENOTSUP;
} }
if (flags & BDRV_REQ_FUA) { if (flags & BDRV_REQ_FUA) {
assert(client->info.flags & NBD_FLAG_SEND_FUA); assert(s->info.flags & NBD_FLAG_SEND_FUA);
request.flags |= NBD_CMD_FLAG_FUA; request.flags |= NBD_CMD_FLAG_FUA;
} }
if (!(flags & BDRV_REQ_MAY_UNMAP)) { if (!(flags & BDRV_REQ_MAY_UNMAP)) {
@ -1042,10 +1033,10 @@ static int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
static int nbd_client_co_flush(BlockDriverState *bs) static int nbd_client_co_flush(BlockDriverState *bs)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
NBDRequest request = { .type = NBD_CMD_FLUSH }; NBDRequest request = { .type = NBD_CMD_FLUSH };
if (!(client->info.flags & NBD_FLAG_SEND_FLUSH)) { if (!(s->info.flags & NBD_FLAG_SEND_FLUSH)) {
return 0; return 0;
} }
@ -1058,15 +1049,15 @@ static int nbd_client_co_flush(BlockDriverState *bs)
static int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, static int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset,
int bytes) int bytes)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
NBDRequest request = { NBDRequest request = {
.type = NBD_CMD_TRIM, .type = NBD_CMD_TRIM,
.from = offset, .from = offset,
.len = bytes, .len = bytes,
}; };
assert(!(client->info.flags & NBD_FLAG_READ_ONLY)); assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
if (!(client->info.flags & NBD_FLAG_SEND_TRIM) || !bytes) { if (!(s->info.flags & NBD_FLAG_SEND_TRIM) || !bytes) {
return 0; return 0;
} }
@ -1079,7 +1070,7 @@ static int coroutine_fn nbd_client_co_block_status(
{ {
int ret, request_ret; int ret, request_ret;
NBDExtent extent = { 0 }; NBDExtent extent = { 0 };
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
Error *local_err = NULL; Error *local_err = NULL;
NBDRequest request = { NBDRequest request = {
@ -1087,12 +1078,12 @@ static int coroutine_fn nbd_client_co_block_status(
.from = offset, .from = offset,
.len = MIN(MIN_NON_ZERO(QEMU_ALIGN_DOWN(INT_MAX, .len = MIN(MIN_NON_ZERO(QEMU_ALIGN_DOWN(INT_MAX,
bs->bl.request_alignment), bs->bl.request_alignment),
client->info.max_block), s->info.max_block),
MIN(bytes, client->info.size - offset)), MIN(bytes, s->info.size - offset)),
.flags = NBD_CMD_FLAG_REQ_ONE, .flags = NBD_CMD_FLAG_REQ_ONE,
}; };
if (!client->info.base_allocation) { if (!s->info.base_allocation) {
*pnum = bytes; *pnum = bytes;
*map = offset; *map = offset;
*file = bs; *file = bs;
@ -1106,22 +1097,22 @@ static int coroutine_fn nbd_client_co_block_status(
* up, we truncated the request to the server (above), or are * up, we truncated the request to the server (above), or are
* called on just the hole. * called on just the hole.
*/ */
if (offset >= client->info.size) { if (offset >= s->info.size) {
*pnum = bytes; *pnum = bytes;
assert(bytes < BDRV_SECTOR_SIZE); assert(bytes < BDRV_SECTOR_SIZE);
/* Intentionally don't report offset_valid for the hole */ /* Intentionally don't report offset_valid for the hole */
return BDRV_BLOCK_ZERO; return BDRV_BLOCK_ZERO;
} }
if (client->info.min_block) { if (s->info.min_block) {
assert(QEMU_IS_ALIGNED(request.len, client->info.min_block)); assert(QEMU_IS_ALIGNED(request.len, s->info.min_block));
} }
ret = nbd_co_send_request(bs, &request, NULL); ret = nbd_co_send_request(bs, &request, NULL);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = nbd_co_receive_blockstatus_reply(client, request.handle, bytes, ret = nbd_co_receive_blockstatus_reply(s, request.handle, bytes,
&extent, &request_ret, &local_err); &extent, &request_ret, &local_err);
if (local_err) { if (local_err) {
trace_nbd_co_request_fail(request.from, request.len, request.handle, trace_nbd_co_request_fail(request.from, request.len, request.handle,
@ -1145,12 +1136,12 @@ static int coroutine_fn nbd_client_co_block_status(
static void nbd_client_close(BlockDriverState *bs) static void nbd_client_close(BlockDriverState *bs)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
NBDRequest request = { .type = NBD_CMD_DISC }; NBDRequest request = { .type = NBD_CMD_DISC };
assert(client->ioc); assert(s->ioc);
nbd_send_request(client->ioc, &request); nbd_send_request(s->ioc, &request);
nbd_teardown_connection(bs); nbd_teardown_connection(bs);
} }
@ -1184,7 +1175,7 @@ static int nbd_client_connect(BlockDriverState *bs,
const char *x_dirty_bitmap, const char *x_dirty_bitmap,
Error **errp) Error **errp)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
int ret; int ret;
/* /*
@ -1201,44 +1192,44 @@ static int nbd_client_connect(BlockDriverState *bs,
trace_nbd_client_connect(export); trace_nbd_client_connect(export);
qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL); qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL);
client->info.request_sizes = true; s->info.request_sizes = true;
client->info.structured_reply = true; s->info.structured_reply = true;
client->info.base_allocation = true; s->info.base_allocation = true;
client->info.x_dirty_bitmap = g_strdup(x_dirty_bitmap); s->info.x_dirty_bitmap = g_strdup(x_dirty_bitmap);
client->info.name = g_strdup(export ?: ""); s->info.name = g_strdup(export ?: "");
ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), tlscreds, hostname, ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), tlscreds, hostname,
&client->ioc, &client->info, errp); &s->ioc, &s->info, errp);
g_free(client->info.x_dirty_bitmap); g_free(s->info.x_dirty_bitmap);
g_free(client->info.name); g_free(s->info.name);
if (ret < 0) { if (ret < 0) {
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
return ret; return ret;
} }
if (x_dirty_bitmap && !client->info.base_allocation) { if (x_dirty_bitmap && !s->info.base_allocation) {
error_setg(errp, "requested x-dirty-bitmap %s not found", error_setg(errp, "requested x-dirty-bitmap %s not found",
x_dirty_bitmap); x_dirty_bitmap);
ret = -EINVAL; ret = -EINVAL;
goto fail; goto fail;
} }
if (client->info.flags & NBD_FLAG_READ_ONLY) { if (s->info.flags & NBD_FLAG_READ_ONLY) {
ret = bdrv_apply_auto_read_only(bs, "NBD export is read-only", errp); ret = bdrv_apply_auto_read_only(bs, "NBD export is read-only", errp);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;
} }
} }
if (client->info.flags & NBD_FLAG_SEND_FUA) { if (s->info.flags & NBD_FLAG_SEND_FUA) {
bs->supported_write_flags = BDRV_REQ_FUA; bs->supported_write_flags = BDRV_REQ_FUA;
bs->supported_zero_flags |= BDRV_REQ_FUA; bs->supported_zero_flags |= BDRV_REQ_FUA;
} }
if (client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) { if (s->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) {
bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP; bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP;
} }
client->sioc = sioc; s->sioc = sioc;
if (!client->ioc) { if (!s->ioc) {
client->ioc = QIO_CHANNEL(sioc); s->ioc = QIO_CHANNEL(sioc);
object_ref(OBJECT(client->ioc)); object_ref(OBJECT(s->ioc));
} }
/* /*
@ -1246,7 +1237,7 @@ static int nbd_client_connect(BlockDriverState *bs,
* kick the reply mechanism. * kick the reply mechanism.
*/ */
qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL); qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
client->connection_co = qemu_coroutine_create(nbd_connection_entry, client); s->connection_co = qemu_coroutine_create(nbd_connection_entry, s);
bdrv_inc_in_flight(bs); bdrv_inc_in_flight(bs);
nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs)); nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
@ -1263,7 +1254,7 @@ static int nbd_client_connect(BlockDriverState *bs,
{ {
NBDRequest request = { .type = NBD_CMD_DISC }; NBDRequest request = { .type = NBD_CMD_DISC };
nbd_send_request(client->ioc ?: QIO_CHANNEL(sioc), &request); nbd_send_request(s->ioc ?: QIO_CHANNEL(sioc), &request);
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
@ -1279,11 +1270,11 @@ static int nbd_client_init(BlockDriverState *bs,
const char *x_dirty_bitmap, const char *x_dirty_bitmap,
Error **errp) Error **errp)
{ {
NBDClientSession *client = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
client->bs = bs; s->bs = bs;
qemu_co_mutex_init(&client->send_mutex); qemu_co_mutex_init(&s->send_mutex);
qemu_co_queue_init(&client->free_sema); qemu_co_queue_init(&s->free_sema);
return nbd_client_connect(bs, saddr, export, tlscreds, hostname, return nbd_client_connect(bs, saddr, export, tlscreds, hostname,
x_dirty_bitmap, errp); x_dirty_bitmap, errp);
@ -1665,7 +1656,7 @@ static int nbd_co_flush(BlockDriverState *bs)
static void nbd_refresh_limits(BlockDriverState *bs, Error **errp) static void nbd_refresh_limits(BlockDriverState *bs, Error **errp)
{ {
NBDClientSession *s = nbd_get_client_session(bs); BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
uint32_t min = s->info.min_block; uint32_t min = s->info.min_block;
uint32_t max = MIN_NON_ZERO(NBD_MAX_BUFFER_SIZE, s->info.max_block); uint32_t max = MIN_NON_ZERO(NBD_MAX_BUFFER_SIZE, s->info.max_block);
@ -1712,7 +1703,7 @@ static int64_t nbd_getlength(BlockDriverState *bs)
{ {
BDRVNBDState *s = bs->opaque; BDRVNBDState *s = bs->opaque;
return s->client.info.size; return s->info.size;
} }
static void nbd_refresh_filename(BlockDriverState *bs) static void nbd_refresh_filename(BlockDriverState *bs)