block/nbd-client: refactor nbd_co_receive_reply
[qemu.git] / block / nbd-client.c
1 /*
2 * QEMU Block driver for NBD
3 *
4 * Copyright (C) 2016 Red Hat, Inc.
5 * Copyright (C) 2008 Bull S.A.S.
6 * Author: Laurent Vivier <Laurent.Vivier@bull.net>
7 *
8 * Some parts:
9 * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this software and associated documentation files (the "Software"), to deal
13 * in the Software without restriction, including without limitation the rights
14 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 * copies of the Software, and to permit persons to whom the Software is
16 * furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
27 * THE SOFTWARE.
28 */
29
30 #include "qemu/osdep.h"
31 #include "qapi/error.h"
32 #include "nbd-client.h"
33
34 #define HANDLE_TO_INDEX(bs, handle) ((handle) ^ (uint64_t)(intptr_t)(bs))
35 #define INDEX_TO_HANDLE(bs, index) ((index) ^ (uint64_t)(intptr_t)(bs))
36
37 static void nbd_recv_coroutines_wake_all(NBDClientSession *s)
38 {
39 int i;
40
41 for (i = 0; i < MAX_NBD_REQUESTS; i++) {
42 NBDClientRequest *req = &s->requests[i];
43
44 if (req->coroutine && req->receiving) {
45 aio_co_wake(req->coroutine);
46 }
47 }
48 }
49
50 static void nbd_teardown_connection(BlockDriverState *bs)
51 {
52 NBDClientSession *client = nbd_get_client_session(bs);
53
54 if (!client->ioc) { /* Already closed */
55 return;
56 }
57
58 /* finish any pending coroutines */
59 qio_channel_shutdown(client->ioc,
60 QIO_CHANNEL_SHUTDOWN_BOTH,
61 NULL);
62 BDRV_POLL_WHILE(bs, client->read_reply_co);
63
64 nbd_client_detach_aio_context(bs);
65 object_unref(OBJECT(client->sioc));
66 client->sioc = NULL;
67 object_unref(OBJECT(client->ioc));
68 client->ioc = NULL;
69 }
70
71 static coroutine_fn void nbd_read_reply_entry(void *opaque)
72 {
73 NBDClientSession *s = opaque;
74 uint64_t i;
75 int ret = 0;
76 Error *local_err = NULL;
77
78 while (!s->quit) {
79 assert(s->reply.handle == 0);
80 ret = nbd_receive_reply(s->ioc, &s->reply, &local_err);
81 if (ret < 0) {
82 error_report_err(local_err);
83 }
84 if (ret <= 0) {
85 break;
86 }
87
88 /* There's no need for a mutex on the receive side, because the
89 * handler acts as a synchronization point and ensures that only
90 * one coroutine is called until the reply finishes.
91 */
92 i = HANDLE_TO_INDEX(s, s->reply.handle);
93 if (i >= MAX_NBD_REQUESTS ||
94 !s->requests[i].coroutine ||
95 !s->requests[i].receiving) {
96 break;
97 }
98
99 /* We're woken up again by the request itself. Note that there
100 * is no race between yielding and reentering read_reply_co. This
101 * is because:
102 *
103 * - if the request runs on the same AioContext, it is only
104 * entered after we yield
105 *
106 * - if the request runs on a different AioContext, reentering
107 * read_reply_co happens through a bottom half, which can only
108 * run after we yield.
109 */
110 aio_co_wake(s->requests[i].coroutine);
111 qemu_coroutine_yield();
112 }
113
114 s->quit = true;
115 nbd_recv_coroutines_wake_all(s);
116 s->read_reply_co = NULL;
117 }
118
119 static int nbd_co_send_request(BlockDriverState *bs,
120 NBDRequest *request,
121 QEMUIOVector *qiov)
122 {
123 NBDClientSession *s = nbd_get_client_session(bs);
124 int rc, i;
125
126 qemu_co_mutex_lock(&s->send_mutex);
127 while (s->in_flight == MAX_NBD_REQUESTS) {
128 qemu_co_queue_wait(&s->free_sema, &s->send_mutex);
129 }
130 s->in_flight++;
131
132 for (i = 0; i < MAX_NBD_REQUESTS; i++) {
133 if (s->requests[i].coroutine == NULL) {
134 break;
135 }
136 }
137
138 g_assert(qemu_in_coroutine());
139 assert(i < MAX_NBD_REQUESTS);
140
141 s->requests[i].coroutine = qemu_coroutine_self();
142 s->requests[i].receiving = false;
143
144 request->handle = INDEX_TO_HANDLE(s, i);
145
146 if (s->quit) {
147 rc = -EIO;
148 goto err;
149 }
150 if (!s->ioc) {
151 rc = -EPIPE;
152 goto err;
153 }
154
155 if (qiov) {
156 qio_channel_set_cork(s->ioc, true);
157 rc = nbd_send_request(s->ioc, request);
158 if (rc >= 0 && !s->quit) {
159 if (qio_channel_writev_all(s->ioc, qiov->iov, qiov->niov,
160 NULL) < 0) {
161 rc = -EIO;
162 }
163 } else if (rc >= 0) {
164 rc = -EIO;
165 }
166 qio_channel_set_cork(s->ioc, false);
167 } else {
168 rc = nbd_send_request(s->ioc, request);
169 }
170
171 err:
172 if (rc < 0) {
173 s->quit = true;
174 s->requests[i].coroutine = NULL;
175 s->in_flight--;
176 qemu_co_queue_next(&s->free_sema);
177 }
178 qemu_co_mutex_unlock(&s->send_mutex);
179 return rc;
180 }
181
182 static int nbd_co_receive_reply(NBDClientSession *s,
183 uint64_t handle,
184 QEMUIOVector *qiov)
185 {
186 int ret;
187 int i = HANDLE_TO_INDEX(s, handle);
188
189 /* Wait until we're woken up by nbd_read_reply_entry. */
190 s->requests[i].receiving = true;
191 qemu_coroutine_yield();
192 s->requests[i].receiving = false;
193 if (!s->ioc || s->quit) {
194 ret = -EIO;
195 } else {
196 assert(s->reply.handle == handle);
197 ret = -s->reply.error;
198 if (qiov && s->reply.error == 0) {
199 if (qio_channel_readv_all(s->ioc, qiov->iov, qiov->niov,
200 NULL) < 0) {
201 ret = -EIO;
202 s->quit = true;
203 }
204 }
205
206 /* Tell the read handler to read another header. */
207 s->reply.handle = 0;
208 }
209
210 s->requests[i].coroutine = NULL;
211
212 /* Kick the read_reply_co to get the next reply. */
213 if (s->read_reply_co) {
214 aio_co_wake(s->read_reply_co);
215 }
216
217 qemu_co_mutex_lock(&s->send_mutex);
218 s->in_flight--;
219 qemu_co_queue_next(&s->free_sema);
220 qemu_co_mutex_unlock(&s->send_mutex);
221
222 return ret;
223 }
224
225 static int nbd_co_request(BlockDriverState *bs,
226 NBDRequest *request,
227 QEMUIOVector *qiov)
228 {
229 NBDClientSession *client = nbd_get_client_session(bs);
230 int ret;
231
232 if (qiov) {
233 assert(request->type == NBD_CMD_WRITE || request->type == NBD_CMD_READ);
234 assert(request->len == iov_size(qiov->iov, qiov->niov));
235 } else {
236 assert(request->type != NBD_CMD_WRITE && request->type != NBD_CMD_READ);
237 }
238 ret = nbd_co_send_request(bs, request,
239 request->type == NBD_CMD_WRITE ? qiov : NULL);
240 if (ret < 0) {
241 return ret;
242 }
243
244 return nbd_co_receive_reply(client, request->handle,
245 request->type == NBD_CMD_READ ? qiov : NULL);
246 }
247
248 int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
249 uint64_t bytes, QEMUIOVector *qiov, int flags)
250 {
251 NBDRequest request = {
252 .type = NBD_CMD_READ,
253 .from = offset,
254 .len = bytes,
255 };
256
257 assert(bytes <= NBD_MAX_BUFFER_SIZE);
258 assert(!flags);
259
260 return nbd_co_request(bs, &request, qiov);
261 }
262
263 int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
264 uint64_t bytes, QEMUIOVector *qiov, int flags)
265 {
266 NBDClientSession *client = nbd_get_client_session(bs);
267 NBDRequest request = {
268 .type = NBD_CMD_WRITE,
269 .from = offset,
270 .len = bytes,
271 };
272
273 if (flags & BDRV_REQ_FUA) {
274 assert(client->info.flags & NBD_FLAG_SEND_FUA);
275 request.flags |= NBD_CMD_FLAG_FUA;
276 }
277
278 assert(bytes <= NBD_MAX_BUFFER_SIZE);
279
280 return nbd_co_request(bs, &request, qiov);
281 }
282
283 int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
284 int bytes, BdrvRequestFlags flags)
285 {
286 NBDClientSession *client = nbd_get_client_session(bs);
287 NBDRequest request = {
288 .type = NBD_CMD_WRITE_ZEROES,
289 .from = offset,
290 .len = bytes,
291 };
292
293 if (!(client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) {
294 return -ENOTSUP;
295 }
296
297 if (flags & BDRV_REQ_FUA) {
298 assert(client->info.flags & NBD_FLAG_SEND_FUA);
299 request.flags |= NBD_CMD_FLAG_FUA;
300 }
301 if (!(flags & BDRV_REQ_MAY_UNMAP)) {
302 request.flags |= NBD_CMD_FLAG_NO_HOLE;
303 }
304
305 return nbd_co_request(bs, &request, NULL);
306 }
307
308 int nbd_client_co_flush(BlockDriverState *bs)
309 {
310 NBDClientSession *client = nbd_get_client_session(bs);
311 NBDRequest request = { .type = NBD_CMD_FLUSH };
312
313 if (!(client->info.flags & NBD_FLAG_SEND_FLUSH)) {
314 return 0;
315 }
316
317 request.from = 0;
318 request.len = 0;
319
320 return nbd_co_request(bs, &request, NULL);
321 }
322
323 int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
324 {
325 NBDClientSession *client = nbd_get_client_session(bs);
326 NBDRequest request = {
327 .type = NBD_CMD_TRIM,
328 .from = offset,
329 .len = bytes,
330 };
331
332 if (!(client->info.flags & NBD_FLAG_SEND_TRIM)) {
333 return 0;
334 }
335
336 return nbd_co_request(bs, &request, NULL);
337 }
338
339 void nbd_client_detach_aio_context(BlockDriverState *bs)
340 {
341 NBDClientSession *client = nbd_get_client_session(bs);
342 qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc));
343 }
344
345 void nbd_client_attach_aio_context(BlockDriverState *bs,
346 AioContext *new_context)
347 {
348 NBDClientSession *client = nbd_get_client_session(bs);
349 qio_channel_attach_aio_context(QIO_CHANNEL(client->ioc), new_context);
350 aio_co_schedule(new_context, client->read_reply_co);
351 }
352
353 void nbd_client_close(BlockDriverState *bs)
354 {
355 NBDClientSession *client = nbd_get_client_session(bs);
356 NBDRequest request = { .type = NBD_CMD_DISC };
357
358 if (client->ioc == NULL) {
359 return;
360 }
361
362 nbd_send_request(client->ioc, &request);
363
364 nbd_teardown_connection(bs);
365 }
366
367 int nbd_client_init(BlockDriverState *bs,
368 QIOChannelSocket *sioc,
369 const char *export,
370 QCryptoTLSCreds *tlscreds,
371 const char *hostname,
372 Error **errp)
373 {
374 NBDClientSession *client = nbd_get_client_session(bs);
375 int ret;
376
377 /* NBD handshake */
378 logout("session init %s\n", export);
379 qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL);
380
381 client->info.request_sizes = true;
382 ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), export,
383 tlscreds, hostname,
384 &client->ioc, &client->info, errp);
385 if (ret < 0) {
386 logout("Failed to negotiate with the NBD server\n");
387 return ret;
388 }
389 if (client->info.flags & NBD_FLAG_SEND_FUA) {
390 bs->supported_write_flags = BDRV_REQ_FUA;
391 bs->supported_zero_flags |= BDRV_REQ_FUA;
392 }
393 if (client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) {
394 bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP;
395 }
396 if (client->info.min_block > bs->bl.request_alignment) {
397 bs->bl.request_alignment = client->info.min_block;
398 }
399
400 qemu_co_mutex_init(&client->send_mutex);
401 qemu_co_queue_init(&client->free_sema);
402 client->sioc = sioc;
403 object_ref(OBJECT(client->sioc));
404
405 if (!client->ioc) {
406 client->ioc = QIO_CHANNEL(sioc);
407 object_ref(OBJECT(client->ioc));
408 }
409
410 /* Now that we're connected, set the socket to be non-blocking and
411 * kick the reply mechanism. */
412 qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
413 client->read_reply_co = qemu_coroutine_create(nbd_read_reply_entry, client);
414 nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
415
416 logout("Established connection with NBD server\n");
417 return 0;
418 }