aio: add AioPollFn and io_poll() interface
[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 "nbd-client.h"
32
33 #define HANDLE_TO_INDEX(bs, handle) ((handle) ^ ((uint64_t)(intptr_t)bs))
34 #define INDEX_TO_HANDLE(bs, index) ((index) ^ ((uint64_t)(intptr_t)bs))
35
36 static void nbd_recv_coroutines_enter_all(NBDClientSession *s)
37 {
38 int i;
39
40 for (i = 0; i < MAX_NBD_REQUESTS; i++) {
41 if (s->recv_coroutine[i]) {
42 qemu_coroutine_enter(s->recv_coroutine[i]);
43 }
44 }
45 }
46
47 static void nbd_teardown_connection(BlockDriverState *bs)
48 {
49 NBDClientSession *client = nbd_get_client_session(bs);
50
51 if (!client->ioc) { /* Already closed */
52 return;
53 }
54
55 /* finish any pending coroutines */
56 qio_channel_shutdown(client->ioc,
57 QIO_CHANNEL_SHUTDOWN_BOTH,
58 NULL);
59 nbd_recv_coroutines_enter_all(client);
60
61 nbd_client_detach_aio_context(bs);
62 object_unref(OBJECT(client->sioc));
63 client->sioc = NULL;
64 object_unref(OBJECT(client->ioc));
65 client->ioc = NULL;
66 }
67
68 static void nbd_reply_ready(void *opaque)
69 {
70 BlockDriverState *bs = opaque;
71 NBDClientSession *s = nbd_get_client_session(bs);
72 uint64_t i;
73 int ret;
74
75 if (!s->ioc) { /* Already closed */
76 return;
77 }
78
79 if (s->reply.handle == 0) {
80 /* No reply already in flight. Fetch a header. It is possible
81 * that another thread has done the same thing in parallel, so
82 * the socket is not readable anymore.
83 */
84 ret = nbd_receive_reply(s->ioc, &s->reply);
85 if (ret == -EAGAIN) {
86 return;
87 }
88 if (ret < 0) {
89 s->reply.handle = 0;
90 goto fail;
91 }
92 }
93
94 /* There's no need for a mutex on the receive side, because the
95 * handler acts as a synchronization point and ensures that only
96 * one coroutine is called until the reply finishes. */
97 i = HANDLE_TO_INDEX(s, s->reply.handle);
98 if (i >= MAX_NBD_REQUESTS) {
99 goto fail;
100 }
101
102 if (s->recv_coroutine[i]) {
103 qemu_coroutine_enter(s->recv_coroutine[i]);
104 return;
105 }
106
107 fail:
108 nbd_teardown_connection(bs);
109 }
110
111 static void nbd_restart_write(void *opaque)
112 {
113 BlockDriverState *bs = opaque;
114
115 qemu_coroutine_enter(nbd_get_client_session(bs)->send_coroutine);
116 }
117
118 static int nbd_co_send_request(BlockDriverState *bs,
119 NBDRequest *request,
120 QEMUIOVector *qiov)
121 {
122 NBDClientSession *s = nbd_get_client_session(bs);
123 AioContext *aio_context;
124 int rc, ret, i;
125
126 qemu_co_mutex_lock(&s->send_mutex);
127
128 for (i = 0; i < MAX_NBD_REQUESTS; i++) {
129 if (s->recv_coroutine[i] == NULL) {
130 s->recv_coroutine[i] = qemu_coroutine_self();
131 break;
132 }
133 }
134
135 g_assert(qemu_in_coroutine());
136 assert(i < MAX_NBD_REQUESTS);
137 request->handle = INDEX_TO_HANDLE(s, i);
138
139 if (!s->ioc) {
140 qemu_co_mutex_unlock(&s->send_mutex);
141 return -EPIPE;
142 }
143
144 s->send_coroutine = qemu_coroutine_self();
145 aio_context = bdrv_get_aio_context(bs);
146
147 aio_set_fd_handler(aio_context, s->sioc->fd, false,
148 nbd_reply_ready, nbd_restart_write, NULL, bs);
149 if (qiov) {
150 qio_channel_set_cork(s->ioc, true);
151 rc = nbd_send_request(s->ioc, request);
152 if (rc >= 0) {
153 ret = nbd_wr_syncv(s->ioc, qiov->iov, qiov->niov, request->len,
154 false);
155 if (ret != request->len) {
156 rc = -EIO;
157 }
158 }
159 qio_channel_set_cork(s->ioc, false);
160 } else {
161 rc = nbd_send_request(s->ioc, request);
162 }
163 aio_set_fd_handler(aio_context, s->sioc->fd, false,
164 nbd_reply_ready, NULL, NULL, bs);
165 s->send_coroutine = NULL;
166 qemu_co_mutex_unlock(&s->send_mutex);
167 return rc;
168 }
169
170 static void nbd_co_receive_reply(NBDClientSession *s,
171 NBDRequest *request,
172 NBDReply *reply,
173 QEMUIOVector *qiov)
174 {
175 int ret;
176
177 /* Wait until we're woken up by the read handler. TODO: perhaps
178 * peek at the next reply and avoid yielding if it's ours? */
179 qemu_coroutine_yield();
180 *reply = s->reply;
181 if (reply->handle != request->handle ||
182 !s->ioc) {
183 reply->error = EIO;
184 } else {
185 if (qiov && reply->error == 0) {
186 ret = nbd_wr_syncv(s->ioc, qiov->iov, qiov->niov, request->len,
187 true);
188 if (ret != request->len) {
189 reply->error = EIO;
190 }
191 }
192
193 /* Tell the read handler to read another header. */
194 s->reply.handle = 0;
195 }
196 }
197
198 static void nbd_coroutine_start(NBDClientSession *s,
199 NBDRequest *request)
200 {
201 /* Poor man semaphore. The free_sema is locked when no other request
202 * can be accepted, and unlocked after receiving one reply. */
203 if (s->in_flight == MAX_NBD_REQUESTS) {
204 qemu_co_queue_wait(&s->free_sema);
205 assert(s->in_flight < MAX_NBD_REQUESTS);
206 }
207 s->in_flight++;
208
209 /* s->recv_coroutine[i] is set as soon as we get the send_lock. */
210 }
211
212 static void nbd_coroutine_end(NBDClientSession *s,
213 NBDRequest *request)
214 {
215 int i = HANDLE_TO_INDEX(s, request->handle);
216 s->recv_coroutine[i] = NULL;
217 if (s->in_flight-- == MAX_NBD_REQUESTS) {
218 qemu_co_queue_next(&s->free_sema);
219 }
220 }
221
222 int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
223 uint64_t bytes, QEMUIOVector *qiov, int flags)
224 {
225 NBDClientSession *client = nbd_get_client_session(bs);
226 NBDRequest request = {
227 .type = NBD_CMD_READ,
228 .from = offset,
229 .len = bytes,
230 };
231 NBDReply reply;
232 ssize_t ret;
233
234 assert(bytes <= NBD_MAX_BUFFER_SIZE);
235 assert(!flags);
236
237 nbd_coroutine_start(client, &request);
238 ret = nbd_co_send_request(bs, &request, NULL);
239 if (ret < 0) {
240 reply.error = -ret;
241 } else {
242 nbd_co_receive_reply(client, &request, &reply, qiov);
243 }
244 nbd_coroutine_end(client, &request);
245 return -reply.error;
246 }
247
248 int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
249 uint64_t bytes, QEMUIOVector *qiov, int flags)
250 {
251 NBDClientSession *client = nbd_get_client_session(bs);
252 NBDRequest request = {
253 .type = NBD_CMD_WRITE,
254 .from = offset,
255 .len = bytes,
256 };
257 NBDReply reply;
258 ssize_t ret;
259
260 if (flags & BDRV_REQ_FUA) {
261 assert(client->nbdflags & NBD_FLAG_SEND_FUA);
262 request.flags |= NBD_CMD_FLAG_FUA;
263 }
264
265 assert(bytes <= NBD_MAX_BUFFER_SIZE);
266
267 nbd_coroutine_start(client, &request);
268 ret = nbd_co_send_request(bs, &request, qiov);
269 if (ret < 0) {
270 reply.error = -ret;
271 } else {
272 nbd_co_receive_reply(client, &request, &reply, NULL);
273 }
274 nbd_coroutine_end(client, &request);
275 return -reply.error;
276 }
277
278 int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
279 int count, BdrvRequestFlags flags)
280 {
281 ssize_t ret;
282 NBDClientSession *client = nbd_get_client_session(bs);
283 NBDRequest request = {
284 .type = NBD_CMD_WRITE_ZEROES,
285 .from = offset,
286 .len = count,
287 };
288 NBDReply reply;
289
290 if (!(client->nbdflags & NBD_FLAG_SEND_WRITE_ZEROES)) {
291 return -ENOTSUP;
292 }
293
294 if (flags & BDRV_REQ_FUA) {
295 assert(client->nbdflags & NBD_FLAG_SEND_FUA);
296 request.flags |= NBD_CMD_FLAG_FUA;
297 }
298 if (!(flags & BDRV_REQ_MAY_UNMAP)) {
299 request.flags |= NBD_CMD_FLAG_NO_HOLE;
300 }
301
302 nbd_coroutine_start(client, &request);
303 ret = nbd_co_send_request(bs, &request, NULL);
304 if (ret < 0) {
305 reply.error = -ret;
306 } else {
307 nbd_co_receive_reply(client, &request, &reply, NULL);
308 }
309 nbd_coroutine_end(client, &request);
310 return -reply.error;
311 }
312
313 int nbd_client_co_flush(BlockDriverState *bs)
314 {
315 NBDClientSession *client = nbd_get_client_session(bs);
316 NBDRequest request = { .type = NBD_CMD_FLUSH };
317 NBDReply reply;
318 ssize_t ret;
319
320 if (!(client->nbdflags & NBD_FLAG_SEND_FLUSH)) {
321 return 0;
322 }
323
324 request.from = 0;
325 request.len = 0;
326
327 nbd_coroutine_start(client, &request);
328 ret = nbd_co_send_request(bs, &request, NULL);
329 if (ret < 0) {
330 reply.error = -ret;
331 } else {
332 nbd_co_receive_reply(client, &request, &reply, NULL);
333 }
334 nbd_coroutine_end(client, &request);
335 return -reply.error;
336 }
337
338 int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
339 {
340 NBDClientSession *client = nbd_get_client_session(bs);
341 NBDRequest request = {
342 .type = NBD_CMD_TRIM,
343 .from = offset,
344 .len = count,
345 };
346 NBDReply reply;
347 ssize_t ret;
348
349 if (!(client->nbdflags & NBD_FLAG_SEND_TRIM)) {
350 return 0;
351 }
352
353 nbd_coroutine_start(client, &request);
354 ret = nbd_co_send_request(bs, &request, NULL);
355 if (ret < 0) {
356 reply.error = -ret;
357 } else {
358 nbd_co_receive_reply(client, &request, &reply, NULL);
359 }
360 nbd_coroutine_end(client, &request);
361 return -reply.error;
362
363 }
364
365 void nbd_client_detach_aio_context(BlockDriverState *bs)
366 {
367 aio_set_fd_handler(bdrv_get_aio_context(bs),
368 nbd_get_client_session(bs)->sioc->fd,
369 false, NULL, NULL, NULL, NULL);
370 }
371
372 void nbd_client_attach_aio_context(BlockDriverState *bs,
373 AioContext *new_context)
374 {
375 aio_set_fd_handler(new_context, nbd_get_client_session(bs)->sioc->fd,
376 false, nbd_reply_ready, NULL, NULL, bs);
377 }
378
379 void nbd_client_close(BlockDriverState *bs)
380 {
381 NBDClientSession *client = nbd_get_client_session(bs);
382 NBDRequest request = { .type = NBD_CMD_DISC };
383
384 if (client->ioc == NULL) {
385 return;
386 }
387
388 nbd_send_request(client->ioc, &request);
389
390 nbd_teardown_connection(bs);
391 }
392
393 int nbd_client_init(BlockDriverState *bs,
394 QIOChannelSocket *sioc,
395 const char *export,
396 QCryptoTLSCreds *tlscreds,
397 const char *hostname,
398 Error **errp)
399 {
400 NBDClientSession *client = nbd_get_client_session(bs);
401 int ret;
402
403 /* NBD handshake */
404 logout("session init %s\n", export);
405 qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL);
406
407 ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), export,
408 &client->nbdflags,
409 tlscreds, hostname,
410 &client->ioc,
411 &client->size, errp);
412 if (ret < 0) {
413 logout("Failed to negotiate with the NBD server\n");
414 return ret;
415 }
416 if (client->nbdflags & NBD_FLAG_SEND_FUA) {
417 bs->supported_write_flags = BDRV_REQ_FUA;
418 bs->supported_zero_flags |= BDRV_REQ_FUA;
419 }
420 if (client->nbdflags & NBD_FLAG_SEND_WRITE_ZEROES) {
421 bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP;
422 }
423
424 qemu_co_mutex_init(&client->send_mutex);
425 qemu_co_queue_init(&client->free_sema);
426 client->sioc = sioc;
427 object_ref(OBJECT(client->sioc));
428
429 if (!client->ioc) {
430 client->ioc = QIO_CHANNEL(sioc);
431 object_ref(OBJECT(client->ioc));
432 }
433
434 /* Now that we're connected, set the socket to be non-blocking and
435 * kick the reply mechanism. */
436 qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
437
438 nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
439
440 logout("Established connection with NBD server\n");
441 return 0;
442 }