Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : : #include "spdk/string.h"
8 : :
9 : : #include <linux/nbd.h>
10 : :
11 : : #include "spdk/nbd.h"
12 : : #include "nbd_internal.h"
13 : : #include "spdk/bdev.h"
14 : : #include "spdk/endian.h"
15 : : #include "spdk/env.h"
16 : : #include "spdk/likely.h"
17 : : #include "spdk/log.h"
18 : : #include "spdk/util.h"
19 : : #include "spdk/thread.h"
20 : :
21 : : #include "spdk/queue.h"
22 : :
23 : : #define GET_IO_LOOP_COUNT 16
24 : : #define NBD_START_BUSY_WAITING_MS 1000
25 : : #define NBD_STOP_BUSY_WAITING_MS 10000
26 : : #define NBD_BUSY_POLLING_INTERVAL_US 20000
27 : : #define NBD_IO_TIMEOUT_S 60
28 : :
29 : : enum nbd_io_state_t {
30 : : /* Receiving or ready to receive nbd request header */
31 : : NBD_IO_RECV_REQ = 0,
32 : : /* Receiving write payload */
33 : : NBD_IO_RECV_PAYLOAD,
34 : : /* Transmitting or ready to transmit nbd response header */
35 : : NBD_IO_XMIT_RESP,
36 : : /* Transmitting read payload */
37 : : NBD_IO_XMIT_PAYLOAD,
38 : : };
39 : :
40 : : struct nbd_io {
41 : : struct spdk_nbd_disk *nbd;
42 : : enum nbd_io_state_t state;
43 : :
44 : : void *payload;
45 : : uint32_t payload_size;
46 : :
47 : : struct nbd_request req;
48 : : struct nbd_reply resp;
49 : :
50 : : /*
51 : : * Tracks current progress on reading/writing a request,
52 : : * response, or payload from the nbd socket.
53 : : */
54 : : uint32_t offset;
55 : :
56 : : /* for bdev io_wait */
57 : : struct spdk_bdev_io_wait_entry bdev_io_wait;
58 : :
59 : : TAILQ_ENTRY(nbd_io) tailq;
60 : : };
61 : :
62 : : struct spdk_nbd_disk {
63 : : struct spdk_bdev *bdev;
64 : : struct spdk_bdev_desc *bdev_desc;
65 : : struct spdk_io_channel *ch;
66 : : int dev_fd;
67 : : char *nbd_path;
68 : : int kernel_sp_fd;
69 : : int spdk_sp_fd;
70 : : struct spdk_poller *nbd_poller;
71 : : struct spdk_interrupt *intr;
72 : : bool interrupt_mode;
73 : : uint32_t buf_align;
74 : :
75 : : struct spdk_poller *retry_poller;
76 : : int retry_count;
77 : : /* Synchronize nbd_start_kernel pthread and nbd_stop */
78 : : bool has_nbd_pthread;
79 : :
80 : : struct nbd_io *io_in_recv;
81 : : TAILQ_HEAD(, nbd_io) received_io_list;
82 : : TAILQ_HEAD(, nbd_io) executed_io_list;
83 : : TAILQ_HEAD(, nbd_io) processing_io_list;
84 : :
85 : : bool is_started;
86 : : bool is_closing;
87 : : /* count of nbd_io in spdk_nbd_disk */
88 : : int io_count;
89 : :
90 : : TAILQ_ENTRY(spdk_nbd_disk) tailq;
91 : : };
92 : :
93 : : struct spdk_nbd_disk_globals {
94 : : TAILQ_HEAD(, spdk_nbd_disk) disk_head;
95 : : };
96 : :
97 : : static struct spdk_nbd_disk_globals g_spdk_nbd;
98 : : static spdk_nbd_fini_cb g_fini_cb_fn;
99 : : static void *g_fini_cb_arg;
100 : :
101 : : static void _nbd_fini(void *arg1);
102 : :
103 : : static int nbd_submit_bdev_io(struct spdk_nbd_disk *nbd, struct nbd_io *io);
104 : : static int nbd_io_recv_internal(struct spdk_nbd_disk *nbd);
105 : :
106 : : int
107 : 1179 : spdk_nbd_init(void)
108 : : {
109 [ + - ]: 1179 : TAILQ_INIT(&g_spdk_nbd.disk_head);
110 : :
111 : 1179 : return 0;
112 : : }
113 : :
114 : : static void
115 : 1179 : _nbd_fini(void *arg1)
116 : : {
117 : : struct spdk_nbd_disk *nbd, *nbd_tmp;
118 : :
119 [ + + # # : 1179 : TAILQ_FOREACH_SAFE(nbd, &g_spdk_nbd.disk_head, tailq, nbd_tmp) {
# # # # -
+ ]
120 [ # # # # : 0 : if (!nbd->is_closing) {
# # # # ]
121 : 0 : spdk_nbd_stop(nbd);
122 : 0 : }
123 : 0 : }
124 : :
125 : : /* Check if all nbds closed */
126 [ + - ]: 1179 : if (!TAILQ_FIRST(&g_spdk_nbd.disk_head)) {
127 [ - + + - ]: 1179 : g_fini_cb_fn(g_fini_cb_arg);
128 : 23 : } else {
129 : 0 : spdk_thread_send_msg(spdk_get_thread(),
130 : : _nbd_fini, NULL);
131 : : }
132 : 1179 : }
133 : :
134 : : void
135 : 1179 : spdk_nbd_fini(spdk_nbd_fini_cb cb_fn, void *cb_arg)
136 : : {
137 : 1179 : g_fini_cb_fn = cb_fn;
138 : 1179 : g_fini_cb_arg = cb_arg;
139 : :
140 : 1179 : _nbd_fini(NULL);
141 : 1179 : }
142 : :
143 : : static int
144 : 523 : nbd_disk_register(struct spdk_nbd_disk *nbd)
145 : : {
146 : : /* Make sure nbd_path is not used in this SPDK app */
147 [ + + + - : 523 : if (nbd_disk_find_by_nbd_path(nbd->nbd_path)) {
+ - ]
148 [ # # # # ]: 0 : SPDK_NOTICELOG("%s is already exported\n", nbd->nbd_path);
149 : 0 : return -EBUSY;
150 : : }
151 : :
152 [ + - + - : 523 : TAILQ_INSERT_TAIL(&g_spdk_nbd.disk_head, nbd, tailq);
+ - + - +
- + - + -
+ - + - +
- + - +
- ]
153 : :
154 : 523 : return 0;
155 : 6 : }
156 : :
157 : : static void
158 : 523 : nbd_disk_unregister(struct spdk_nbd_disk *nbd)
159 : : {
160 : : struct spdk_nbd_disk *nbd_idx, *nbd_tmp;
161 : :
162 : : /*
163 : : * nbd disk may be stopped before registered.
164 : : * check whether it was registered.
165 : : */
166 [ + + + - : 552 : TAILQ_FOREACH_SAFE(nbd_idx, &g_spdk_nbd.disk_head, tailq, nbd_tmp) {
+ - + - -
+ ]
167 [ + + ]: 552 : if (nbd == nbd_idx) {
168 [ + + + - : 523 : TAILQ_REMOVE(&g_spdk_nbd.disk_head, nbd_idx, tailq);
+ - + + +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - ]
169 : 523 : break;
170 : : }
171 : 0 : }
172 : 523 : }
173 : :
174 : : struct spdk_nbd_disk *
175 : 2643 : nbd_disk_find_by_nbd_path(const char *nbd_path)
176 : : {
177 : : struct spdk_nbd_disk *nbd;
178 : :
179 : : /*
180 : : * check whether nbd has already been registered by nbd path.
181 : : */
182 [ + + - + : 7473 : TAILQ_FOREACH(nbd, &g_spdk_nbd.disk_head, tailq) {
- + - + ]
183 [ + + + + : 6427 : if (!strcmp(nbd->nbd_path, nbd_path)) {
+ + + - +
+ ]
184 : 1597 : return nbd;
185 : : }
186 : 6 : }
187 : :
188 : 1046 : return NULL;
189 : 24 : }
190 : :
191 : 222 : struct spdk_nbd_disk *nbd_disk_first(void)
192 : : {
193 : 222 : return TAILQ_FIRST(&g_spdk_nbd.disk_head);
194 : : }
195 : :
196 : 348 : struct spdk_nbd_disk *nbd_disk_next(struct spdk_nbd_disk *prev)
197 : : {
198 [ + - + - : 348 : return TAILQ_NEXT(prev, tailq);
+ - ]
199 : : }
200 : :
201 : : const char *
202 : 348 : nbd_disk_get_nbd_path(struct spdk_nbd_disk *nbd)
203 : : {
204 [ + - + - ]: 348 : return nbd->nbd_path;
205 : : }
206 : :
207 : : const char *
208 : 348 : nbd_disk_get_bdev_name(struct spdk_nbd_disk *nbd)
209 : : {
210 [ + - + - ]: 348 : return spdk_bdev_get_name(nbd->bdev);
211 : : }
212 : :
213 : : void
214 : 81 : spdk_nbd_write_config_json(struct spdk_json_write_ctx *w)
215 : : {
216 : : struct spdk_nbd_disk *nbd;
217 : :
218 : 81 : spdk_json_write_array_begin(w);
219 : :
220 [ - + # # : 81 : TAILQ_FOREACH(nbd, &g_spdk_nbd.disk_head, tailq) {
# # # # ]
221 : 0 : spdk_json_write_object_begin(w);
222 : :
223 : 0 : spdk_json_write_named_string(w, "method", "nbd_start_disk");
224 : :
225 : 0 : spdk_json_write_named_object_begin(w, "params");
226 : 0 : spdk_json_write_named_string(w, "nbd_device", nbd_disk_get_nbd_path(nbd));
227 : 0 : spdk_json_write_named_string(w, "bdev_name", nbd_disk_get_bdev_name(nbd));
228 : 0 : spdk_json_write_object_end(w);
229 : :
230 : 0 : spdk_json_write_object_end(w);
231 : 0 : }
232 : :
233 : 81 : spdk_json_write_array_end(w);
234 : 81 : }
235 : :
236 : : void
237 : 522 : nbd_disconnect(struct spdk_nbd_disk *nbd)
238 : : {
239 : : /*
240 : : * nbd soft-disconnection to terminate transmission phase.
241 : : * After receiving this ioctl command, nbd kernel module will send
242 : : * a NBD_CMD_DISC type io to nbd server in order to inform server.
243 : : */
244 [ + - + - : 522 : ioctl(nbd->dev_fd, NBD_DISCONNECT);
+ - - + +
- - + + -
- + + - ]
245 : 522 : }
246 : :
247 : : static struct nbd_io *
248 : 2251787 : nbd_get_io(struct spdk_nbd_disk *nbd)
249 : : {
250 : : struct nbd_io *io;
251 : :
252 : 2251787 : io = calloc(1, sizeof(*io));
253 [ + + ]: 2251787 : if (!io) {
254 : 0 : return NULL;
255 : : }
256 : :
257 [ - + - + ]: 2251787 : io->nbd = nbd;
258 [ - + - + ]: 2251787 : to_be32(&io->resp.magic, NBD_REPLY_MAGIC);
259 : :
260 [ - + - + ]: 2251787 : nbd->io_count++;
261 : :
262 : 2251787 : return io;
263 : 2220 : }
264 : :
265 : : static void
266 : 2251787 : nbd_put_io(struct spdk_nbd_disk *nbd, struct nbd_io *io)
267 : : {
268 [ + + + - : 2251787 : if (io->payload) {
+ + ]
269 [ + - + - ]: 2250671 : spdk_free(io->payload);
270 : 2208 : }
271 : 2251787 : free(io);
272 : :
273 [ + - + - ]: 2251787 : nbd->io_count--;
274 : 2251787 : }
275 : :
276 : : /*
277 : : * Check whether received nbd_io are all executed,
278 : : * and put back executed nbd_io instead of transmitting them
279 : : *
280 : : * \return 1 there is still some nbd_io under executing
281 : : * 0 all nbd_io gotten are freed.
282 : : */
283 : : static int
284 : 524 : nbd_cleanup_io(struct spdk_nbd_disk *nbd)
285 : : {
286 : : /* Try to read the remaining nbd commands in the socket */
287 [ - + ]: 524 : while (nbd_io_recv_internal(nbd) > 0);
288 : :
289 : : /* free io_in_recv */
290 [ + - + - : 524 : if (nbd->io_in_recv != NULL) {
+ - ]
291 [ + - + - ]: 524 : nbd_put_io(nbd, nbd->io_in_recv);
292 [ + - + - ]: 524 : nbd->io_in_recv = NULL;
293 : 6 : }
294 : :
295 : : /*
296 : : * Some nbd_io may be under executing in bdev.
297 : : * Wait for their done operation.
298 : : */
299 [ + + + - : 524 : if (nbd->io_count != 0) {
- + ]
300 : 0 : return 1;
301 : : }
302 : :
303 : 524 : return 0;
304 : 6 : }
305 : :
306 : : static int
307 : 956 : _nbd_stop(void *arg)
308 : : {
309 : 956 : struct spdk_nbd_disk *nbd = arg;
310 : :
311 [ + + + - : 956 : if (nbd->nbd_poller) {
+ + ]
312 [ + - ]: 523 : spdk_poller_unregister(&nbd->nbd_poller);
313 : 6 : }
314 : :
315 [ + + + - : 956 : if (nbd->intr) {
+ - ]
316 [ # # ]: 0 : spdk_interrupt_unregister(&nbd->intr);
317 : 0 : }
318 : :
319 [ + + + - : 956 : if (nbd->spdk_sp_fd >= 0) {
+ + ]
320 [ + - + - ]: 523 : close(nbd->spdk_sp_fd);
321 [ + - + - ]: 523 : nbd->spdk_sp_fd = -1;
322 : 6 : }
323 : :
324 [ + + + - : 956 : if (nbd->kernel_sp_fd >= 0) {
+ + ]
325 [ + - + - ]: 523 : close(nbd->kernel_sp_fd);
326 [ + - + - ]: 523 : nbd->kernel_sp_fd = -1;
327 : 6 : }
328 : :
329 : : /* Continue the stop procedure after the exit of nbd_start_kernel pthread */
330 [ + + + + : 956 : if (nbd->has_nbd_pthread) {
+ - + + ]
331 [ + - + - : 433 : if (nbd->retry_poller == NULL) {
- + ]
332 [ + - + - ]: 433 : nbd->retry_count = NBD_STOP_BUSY_WAITING_MS * 1000ULL / NBD_BUSY_POLLING_INTERVAL_US;
333 [ + - + - ]: 433 : nbd->retry_poller = SPDK_POLLER_REGISTER(_nbd_stop, nbd,
334 : : NBD_BUSY_POLLING_INTERVAL_US);
335 : 433 : return SPDK_POLLER_BUSY;
336 : : }
337 : :
338 [ # # # # : 0 : if (nbd->retry_count-- > 0) {
# # ]
339 : 0 : return SPDK_POLLER_BUSY;
340 : : }
341 : :
342 : 0 : SPDK_ERRLOG("Failed to wait for returning of NBD_DO_IT ioctl.\n");
343 : 0 : }
344 : :
345 [ + + + - : 523 : if (nbd->retry_poller) {
- + ]
346 [ + - ]: 433 : spdk_poller_unregister(&nbd->retry_poller);
347 : 6 : }
348 : :
349 [ + - + - : 523 : if (nbd->dev_fd >= 0) {
- + ]
350 : : /* Clear nbd device only if it is occupied by SPDK app */
351 [ + - + - : 523 : if (nbd->nbd_path && nbd_disk_find_by_nbd_path(nbd->nbd_path)) {
+ - + - +
- + - ]
352 [ + - + - : 523 : ioctl(nbd->dev_fd, NBD_CLEAR_QUE);
+ - - + +
- - + + -
- + + - ]
353 [ + - + - : 523 : ioctl(nbd->dev_fd, NBD_CLEAR_SOCK);
+ - - + +
- - + + -
- + + - ]
354 : 6 : }
355 [ + - + - ]: 523 : close(nbd->dev_fd);
356 : 6 : }
357 : :
358 [ + - + - : 523 : if (nbd->nbd_path) {
- + ]
359 [ + - + - ]: 523 : free(nbd->nbd_path);
360 : 6 : }
361 : :
362 [ + - + - : 523 : if (nbd->ch) {
- + ]
363 [ + - + - ]: 523 : spdk_put_io_channel(nbd->ch);
364 [ + - + - ]: 523 : nbd->ch = NULL;
365 : 6 : }
366 : :
367 [ + - + - : 523 : if (nbd->bdev_desc) {
- + ]
368 [ + - + - ]: 523 : spdk_bdev_close(nbd->bdev_desc);
369 [ + - + - ]: 523 : nbd->bdev_desc = NULL;
370 : 6 : }
371 : :
372 : 523 : nbd_disk_unregister(nbd);
373 : :
374 : 523 : free(nbd);
375 : :
376 : 523 : return 0;
377 : 12 : }
378 : :
379 : : int
380 : 523 : spdk_nbd_stop(struct spdk_nbd_disk *nbd)
381 : : {
382 : 523 : int rc = 0;
383 : :
384 [ + + ]: 523 : if (nbd == NULL) {
385 : 0 : return rc;
386 : : }
387 : :
388 [ + - + - ]: 523 : nbd->is_closing = true;
389 : :
390 : : /* if nbd is not started, it will continue to call nbd stop later */
391 [ + + + + : 523 : if (!nbd->is_started) {
+ - + - ]
392 : 0 : return 1;
393 : : }
394 : :
395 : : /*
396 : : * Stop action should be called only after all nbd_io are executed.
397 : : */
398 : :
399 : 523 : rc = nbd_cleanup_io(nbd);
400 [ + + ]: 523 : if (!rc) {
401 : 523 : _nbd_stop(nbd);
402 : 6 : }
403 : :
404 : 523 : return rc;
405 : 6 : }
406 : :
407 : : static int64_t
408 : 452232178 : nbd_socket_rw(int fd, void *buf, size_t length, bool read_op)
409 : : {
410 : : ssize_t rc;
411 : :
412 [ + + + + ]: 452232178 : if (read_op) {
413 : 449467298 : rc = read(fd, buf, length);
414 : 3117244 : } else {
415 : 2764880 : rc = write(fd, buf, length);
416 : : }
417 : :
418 [ + + ]: 452232178 : if (rc == 0) {
419 : 0 : return -EIO;
420 [ + + ]: 452232178 : } else if (rc == -1) {
421 [ + + - + ]: 445465237 : if (errno != EAGAIN) {
422 [ # # # # ]: 0 : return -errno;
423 : : }
424 : 445465237 : return 0;
425 : : } else {
426 : 6766941 : return rc;
427 : : }
428 : 3120124 : }
429 : :
430 : : static void
431 : 2250741 : nbd_io_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
432 : : {
433 : 2250741 : struct nbd_io *io = cb_arg;
434 [ + - + - ]: 2250741 : struct spdk_nbd_disk *nbd = io->nbd;
435 : :
436 [ + + + - ]: 2250741 : if (success) {
437 [ + - + - : 2250704 : io->resp.error = 0;
+ - ]
438 : 2208 : } else {
439 [ # # # # ]: 37 : to_be32(&io->resp.error, EIO);
440 : : }
441 : :
442 [ + - + - : 2250741 : memcpy(&io->resp.handle, &io->req.handle, sizeof(io->resp.handle));
+ - + - +
- + - + -
+ - ]
443 : :
444 : : /* When there begins to have executed_io, enable socket writable notice in order to
445 : : * get it processed in nbd_io_xmit
446 : : */
447 [ + + + + : 2250741 : if (nbd->interrupt_mode && TAILQ_EMPTY(&nbd->executed_io_list)) {
+ - - + #
# # # # #
# # ]
448 [ # # # # ]: 0 : spdk_interrupt_set_event_types(nbd->intr, SPDK_INTERRUPT_EVENT_IN | SPDK_INTERRUPT_EVENT_OUT);
449 : 0 : }
450 : :
451 [ + + + - : 2250741 : TAILQ_REMOVE(&nbd->processing_io_list, io, tailq);
+ - + + +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
452 [ + - + - : 2250741 : TAILQ_INSERT_TAIL(&nbd->executed_io_list, io, tailq);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
453 : :
454 [ + + ]: 2250741 : if (bdev_io != NULL) {
455 : 2250741 : spdk_bdev_free_io(bdev_io);
456 : 2208 : }
457 : 2250741 : }
458 : :
459 : : static void
460 : 0 : nbd_resubmit_io(void *arg)
461 : : {
462 : 0 : struct nbd_io *io = (struct nbd_io *)arg;
463 [ # # # # ]: 0 : struct spdk_nbd_disk *nbd = io->nbd;
464 : 0 : int rc = 0;
465 : :
466 : 0 : rc = nbd_submit_bdev_io(nbd, io);
467 [ # # ]: 0 : if (rc) {
468 [ # # # # : 0 : SPDK_INFOLOG(nbd, "nbd: io resubmit for dev %s , io_type %d, returned %d.\n",
# # # # #
# ]
469 : : nbd_disk_get_bdev_name(nbd), from_be32(&io->req.type), rc);
470 : 0 : }
471 : 0 : }
472 : :
473 : : static void
474 : 0 : nbd_queue_io(struct nbd_io *io)
475 : : {
476 : : int rc;
477 [ # # # # : 0 : struct spdk_bdev *bdev = io->nbd->bdev;
# # # # ]
478 : :
479 [ # # # # : 0 : io->bdev_io_wait.bdev = bdev;
# # ]
480 [ # # # # : 0 : io->bdev_io_wait.cb_fn = nbd_resubmit_io;
# # ]
481 [ # # # # : 0 : io->bdev_io_wait.cb_arg = io;
# # ]
482 : :
483 [ # # # # : 0 : rc = spdk_bdev_queue_io_wait(bdev, io->nbd->ch, &io->bdev_io_wait);
# # # # #
# ]
484 [ # # ]: 0 : if (rc != 0) {
485 : 0 : SPDK_ERRLOG("Queue io failed in nbd_queue_io, rc=%d.\n", rc);
486 : 0 : nbd_io_done(NULL, false, io);
487 : 0 : }
488 : 0 : }
489 : :
490 : : static int
491 : 2250741 : nbd_submit_bdev_io(struct spdk_nbd_disk *nbd, struct nbd_io *io)
492 : : {
493 [ + - + - ]: 2250741 : struct spdk_bdev_desc *desc = nbd->bdev_desc;
494 [ + - + - ]: 2250741 : struct spdk_io_channel *ch = nbd->ch;
495 : 2250741 : int rc = 0;
496 : :
497 [ + + + + : 2250741 : switch (from_be32(&io->req.type)) {
- + + -
- ]
498 : 508966 : case NBD_CMD_READ:
499 [ + - + - : 510310 : rc = spdk_bdev_read(desc, ch, io->payload, from_be64(&io->req.from),
+ - + - ]
500 [ + - + - ]: 509638 : io->payload_size, nbd_io_done, io);
501 : 509638 : break;
502 : 1739497 : case NBD_CMD_WRITE:
503 [ + - + - : 1742569 : rc = spdk_bdev_write(desc, ch, io->payload, from_be64(&io->req.from),
+ - + - ]
504 [ + - + - ]: 1741033 : io->payload_size, nbd_io_done, io);
505 : 1741033 : break;
506 : : #ifdef NBD_FLAG_SEND_FLUSH
507 : 0 : case NBD_CMD_FLUSH:
508 : 0 : rc = spdk_bdev_flush(desc, ch, 0,
509 [ # # # # : 0 : spdk_bdev_get_num_blocks(nbd->bdev) * spdk_bdev_get_block_size(nbd->bdev),
# # # # ]
510 : 0 : nbd_io_done, io);
511 : 0 : break;
512 : : #endif
513 : : #ifdef NBD_FLAG_SEND_TRIM
514 : 70 : case NBD_CMD_TRIM:
515 [ # # # # ]: 70 : rc = spdk_bdev_unmap(desc, ch, from_be64(&io->req.from),
516 [ # # # # ]: 70 : from_be32(&io->req.len), nbd_io_done, io);
517 : 70 : break;
518 : : #endif
519 : 0 : default:
520 : 0 : rc = -1;
521 : 0 : }
522 : :
523 [ + + ]: 2250741 : if (rc < 0) {
524 [ # # ]: 0 : if (rc == -ENOMEM) {
525 [ # # # # : 0 : SPDK_INFOLOG(nbd, "No memory, start to queue io.\n");
# # ]
526 : 0 : nbd_queue_io(io);
527 : 0 : } else {
528 : 0 : SPDK_ERRLOG("nbd io failed in nbd_queue_io, rc=%d.\n", rc);
529 : 0 : nbd_io_done(NULL, false, io);
530 : : }
531 : 0 : }
532 : :
533 : 2250741 : return 0;
534 : : }
535 : :
536 : : static int
537 : 27983248 : nbd_io_exec(struct spdk_nbd_disk *nbd)
538 : : {
539 : : struct nbd_io *io, *io_tmp;
540 : 27983248 : int io_count = 0;
541 : 27983248 : int ret = 0;
542 : :
543 [ + + + - : 30233989 : TAILQ_FOREACH_SAFE(io, &nbd->received_io_list, tailq, io_tmp) {
+ - + + +
- + - + -
+ + ]
544 [ + + + - : 2250741 : TAILQ_REMOVE(&nbd->received_io_list, io, tailq);
+ - + + +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
545 [ + - + - : 2250741 : TAILQ_INSERT_TAIL(&nbd->processing_io_list, io, tailq);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
546 : 2250741 : ret = nbd_submit_bdev_io(nbd, io);
547 [ + + ]: 2250741 : if (ret < 0) {
548 : 0 : return ret;
549 : : }
550 : :
551 [ + - ]: 2250741 : io_count++;
552 : 2208 : }
553 : :
554 : 27983248 : return io_count;
555 : 194735 : }
556 : :
557 : : static int
558 : 447726265 : nbd_io_recv_internal(struct spdk_nbd_disk *nbd)
559 : : {
560 : : struct nbd_io *io;
561 : 447726265 : int ret = 0;
562 : 447726265 : int received = 0;
563 : :
564 [ + + + - : 447726265 : if (nbd->io_in_recv == NULL) {
+ + ]
565 [ + - + - ]: 2251787 : nbd->io_in_recv = nbd_get_io(nbd);
566 [ + + + - : 2251787 : if (!nbd->io_in_recv) {
+ - ]
567 : 0 : return -ENOMEM;
568 : : }
569 : 2220 : }
570 : :
571 [ + - + - ]: 447726265 : io = nbd->io_in_recv;
572 : :
573 [ + + + - : 447726265 : if (io->state == NBD_IO_RECV_REQ) {
+ + ]
574 [ + - + - : 560764257 : ret = nbd_socket_rw(nbd->spdk_sp_fd, (char *)&io->req + io->offset,
+ - + - +
- + - ]
575 [ + - + - ]: 447497070 : sizeof(io->req) - io->offset, true);
576 [ - + ]: 447497070 : if (ret < 0) {
577 : 0 : nbd_put_io(nbd, io);
578 [ # # # # ]: 0 : nbd->io_in_recv = NULL;
579 : 0 : return ret;
580 : : }
581 : :
582 [ + - + - ]: 447497070 : io->offset += ret;
583 : 447497070 : received = ret;
584 : :
585 : : /* request is fully received */
586 [ + + + - : 447497070 : if (io->offset == sizeof(io->req)) {
+ + ]
587 [ + - + - ]: 2251263 : io->offset = 0;
588 : :
589 : : /* req magic check */
590 [ + + + - : 2251263 : if (from_be32(&io->req.magic) != NBD_REQUEST_MAGIC) {
- + ]
591 : 0 : SPDK_ERRLOG("invalid request magic\n");
592 : 0 : nbd_put_io(nbd, io);
593 [ # # # # ]: 0 : nbd->io_in_recv = NULL;
594 : 0 : return -EINVAL;
595 : : }
596 : :
597 [ + + + - : 2251263 : if (from_be32(&io->req.type) == NBD_CMD_DISC) {
+ + ]
598 [ + - + - ]: 522 : nbd->is_closing = true;
599 [ + - + - ]: 522 : nbd->io_in_recv = NULL;
600 [ + + + + : 522 : if (nbd->interrupt_mode && TAILQ_EMPTY(&nbd->executed_io_list)) {
+ - - + #
# # # # #
# # ]
601 [ # # # # ]: 0 : spdk_interrupt_set_event_types(nbd->intr, SPDK_INTERRUPT_EVENT_IN | SPDK_INTERRUPT_EVENT_OUT);
602 : 0 : }
603 : 522 : nbd_put_io(nbd, io);
604 : : /* After receiving NBD_CMD_DISC, nbd will not receive any new commands */
605 : 522 : return received;
606 : : }
607 : :
608 : : /* io except read/write should ignore payload */
609 [ + + + + : 2760449 : if (from_be32(&io->req.type) == NBD_CMD_WRITE ||
+ + + - ]
610 [ + - + - ]: 509708 : from_be32(&io->req.type) == NBD_CMD_READ) {
611 [ + - + - : 2250671 : io->payload_size = from_be32(&io->req.len);
+ - + - ]
612 : 2208 : } else {
613 [ # # # # ]: 70 : io->payload_size = 0;
614 : : }
615 : :
616 : : /* io payload allocate */
617 [ + + + - : 2250741 : if (io->payload_size) {
+ - ]
618 [ + - + - : 2250671 : io->payload = spdk_malloc(io->payload_size, nbd->buf_align, NULL,
+ - + - +
- + - ]
619 : : SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
620 [ + + + - : 2250671 : if (io->payload == NULL) {
+ - ]
621 [ # # # # ]: 0 : SPDK_ERRLOG("could not allocate io->payload of size %d\n", io->payload_size);
622 : 0 : nbd_put_io(nbd, io);
623 [ # # # # ]: 0 : nbd->io_in_recv = NULL;
624 : 0 : return -ENOMEM;
625 : : }
626 : 2208 : } else {
627 [ # # # # ]: 70 : io->payload = NULL;
628 : : }
629 : :
630 : : /* next io step */
631 [ + + + - : 2250741 : if (from_be32(&io->req.type) == NBD_CMD_WRITE) {
+ + ]
632 [ + - + - ]: 1741033 : io->state = NBD_IO_RECV_PAYLOAD;
633 : 1536 : } else {
634 [ + - + - ]: 509708 : io->state = NBD_IO_XMIT_RESP;
635 [ + + + - : 509708 : if (spdk_likely((!nbd->is_closing) && nbd->is_started)) {
+ + + + +
- + - + -
+ - ]
636 [ + - + - : 509708 : TAILQ_INSERT_TAIL(&nbd->received_io_list, io, tailq);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
637 : 672 : } else {
638 [ # # # # : 0 : TAILQ_INSERT_TAIL(&nbd->processing_io_list, io, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
639 : 0 : nbd_io_done(NULL, false, io);
640 : : }
641 [ + - + - ]: 509708 : nbd->io_in_recv = NULL;
642 : : }
643 : 2208 : }
644 : 3115698 : }
645 : :
646 [ + + + - : 447725743 : if (io->state == NBD_IO_RECV_PAYLOAD) {
+ + ]
647 [ + - + - : 1970228 : ret = nbd_socket_rw(nbd->spdk_sp_fd, io->payload + io->offset, io->payload_size - io->offset, true);
+ - + - +
- + - + -
+ - + - +
- ]
648 [ + + ]: 1970228 : if (ret < 0) {
649 : 0 : nbd_put_io(nbd, io);
650 [ # # # # ]: 0 : nbd->io_in_recv = NULL;
651 : 0 : return ret;
652 : : }
653 : :
654 [ + - + - ]: 1970228 : io->offset += ret;
655 [ + - ]: 1970228 : received += ret;
656 : :
657 : : /* request payload is fully received */
658 [ + + + - : 1970228 : if (io->offset == io->payload_size) {
+ - + - +
+ ]
659 [ + - + - ]: 1741033 : io->offset = 0;
660 [ + - + - ]: 1741033 : io->state = NBD_IO_XMIT_RESP;
661 [ + + + - : 1741033 : if (spdk_likely((!nbd->is_closing) && nbd->is_started)) {
+ + + + +
- + - + -
- + ]
662 [ + - + - : 1741033 : TAILQ_INSERT_TAIL(&nbd->received_io_list, io, tailq);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
663 : 1536 : } else {
664 [ # # # # : 0 : TAILQ_INSERT_TAIL(&nbd->processing_io_list, io, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
665 : 0 : nbd_io_done(NULL, false, io);
666 : : }
667 [ + - + - ]: 1741033 : nbd->io_in_recv = NULL;
668 : 1536 : }
669 : :
670 : 1540 : }
671 : :
672 : 447725743 : return received;
673 : 3115708 : }
674 : :
675 : : static int
676 : 27983248 : nbd_io_recv(struct spdk_nbd_disk *nbd)
677 : : {
678 : 27983248 : int i, rc, ret = 0;
679 : :
680 : : /*
681 : : * nbd server should not accept request after closing command
682 : : */
683 [ + + + + : 27983248 : if (nbd->is_closing) {
+ - - + ]
684 : 1 : return 0;
685 : : }
686 : :
687 [ + + + - ]: 475708466 : for (i = 0; i < GET_IO_LOOP_COUNT; i++) {
688 : 447725741 : rc = nbd_io_recv_internal(nbd);
689 [ + + ]: 447725741 : if (rc < 0) {
690 : 0 : return rc;
691 : : }
692 [ + - ]: 447725741 : ret += rc;
693 [ + + + + : 447725741 : if (nbd->is_closing) {
+ - + + ]
694 : 522 : break;
695 : : }
696 : 3115696 : }
697 : :
698 : 27983247 : return ret;
699 : 194735 : }
700 : :
701 : : static int
702 : 2255242 : nbd_io_xmit_internal(struct spdk_nbd_disk *nbd)
703 : : {
704 : : struct nbd_io *io;
705 : 2255242 : int ret = 0;
706 : 2255242 : int sent = 0;
707 : :
708 [ + - + - : 2255242 : io = TAILQ_FIRST(&nbd->executed_io_list);
+ - ]
709 [ - + ]: 2255242 : if (io == NULL) {
710 : 0 : return 0;
711 : : }
712 : :
713 : : /* Remove IO from list now assuming it will be completed. It will be inserted
714 : : * back to the head if it cannot be completed. This approach is specifically
715 : : * taken to work around a scan-build use-after-free mischaracterization.
716 : : */
717 [ + + + - : 2255242 : TAILQ_REMOVE(&nbd->executed_io_list, io, tailq);
+ - + + +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
718 : :
719 : : /* resp error and handler are already set in io_done */
720 : :
721 [ + + + - : 2255242 : if (io->state == NBD_IO_XMIT_RESP) {
- + ]
722 [ + - + - : 2542003 : ret = nbd_socket_rw(nbd->spdk_sp_fd, (char *)&io->resp + io->offset,
+ - + - +
- + - ]
723 [ + - + - ]: 2250741 : sizeof(io->resp) - io->offset, false);
724 [ - + ]: 2250741 : if (ret <= 0) {
725 : 0 : goto reinsert;
726 : : }
727 : :
728 [ + - + - ]: 2250741 : io->offset += ret;
729 : 2250741 : sent = ret;
730 : :
731 : : /* response is fully transmitted */
732 [ + - + - : 2250741 : if (io->offset == sizeof(io->resp)) {
- + ]
733 [ + - + - ]: 2250741 : io->offset = 0;
734 : :
735 : : /* transmit payload only when NBD_CMD_READ with no resp error */
736 [ + + + + : 2250741 : if (from_be32(&io->req.type) != NBD_CMD_READ || io->resp.error != 0) {
+ + + - +
- + - -
+ ]
737 : 1741103 : nbd_put_io(nbd, io);
738 : 1741103 : return 0;
739 : : } else {
740 [ + - + - ]: 509638 : io->state = NBD_IO_XMIT_PAYLOAD;
741 : : }
742 : 672 : }
743 : 672 : }
744 : :
745 [ + - + - : 514139 : if (io->state == NBD_IO_XMIT_PAYLOAD) {
- + ]
746 [ + - + - : 514139 : ret = nbd_socket_rw(nbd->spdk_sp_fd, io->payload + io->offset, io->payload_size - io->offset,
+ - + - +
- + - + -
+ - + - +
- ]
747 : : false);
748 [ + + ]: 514139 : if (ret <= 0) {
749 : 4474 : goto reinsert;
750 : : }
751 : :
752 [ + - + - ]: 509665 : io->offset += ret;
753 [ + - ]: 509665 : sent += ret;
754 : :
755 : : /* read payload is fully transmitted */
756 [ + + + - : 509665 : if (io->offset == io->payload_size) {
+ - + - +
- ]
757 : 509638 : nbd_put_io(nbd, io);
758 : 509638 : return sent;
759 : : }
760 : 0 : }
761 : :
762 : 27 : reinsert:
763 [ - + # # : 4501 : TAILQ_INSERT_HEAD(&nbd->executed_io_list, io, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
764 [ - + ]: 4501 : return ret < 0 ? ret : sent;
765 : 2208 : }
766 : :
767 : : static int
768 : 27983248 : nbd_io_xmit(struct spdk_nbd_disk *nbd)
769 : : {
770 : 27983248 : int ret = 0;
771 : : int rc;
772 : :
773 [ + + + - : 30238490 : while (!TAILQ_EMPTY(&nbd->executed_io_list)) {
+ - + + ]
774 : 2255242 : rc = nbd_io_xmit_internal(nbd);
775 [ + + ]: 2255242 : if (rc < 0) {
776 : 0 : return rc;
777 : : }
778 : :
779 [ + - ]: 2255242 : ret += rc;
780 : : }
781 : :
782 : : /* When there begins to have no executed_io, disable socket writable notice */
783 [ + + + + : 27983248 : if (nbd->interrupt_mode) {
+ - + - ]
784 [ # # # # ]: 0 : spdk_interrupt_set_event_types(nbd->intr, SPDK_INTERRUPT_EVENT_IN);
785 : 0 : }
786 : :
787 : 27983248 : return ret;
788 : 194735 : }
789 : :
790 : : /**
791 : : * Poll an NBD instance.
792 : : *
793 : : * \return 0 on success or negated errno values on error (e.g. connection closed).
794 : : */
795 : : static int
796 : 27983248 : _nbd_poll(struct spdk_nbd_disk *nbd)
797 : : {
798 : : int received, sent, executed;
799 : :
800 : : /* transmit executed io first */
801 : 27983248 : sent = nbd_io_xmit(nbd);
802 [ + + ]: 27983248 : if (sent < 0) {
803 : 0 : return sent;
804 : : }
805 : :
806 : 27983248 : received = nbd_io_recv(nbd);
807 [ + + ]: 27983248 : if (received < 0) {
808 : 0 : return received;
809 : : }
810 : :
811 : 27983248 : executed = nbd_io_exec(nbd);
812 [ + + ]: 27983248 : if (executed < 0) {
813 : 0 : return executed;
814 : : }
815 : :
816 [ + - + - ]: 27983248 : return sent + received + executed;
817 : 194735 : }
818 : :
819 : : static int
820 : 27983248 : nbd_poll(void *arg)
821 : : {
822 : 27983248 : struct spdk_nbd_disk *nbd = arg;
823 : : int rc;
824 : :
825 : 27983248 : rc = _nbd_poll(nbd);
826 [ + + ]: 27983248 : if (rc < 0) {
827 [ # # # # : 0 : SPDK_INFOLOG(nbd, "nbd_poll() returned %s (%d); closing connection\n",
# # # # ]
828 : : spdk_strerror(-rc), rc);
829 : 0 : _nbd_stop(nbd);
830 : 0 : return SPDK_POLLER_IDLE;
831 : : }
832 [ + + + + : 27983248 : if (nbd->is_closing && nbd->io_count == 0) {
+ - + + +
- + - -
+ ]
833 : 523 : spdk_nbd_stop(nbd);
834 : 6 : }
835 : :
836 : 27983248 : return rc == 0 ? SPDK_POLLER_IDLE : SPDK_POLLER_BUSY;
837 : 194735 : }
838 : :
839 : : static void *
840 : 529 : nbd_start_kernel(void *arg)
841 : : {
842 : 529 : struct spdk_nbd_disk *nbd = arg;
843 : :
844 : 529 : spdk_unaffinitize_thread();
845 : :
846 : : /* This will block in the kernel until we close the spdk_sp_fd. */
847 [ + - + - : 529 : ioctl(nbd->dev_fd, NBD_DO_IT);
+ - + + +
- + + + -
+ + # # ]
848 : :
849 [ # # # # ]: 517 : nbd->has_nbd_pthread = false;
850 : :
851 [ # # ]: 517 : pthread_exit(NULL);
852 : : }
853 : :
854 : : static void
855 : 1 : nbd_bdev_hot_remove(struct spdk_nbd_disk *nbd)
856 : : {
857 : : struct nbd_io *io, *io_tmp;
858 : :
859 [ # # # # ]: 1 : nbd->is_closing = true;
860 : 1 : nbd_cleanup_io(nbd);
861 : :
862 [ - + # # : 1 : TAILQ_FOREACH_SAFE(io, &nbd->received_io_list, tailq, io_tmp) {
# # # # #
# # # # #
# # ]
863 [ # # # # : 0 : TAILQ_REMOVE(&nbd->received_io_list, io, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
864 : 0 : nbd_io_done(NULL, false, io);
865 : 0 : }
866 : 1 : }
867 : :
868 : : static void
869 : 2 : nbd_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
870 : : void *event_ctx)
871 : : {
872 [ + + ]: 2 : switch (type) {
873 : 1 : case SPDK_BDEV_EVENT_REMOVE:
874 : 1 : nbd_bdev_hot_remove(event_ctx);
875 : 1 : break;
876 : 1 : default:
877 : 1 : SPDK_NOTICELOG("Unsupported bdev event: type %d\n", type);
878 : 1 : break;
879 : : }
880 : 2 : }
881 : :
882 : : struct spdk_nbd_start_ctx {
883 : : struct spdk_nbd_disk *nbd;
884 : : spdk_nbd_start_cb cb_fn;
885 : : void *cb_arg;
886 : : };
887 : :
888 : : static void
889 : 0 : nbd_poller_set_interrupt_mode(struct spdk_poller *poller, void *cb_arg, bool interrupt_mode)
890 : : {
891 : 0 : struct spdk_nbd_disk *nbd = cb_arg;
892 : :
893 [ # # # # : 0 : nbd->interrupt_mode = interrupt_mode;
# # ]
894 : 0 : }
895 : :
896 : : static void
897 : 523 : nbd_start_complete(struct spdk_nbd_start_ctx *ctx)
898 : : {
899 : : int rc;
900 : 346 : pthread_t tid;
901 : 523 : unsigned long nbd_flags = 0;
902 : :
903 [ + - + - : 523 : rc = ioctl(ctx->nbd->dev_fd, NBD_SET_BLKSIZE, spdk_bdev_get_block_size(ctx->nbd->bdev));
+ - + - +
- - + + -
- + + - -
+ + - + -
+ - + - +
- ]
904 [ + + ]: 523 : if (rc == -1) {
905 [ # # ]: 0 : SPDK_ERRLOG("ioctl(NBD_SET_BLKSIZE) failed: %s\n", spdk_strerror(errno));
906 [ # # # # ]: 0 : rc = -errno;
907 : 0 : goto err;
908 : : }
909 : :
910 [ + - + - : 523 : rc = ioctl(ctx->nbd->dev_fd, NBD_SET_SIZE_BLOCKS, spdk_bdev_get_num_blocks(ctx->nbd->bdev));
+ - + - +
- - + + -
- + + - -
+ + - + -
+ - + - +
- ]
911 [ + + ]: 523 : if (rc == -1) {
912 [ # # ]: 0 : SPDK_ERRLOG("ioctl(NBD_SET_SIZE_BLOCKS) failed: %s\n", spdk_strerror(errno));
913 [ # # # # ]: 0 : rc = -errno;
914 : 0 : goto err;
915 : : }
916 : :
917 : : #ifdef NBD_SET_TIMEOUT
918 [ + - + - : 523 : rc = ioctl(ctx->nbd->dev_fd, NBD_SET_TIMEOUT, NBD_IO_TIMEOUT_S);
+ - + - +
- - + + -
- + + - -
+ + - ]
919 [ + + ]: 523 : if (rc == -1) {
920 [ # # ]: 0 : SPDK_ERRLOG("ioctl(NBD_SET_TIMEOUT) failed: %s\n", spdk_strerror(errno));
921 [ # # # # ]: 0 : rc = -errno;
922 : 0 : goto err;
923 : : }
924 : : #else
925 : : SPDK_NOTICELOG("ioctl(NBD_SET_TIMEOUT) is not supported.\n");
926 : : #endif
927 : :
928 : : #ifdef NBD_FLAG_SEND_FLUSH
929 [ + + + - : 523 : if (spdk_bdev_io_type_supported(ctx->nbd->bdev, SPDK_BDEV_IO_TYPE_FLUSH)) {
+ - + - -
+ ]
930 [ - + + - ]: 415 : nbd_flags |= NBD_FLAG_SEND_FLUSH;
931 : 6 : }
932 : : #endif
933 : : #ifdef NBD_FLAG_SEND_TRIM
934 [ + + + - : 523 : if (spdk_bdev_io_type_supported(ctx->nbd->bdev, SPDK_BDEV_IO_TYPE_UNMAP)) {
+ - + - -
+ ]
935 [ - + + - ]: 459 : nbd_flags |= NBD_FLAG_SEND_TRIM;
936 : 6 : }
937 : : #endif
938 : :
939 [ + + ]: 523 : if (nbd_flags) {
940 [ + - + - : 467 : rc = ioctl(ctx->nbd->dev_fd, NBD_SET_FLAGS, nbd_flags);
+ - + - +
- - + + -
- + + - -
+ + - ]
941 [ - + ]: 467 : if (rc == -1) {
942 [ # # ]: 0 : SPDK_ERRLOG("ioctl(NBD_SET_FLAGS, 0x%lx) failed: %s\n", nbd_flags, spdk_strerror(errno));
943 [ # # # # ]: 0 : rc = -errno;
944 : 0 : goto err;
945 : : }
946 : 6 : }
947 : :
948 [ + - + - : 523 : ctx->nbd->has_nbd_pthread = true;
+ - + - ]
949 [ + - + - : 523 : rc = pthread_create(&tid, NULL, nbd_start_kernel, ctx->nbd);
+ - + - ]
950 [ - + ]: 523 : if (rc != 0) {
951 [ # # # # : 0 : ctx->nbd->has_nbd_pthread = false;
# # # # ]
952 : 0 : SPDK_ERRLOG("could not create thread: %s\n", spdk_strerror(rc));
953 [ # # ]: 0 : rc = -rc;
954 : 0 : goto err;
955 : : }
956 : :
957 : 523 : rc = pthread_detach(tid);
958 [ - + ]: 523 : if (rc != 0) {
959 : 0 : SPDK_ERRLOG("could not detach thread for nbd kernel: %s\n", spdk_strerror(rc));
960 [ # # ]: 0 : rc = -rc;
961 : 0 : goto err;
962 : : }
963 : :
964 [ + + ]: 523 : if (spdk_interrupt_mode_is_enabled()) {
965 [ # # # # : 0 : ctx->nbd->intr = SPDK_INTERRUPT_REGISTER(ctx->nbd->spdk_sp_fd, nbd_poll, ctx->nbd);
# # # # #
# # # # #
# # # # #
# ]
966 : 0 : }
967 : :
968 [ + - + - : 523 : ctx->nbd->nbd_poller = SPDK_POLLER_REGISTER(nbd_poll, ctx->nbd, 0);
+ - + - +
- + - ]
969 [ + - + - : 523 : spdk_poller_register_interrupt(ctx->nbd->nbd_poller, nbd_poller_set_interrupt_mode, ctx->nbd);
+ - + - +
- + - ]
970 : :
971 [ + - + - : 523 : if (ctx->cb_fn) {
+ - ]
972 [ + - + - : 523 : ctx->cb_fn(ctx->cb_arg, ctx->nbd, 0);
- + + - +
- + - + -
+ - ]
973 : 6 : }
974 : :
975 : : /* nbd will possibly receive stop command while initing */
976 [ + - + - : 523 : ctx->nbd->is_started = true;
+ - + - ]
977 : :
978 : 523 : free(ctx);
979 : 523 : return;
980 : :
981 : 0 : err:
982 [ # # # # ]: 0 : _nbd_stop(ctx->nbd);
983 [ # # # # : 0 : if (ctx->cb_fn) {
# # ]
984 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, NULL, rc);
# # # # #
# # # ]
985 : 0 : }
986 : 0 : free(ctx);
987 : 6 : }
988 : :
989 : : static int
990 : 523 : nbd_enable_kernel(void *arg)
991 : : {
992 : 523 : struct spdk_nbd_start_ctx *ctx = arg;
993 : : int rc;
994 : :
995 : : /* Declare device setup by this process */
996 [ + - + - : 523 : rc = ioctl(ctx->nbd->dev_fd, NBD_SET_SOCK, ctx->nbd->kernel_sp_fd);
+ - + - +
- - + + -
- + + - -
+ + - + -
+ - + - +
- ]
997 : :
998 [ - + ]: 523 : if (rc) {
999 [ # # # # ]: 0 : if (errno == EBUSY) {
1000 [ # # # # : 0 : if (ctx->nbd->retry_poller == NULL) {
# # # # #
# ]
1001 [ # # # # : 0 : ctx->nbd->retry_count = NBD_START_BUSY_WAITING_MS * 1000ULL / NBD_BUSY_POLLING_INTERVAL_US;
# # # # ]
1002 [ # # # # : 0 : ctx->nbd->retry_poller = SPDK_POLLER_REGISTER(nbd_enable_kernel, ctx,
# # # # ]
1003 : : NBD_BUSY_POLLING_INTERVAL_US);
1004 : 0 : return SPDK_POLLER_BUSY;
1005 [ # # # # : 0 : } else if (ctx->nbd->retry_count-- > 0) {
# # # # #
# ]
1006 : : /* Repeatedly unregister and register retry poller to avoid scan-build error */
1007 [ # # # # : 0 : spdk_poller_unregister(&ctx->nbd->retry_poller);
# # ]
1008 [ # # # # : 0 : ctx->nbd->retry_poller = SPDK_POLLER_REGISTER(nbd_enable_kernel, ctx,
# # # # ]
1009 : : NBD_BUSY_POLLING_INTERVAL_US);
1010 : 0 : return SPDK_POLLER_BUSY;
1011 : : }
1012 : 0 : }
1013 : :
1014 [ # # ]: 0 : SPDK_ERRLOG("ioctl(NBD_SET_SOCK) failed: %s\n", spdk_strerror(errno));
1015 [ # # # # : 0 : if (ctx->nbd->retry_poller) {
# # # # #
# ]
1016 [ # # # # : 0 : spdk_poller_unregister(&ctx->nbd->retry_poller);
# # ]
1017 : 0 : }
1018 : :
1019 [ # # # # ]: 0 : _nbd_stop(ctx->nbd);
1020 : :
1021 [ # # # # : 0 : if (ctx->cb_fn) {
# # ]
1022 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, NULL, -errno);
# # # # #
# # # # #
# # ]
1023 : 0 : }
1024 : :
1025 : 0 : free(ctx);
1026 : 0 : return SPDK_POLLER_BUSY;
1027 : : }
1028 : :
1029 [ + + + - : 523 : if (ctx->nbd->retry_poller) {
+ - + - +
- ]
1030 [ # # # # : 0 : spdk_poller_unregister(&ctx->nbd->retry_poller);
# # ]
1031 : 0 : }
1032 : :
1033 : 523 : nbd_start_complete(ctx);
1034 : :
1035 : 523 : return SPDK_POLLER_BUSY;
1036 : 6 : }
1037 : :
1038 : : void
1039 : 523 : spdk_nbd_start(const char *bdev_name, const char *nbd_path,
1040 : : spdk_nbd_start_cb cb_fn, void *cb_arg)
1041 : : {
1042 : 523 : struct spdk_nbd_start_ctx *ctx = NULL;
1043 : 523 : struct spdk_nbd_disk *nbd = NULL;
1044 : : struct spdk_bdev *bdev;
1045 : : int rc;
1046 : 346 : int sp[2];
1047 : :
1048 : 523 : nbd = calloc(1, sizeof(*nbd));
1049 [ + + ]: 523 : if (nbd == NULL) {
1050 : 0 : rc = -ENOMEM;
1051 : 0 : goto err;
1052 : : }
1053 : :
1054 [ + - + - ]: 523 : nbd->dev_fd = -1;
1055 [ + - + - ]: 523 : nbd->spdk_sp_fd = -1;
1056 [ + - + - ]: 523 : nbd->kernel_sp_fd = -1;
1057 : :
1058 : 523 : ctx = calloc(1, sizeof(*ctx));
1059 [ + + ]: 523 : if (ctx == NULL) {
1060 : 0 : rc = -ENOMEM;
1061 : 0 : goto err;
1062 : : }
1063 : :
1064 [ + - + - ]: 523 : ctx->nbd = nbd;
1065 [ + - + - ]: 523 : ctx->cb_fn = cb_fn;
1066 [ + - + - ]: 523 : ctx->cb_arg = cb_arg;
1067 : :
1068 [ + - ]: 523 : rc = spdk_bdev_open_ext(bdev_name, true, nbd_bdev_event_cb, nbd, &nbd->bdev_desc);
1069 [ - + ]: 523 : if (rc != 0) {
1070 : 0 : SPDK_ERRLOG("could not open bdev %s, error=%d\n", bdev_name, rc);
1071 : 0 : goto err;
1072 : : }
1073 : :
1074 [ + - + - ]: 523 : bdev = spdk_bdev_desc_get_bdev(nbd->bdev_desc);
1075 [ + - + - ]: 523 : nbd->bdev = bdev;
1076 : :
1077 [ + - + - : 523 : nbd->ch = spdk_bdev_get_io_channel(nbd->bdev_desc);
+ - + - ]
1078 [ + + + - : 523 : nbd->buf_align = spdk_max(spdk_bdev_get_buf_align(bdev), 64);
+ - ]
1079 : :
1080 : 523 : rc = socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, sp);
1081 [ - + ]: 523 : if (rc != 0) {
1082 : 0 : SPDK_ERRLOG("socketpair failed\n");
1083 [ # # # # ]: 0 : rc = -errno;
1084 : 0 : goto err;
1085 : : }
1086 : :
1087 [ + - + - : 523 : nbd->spdk_sp_fd = sp[0];
+ - + - ]
1088 [ + - + - : 523 : nbd->kernel_sp_fd = sp[1];
+ - + - +
- ]
1089 [ + + + - : 523 : nbd->nbd_path = strdup(nbd_path);
+ - ]
1090 [ + + + - : 523 : if (!nbd->nbd_path) {
- + ]
1091 : 0 : SPDK_ERRLOG("strdup allocation failure\n");
1092 : 0 : rc = -ENOMEM;
1093 : 0 : goto err;
1094 : : }
1095 : :
1096 [ + - + - : 523 : TAILQ_INIT(&nbd->received_io_list);
+ - + - +
- + - + -
+ - ]
1097 [ + - + - : 523 : TAILQ_INIT(&nbd->executed_io_list);
+ - + - +
- + - + -
+ - ]
1098 [ + - + - : 523 : TAILQ_INIT(&nbd->processing_io_list);
+ - + - +
- + - + -
+ - ]
1099 : :
1100 : : /* Add nbd_disk to the end of disk list */
1101 [ + - + - ]: 523 : rc = nbd_disk_register(ctx->nbd);
1102 [ - + ]: 523 : if (rc != 0) {
1103 : 0 : goto err;
1104 : : }
1105 : :
1106 [ + + + - : 523 : nbd->dev_fd = open(nbd_path, O_RDWR | O_DIRECT);
+ - ]
1107 [ + + + - : 523 : if (nbd->dev_fd == -1) {
+ - ]
1108 [ # # ]: 0 : SPDK_ERRLOG("open(\"%s\") failed: %s\n", nbd_path, spdk_strerror(errno));
1109 [ # # # # ]: 0 : rc = -errno;
1110 : 0 : goto err;
1111 : : }
1112 : :
1113 [ + + + + : 523 : SPDK_INFOLOG(nbd, "Enabling kernel access to bdev %s via %s\n",
+ - ]
1114 : : bdev_name, nbd_path);
1115 : :
1116 : 523 : nbd_enable_kernel(ctx);
1117 : 523 : return;
1118 : :
1119 : 0 : err:
1120 : 0 : free(ctx);
1121 [ # # ]: 0 : if (nbd) {
1122 : 0 : _nbd_stop(nbd);
1123 : 0 : }
1124 : :
1125 [ # # ]: 0 : if (cb_fn) {
1126 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, rc);
1127 : 0 : }
1128 : 6 : }
1129 : :
1130 : : const char *
1131 : 523 : spdk_nbd_get_path(struct spdk_nbd_disk *nbd)
1132 : : {
1133 [ + - + - ]: 523 : return nbd->nbd_path;
1134 : : }
1135 : :
1136 : 1208 : SPDK_LOG_REGISTER_COMPONENT(nbd)
|