2 * QEMU Block driver for NBD
4 * Copyright (C) 2008 Bull S.A.S.
5 * Author: Laurent Vivier <Laurent.Vivier@bull.net>
8 * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 #include "qemu/osdep.h"
30 #include "block/nbd-client.h"
31 #include "qapi/error.h"
33 #include "block/block_int.h"
34 #include "qemu/module.h"
35 #include "qapi-visit.h"
36 #include "qapi/qobject-input-visitor.h"
37 #include "qapi/qobject-output-visitor.h"
38 #include "qapi/qmp/qdict.h"
39 #include "qapi/qmp/qjson.h"
40 #include "qapi/qmp/qint.h"
41 #include "qapi/qmp/qstring.h"
42 #include "qemu/cutils.h"
44 #define EN_OPTSTR ":exportname="
46 typedef struct BDRVNBDState
{
47 NbdClientSession client
;
49 /* For nbd_refresh_filename() */
51 char *export
, *tlscredsid
;
54 static int nbd_parse_uri(const char *filename
, QDict
*options
)
58 QueryParams
*qp
= NULL
;
62 uri
= uri_parse(filename
);
68 if (!strcmp(uri
->scheme
, "nbd")) {
70 } else if (!strcmp(uri
->scheme
, "nbd+tcp")) {
72 } else if (!strcmp(uri
->scheme
, "nbd+unix")) {
79 p
= uri
->path
? uri
->path
: "/";
82 qdict_put(options
, "export", qstring_from_str(p
));
85 qp
= query_params_parse(uri
->query
);
86 if (qp
->n
> 1 || (is_unix
&& !qp
->n
) || (!is_unix
&& qp
->n
)) {
92 /* nbd+unix:///export?socket=path */
93 if (uri
->server
|| uri
->port
|| strcmp(qp
->p
[0].name
, "socket")) {
97 qdict_put(options
, "server.type", qstring_from_str("unix"));
98 qdict_put(options
, "server.data.path",
99 qstring_from_str(qp
->p
[0].value
));
104 /* nbd[+tcp]://host[:port]/export */
110 /* strip braces from literal IPv6 address */
111 if (uri
->server
[0] == '[') {
112 host
= qstring_from_substr(uri
->server
, 1,
113 strlen(uri
->server
) - 2);
115 host
= qstring_from_str(uri
->server
);
118 qdict_put(options
, "server.type", qstring_from_str("inet"));
119 qdict_put(options
, "server.data.host", host
);
121 port_str
= g_strdup_printf("%d", uri
->port
?: NBD_DEFAULT_PORT
);
122 qdict_put(options
, "server.data.port", qstring_from_str(port_str
));
128 query_params_free(qp
);
134 static bool nbd_has_filename_options_conflict(QDict
*options
, Error
**errp
)
138 for (e
= qdict_first(options
); e
; e
= qdict_next(options
, e
)) {
139 if (!strcmp(e
->key
, "host") ||
140 !strcmp(e
->key
, "port") ||
141 !strcmp(e
->key
, "path") ||
142 !strcmp(e
->key
, "export") ||
143 strstart(e
->key
, "server.", NULL
))
145 error_setg(errp
, "Option '%s' cannot be used with a file name",
154 static void nbd_parse_filename(const char *filename
, QDict
*options
,
159 const char *host_spec
;
160 const char *unixpath
;
162 if (nbd_has_filename_options_conflict(options
, errp
)) {
166 if (strstr(filename
, "://")) {
167 int ret
= nbd_parse_uri(filename
, options
);
169 error_setg(errp
, "No valid URL specified");
174 file
= g_strdup(filename
);
176 export_name
= strstr(file
, EN_OPTSTR
);
178 if (export_name
[strlen(EN_OPTSTR
)] == 0) {
181 export_name
[0] = 0; /* truncate 'file' */
182 export_name
+= strlen(EN_OPTSTR
);
184 qdict_put(options
, "export", qstring_from_str(export_name
));
187 /* extract the host_spec - fail if it's not nbd:... */
188 if (!strstart(file
, "nbd:", &host_spec
)) {
189 error_setg(errp
, "File name string for NBD must start with 'nbd:'");
197 /* are we a UNIX or TCP socket? */
198 if (strstart(host_spec
, "unix:", &unixpath
)) {
199 qdict_put(options
, "server.type", qstring_from_str("unix"));
200 qdict_put(options
, "server.data.path", qstring_from_str(unixpath
));
202 InetSocketAddress
*addr
= NULL
;
204 addr
= inet_parse(host_spec
, errp
);
209 qdict_put(options
, "server.type", qstring_from_str("inet"));
210 qdict_put(options
, "server.data.host", qstring_from_str(addr
->host
));
211 qdict_put(options
, "server.data.port", qstring_from_str(addr
->port
));
212 qapi_free_InetSocketAddress(addr
);
219 static bool nbd_process_legacy_socket_options(QDict
*output_options
,
220 QemuOpts
*legacy_opts
,
223 const char *path
= qemu_opt_get(legacy_opts
, "path");
224 const char *host
= qemu_opt_get(legacy_opts
, "host");
225 const char *port
= qemu_opt_get(legacy_opts
, "port");
228 if (!path
&& !host
&& !port
) {
232 for (e
= qdict_first(output_options
); e
; e
= qdict_next(output_options
, e
))
234 if (strstart(e
->key
, "server.", NULL
)) {
235 error_setg(errp
, "Cannot use 'server' and path/host/port at the "
242 error_setg(errp
, "path and host may not be used at the same time");
246 error_setg(errp
, "port may not be used without host");
250 qdict_put(output_options
, "server.type", qstring_from_str("unix"));
251 qdict_put(output_options
, "server.data.path", qstring_from_str(path
));
253 qdict_put(output_options
, "server.type", qstring_from_str("inet"));
254 qdict_put(output_options
, "server.data.host", qstring_from_str(host
));
255 qdict_put(output_options
, "server.data.port",
256 qstring_from_str(port
?: stringify(NBD_DEFAULT_PORT
)));
262 static SocketAddress
*nbd_config(BDRVNBDState
*s
, QDict
*options
, Error
**errp
)
264 SocketAddress
*saddr
= NULL
;
266 QObject
*crumpled_addr
= NULL
;
268 Error
*local_err
= NULL
;
270 qdict_extract_subqdict(options
, &addr
, "server.");
271 if (!qdict_size(addr
)) {
272 error_setg(errp
, "NBD server address missing");
276 crumpled_addr
= qdict_crumple(addr
, errp
);
277 if (!crumpled_addr
) {
281 iv
= qobject_input_visitor_new(crumpled_addr
, true);
282 visit_type_SocketAddress(iv
, NULL
, &saddr
, &local_err
);
284 error_propagate(errp
, local_err
);
288 s
->client
.is_unix
= saddr
->type
== SOCKET_ADDRESS_KIND_UNIX
;
292 qobject_decref(crumpled_addr
);
297 NbdClientSession
*nbd_get_client_session(BlockDriverState
*bs
)
299 BDRVNBDState
*s
= bs
->opaque
;
303 static QIOChannelSocket
*nbd_establish_connection(SocketAddress
*saddr
,
306 QIOChannelSocket
*sioc
;
307 Error
*local_err
= NULL
;
309 sioc
= qio_channel_socket_new();
311 qio_channel_socket_connect_sync(sioc
,
315 error_propagate(errp
, local_err
);
319 qio_channel_set_delay(QIO_CHANNEL(sioc
), false);
325 static QCryptoTLSCreds
*nbd_get_tls_creds(const char *id
, Error
**errp
)
328 QCryptoTLSCreds
*creds
;
330 obj
= object_resolve_path_component(
331 object_get_objects_root(), id
);
333 error_setg(errp
, "No TLS credentials with id '%s'",
337 creds
= (QCryptoTLSCreds
*)
338 object_dynamic_cast(obj
, TYPE_QCRYPTO_TLS_CREDS
);
340 error_setg(errp
, "Object with id '%s' is not TLS credentials",
345 if (creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT
) {
347 "Expecting TLS credentials with a client endpoint");
355 static QemuOptsList nbd_runtime_opts
= {
357 .head
= QTAILQ_HEAD_INITIALIZER(nbd_runtime_opts
.head
),
361 .type
= QEMU_OPT_STRING
,
362 .help
= "TCP host to connect to",
366 .type
= QEMU_OPT_STRING
,
367 .help
= "TCP port to connect to",
371 .type
= QEMU_OPT_STRING
,
372 .help
= "Unix socket path to connect to",
376 .type
= QEMU_OPT_STRING
,
377 .help
= "Name of the NBD export to open",
381 .type
= QEMU_OPT_STRING
,
382 .help
= "ID of the TLS credentials to use",
387 static int nbd_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
390 BDRVNBDState
*s
= bs
->opaque
;
391 QemuOpts
*opts
= NULL
;
392 Error
*local_err
= NULL
;
393 QIOChannelSocket
*sioc
= NULL
;
394 QCryptoTLSCreds
*tlscreds
= NULL
;
395 const char *hostname
= NULL
;
398 opts
= qemu_opts_create(&nbd_runtime_opts
, NULL
, 0, &error_abort
);
399 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
401 error_propagate(errp
, local_err
);
405 /* Translate @host, @port, and @path to a SocketAddress */
406 if (!nbd_process_legacy_socket_options(options
, opts
, errp
)) {
410 /* Pop the config into our state object. Exit if invalid. */
411 s
->saddr
= nbd_config(s
, options
, errp
);
416 s
->export
= g_strdup(qemu_opt_get(opts
, "export"));
418 s
->tlscredsid
= g_strdup(qemu_opt_get(opts
, "tls-creds"));
420 tlscreds
= nbd_get_tls_creds(s
->tlscredsid
, errp
);
425 if (s
->saddr
->type
!= SOCKET_ADDRESS_KIND_INET
) {
426 error_setg(errp
, "TLS only supported over IP sockets");
429 hostname
= s
->saddr
->u
.inet
.data
->host
;
432 /* establish TCP connection, return error if it fails
433 * TODO: Configurable retry-until-timeout behaviour.
435 sioc
= nbd_establish_connection(s
->saddr
, errp
);
442 ret
= nbd_client_init(bs
, sioc
, s
->export
,
443 tlscreds
, hostname
, errp
);
446 object_unref(OBJECT(sioc
));
449 object_unref(OBJECT(tlscreds
));
452 qapi_free_SocketAddress(s
->saddr
);
454 g_free(s
->tlscredsid
);
460 static int nbd_co_flush(BlockDriverState
*bs
)
462 return nbd_client_co_flush(bs
);
465 static void nbd_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
467 bs
->bl
.max_pdiscard
= NBD_MAX_BUFFER_SIZE
;
468 bs
->bl
.max_transfer
= NBD_MAX_BUFFER_SIZE
;
471 static void nbd_close(BlockDriverState
*bs
)
473 BDRVNBDState
*s
= bs
->opaque
;
475 nbd_client_close(bs
);
477 qapi_free_SocketAddress(s
->saddr
);
479 g_free(s
->tlscredsid
);
482 static int64_t nbd_getlength(BlockDriverState
*bs
)
484 BDRVNBDState
*s
= bs
->opaque
;
486 return s
->client
.size
;
489 static void nbd_detach_aio_context(BlockDriverState
*bs
)
491 nbd_client_detach_aio_context(bs
);
494 static void nbd_attach_aio_context(BlockDriverState
*bs
,
495 AioContext
*new_context
)
497 nbd_client_attach_aio_context(bs
, new_context
);
500 static void nbd_refresh_filename(BlockDriverState
*bs
, QDict
*options
)
502 BDRVNBDState
*s
= bs
->opaque
;
503 QDict
*opts
= qdict_new();
504 QObject
*saddr_qdict
;
506 const char *host
= NULL
, *port
= NULL
, *path
= NULL
;
508 if (s
->saddr
->type
== SOCKET_ADDRESS_KIND_INET
) {
509 const InetSocketAddress
*inet
= s
->saddr
->u
.inet
.data
;
510 if (!inet
->has_ipv4
&& !inet
->has_ipv6
&& !inet
->has_to
) {
514 } else if (s
->saddr
->type
== SOCKET_ADDRESS_KIND_UNIX
) {
515 path
= s
->saddr
->u
.q_unix
.data
->path
;
518 qdict_put(opts
, "driver", qstring_from_str("nbd"));
520 if (path
&& s
->export
) {
521 snprintf(bs
->exact_filename
, sizeof(bs
->exact_filename
),
522 "nbd+unix:///%s?socket=%s", s
->export
, path
);
523 } else if (path
&& !s
->export
) {
524 snprintf(bs
->exact_filename
, sizeof(bs
->exact_filename
),
525 "nbd+unix://?socket=%s", path
);
526 } else if (host
&& s
->export
) {
527 snprintf(bs
->exact_filename
, sizeof(bs
->exact_filename
),
528 "nbd://%s:%s/%s", host
, port
, s
->export
);
529 } else if (host
&& !s
->export
) {
530 snprintf(bs
->exact_filename
, sizeof(bs
->exact_filename
),
531 "nbd://%s:%s", host
, port
);
534 ov
= qobject_output_visitor_new(&saddr_qdict
);
535 visit_type_SocketAddress(ov
, NULL
, &s
->saddr
, &error_abort
);
536 visit_complete(ov
, &saddr_qdict
);
537 assert(qobject_type(saddr_qdict
) == QTYPE_QDICT
);
539 qdict_put_obj(opts
, "server", saddr_qdict
);
542 qdict_put(opts
, "export", qstring_from_str(s
->export
));
545 qdict_put(opts
, "tls-creds", qstring_from_str(s
->tlscredsid
));
549 bs
->full_open_options
= opts
;
552 static BlockDriver bdrv_nbd
= {
553 .format_name
= "nbd",
554 .protocol_name
= "nbd",
555 .instance_size
= sizeof(BDRVNBDState
),
556 .bdrv_parse_filename
= nbd_parse_filename
,
557 .bdrv_file_open
= nbd_open
,
558 .bdrv_co_preadv
= nbd_client_co_preadv
,
559 .bdrv_co_pwritev
= nbd_client_co_pwritev
,
560 .bdrv_close
= nbd_close
,
561 .bdrv_co_flush_to_os
= nbd_co_flush
,
562 .bdrv_co_pdiscard
= nbd_client_co_pdiscard
,
563 .bdrv_refresh_limits
= nbd_refresh_limits
,
564 .bdrv_getlength
= nbd_getlength
,
565 .bdrv_detach_aio_context
= nbd_detach_aio_context
,
566 .bdrv_attach_aio_context
= nbd_attach_aio_context
,
567 .bdrv_refresh_filename
= nbd_refresh_filename
,
570 static BlockDriver bdrv_nbd_tcp
= {
571 .format_name
= "nbd",
572 .protocol_name
= "nbd+tcp",
573 .instance_size
= sizeof(BDRVNBDState
),
574 .bdrv_parse_filename
= nbd_parse_filename
,
575 .bdrv_file_open
= nbd_open
,
576 .bdrv_co_preadv
= nbd_client_co_preadv
,
577 .bdrv_co_pwritev
= nbd_client_co_pwritev
,
578 .bdrv_close
= nbd_close
,
579 .bdrv_co_flush_to_os
= nbd_co_flush
,
580 .bdrv_co_pdiscard
= nbd_client_co_pdiscard
,
581 .bdrv_refresh_limits
= nbd_refresh_limits
,
582 .bdrv_getlength
= nbd_getlength
,
583 .bdrv_detach_aio_context
= nbd_detach_aio_context
,
584 .bdrv_attach_aio_context
= nbd_attach_aio_context
,
585 .bdrv_refresh_filename
= nbd_refresh_filename
,
588 static BlockDriver bdrv_nbd_unix
= {
589 .format_name
= "nbd",
590 .protocol_name
= "nbd+unix",
591 .instance_size
= sizeof(BDRVNBDState
),
592 .bdrv_parse_filename
= nbd_parse_filename
,
593 .bdrv_file_open
= nbd_open
,
594 .bdrv_co_preadv
= nbd_client_co_preadv
,
595 .bdrv_co_pwritev
= nbd_client_co_pwritev
,
596 .bdrv_close
= nbd_close
,
597 .bdrv_co_flush_to_os
= nbd_co_flush
,
598 .bdrv_co_pdiscard
= nbd_client_co_pdiscard
,
599 .bdrv_refresh_limits
= nbd_refresh_limits
,
600 .bdrv_getlength
= nbd_getlength
,
601 .bdrv_detach_aio_context
= nbd_detach_aio_context
,
602 .bdrv_attach_aio_context
= nbd_attach_aio_context
,
603 .bdrv_refresh_filename
= nbd_refresh_filename
,
606 static void bdrv_nbd_init(void)
608 bdrv_register(&bdrv_nbd
);
609 bdrv_register(&bdrv_nbd_tcp
);
610 bdrv_register(&bdrv_nbd_unix
);
613 block_init(bdrv_nbd_init
);