1 /* 2 * QEMU Block driver for NBD 3 * 4 * Copyright (C) 2008 Bull S.A.S. 5 * Author: Laurent Vivier <Laurent.Vivier@bull.net> 6 * 7 * Some parts: 8 * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws> 9 * 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: 16 * 17 * The above copyright notice and this permission notice shall be included in 18 * all copies or substantial portions of the Software. 19 * 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 26 * THE SOFTWARE. 27 */ 28 29 #include "qemu/osdep.h" 30 #include "block/nbd-client.h" 31 #include "qemu/uri.h" 32 #include "block/block_int.h" 33 #include "qemu/module.h" 34 #include "qapi/qmp/qdict.h" 35 #include "qapi/qmp/qjson.h" 36 #include "qapi/qmp/qint.h" 37 #include "qapi/qmp/qstring.h" 38 39 40 #define EN_OPTSTR ":exportname=" 41 42 typedef struct BDRVNBDState { 43 NbdClientSession client; 44 } BDRVNBDState; 45 46 static int nbd_parse_uri(const char *filename, QDict *options) 47 { 48 URI *uri; 49 const char *p; 50 QueryParams *qp = NULL; 51 int ret = 0; 52 bool is_unix; 53 54 uri = uri_parse(filename); 55 if (!uri) { 56 return -EINVAL; 57 } 58 59 /* transport */ 60 if (!strcmp(uri->scheme, "nbd")) { 61 is_unix = false; 62 } else if (!strcmp(uri->scheme, "nbd+tcp")) { 63 is_unix = false; 64 } else if (!strcmp(uri->scheme, "nbd+unix")) { 65 is_unix = true; 66 } else { 67 ret = -EINVAL; 68 goto out; 69 } 70 71 p = uri->path ? uri->path : "/"; 72 p += strspn(p, "/"); 73 if (p[0]) { 74 qdict_put(options, "export", qstring_from_str(p)); 75 } 76 77 qp = query_params_parse(uri->query); 78 if (qp->n > 1 || (is_unix && !qp->n) || (!is_unix && qp->n)) { 79 ret = -EINVAL; 80 goto out; 81 } 82 83 if (is_unix) { 84 /* nbd+unix:///export?socket=path */ 85 if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) { 86 ret = -EINVAL; 87 goto out; 88 } 89 qdict_put(options, "path", qstring_from_str(qp->p[0].value)); 90 } else { 91 QString *host; 92 /* nbd[+tcp]://host[:port]/export */ 93 if (!uri->server) { 94 ret = -EINVAL; 95 goto out; 96 } 97 98 /* strip braces from literal IPv6 address */ 99 if (uri->server[0] == '[') { 100 host = qstring_from_substr(uri->server, 1, 101 strlen(uri->server) - 2); 102 } else { 103 host = qstring_from_str(uri->server); 104 } 105 106 qdict_put(options, "host", host); 107 if (uri->port) { 108 char* port_str = g_strdup_printf("%d", uri->port); 109 qdict_put(options, "port", qstring_from_str(port_str)); 110 g_free(port_str); 111 } 112 } 113 114 out: 115 if (qp) { 116 query_params_free(qp); 117 } 118 uri_free(uri); 119 return ret; 120 } 121 122 static void nbd_parse_filename(const char *filename, QDict *options, 123 Error **errp) 124 { 125 char *file; 126 char *export_name; 127 const char *host_spec; 128 const char *unixpath; 129 130 if (qdict_haskey(options, "host") 131 || qdict_haskey(options, "port") 132 || qdict_haskey(options, "path")) 133 { 134 error_setg(errp, "host/port/path and a file name may not be specified " 135 "at the same time"); 136 return; 137 } 138 139 if (strstr(filename, "://")) { 140 int ret = nbd_parse_uri(filename, options); 141 if (ret < 0) { 142 error_setg(errp, "No valid URL specified"); 143 } 144 return; 145 } 146 147 file = g_strdup(filename); 148 149 export_name = strstr(file, EN_OPTSTR); 150 if (export_name) { 151 if (export_name[strlen(EN_OPTSTR)] == 0) { 152 goto out; 153 } 154 export_name[0] = 0; /* truncate 'file' */ 155 export_name += strlen(EN_OPTSTR); 156 157 qdict_put(options, "export", qstring_from_str(export_name)); 158 } 159 160 /* extract the host_spec - fail if it's not nbd:... */ 161 if (!strstart(file, "nbd:", &host_spec)) { 162 error_setg(errp, "File name string for NBD must start with 'nbd:'"); 163 goto out; 164 } 165 166 if (!*host_spec) { 167 goto out; 168 } 169 170 /* are we a UNIX or TCP socket? */ 171 if (strstart(host_spec, "unix:", &unixpath)) { 172 qdict_put(options, "path", qstring_from_str(unixpath)); 173 } else { 174 InetSocketAddress *addr = NULL; 175 176 addr = inet_parse(host_spec, errp); 177 if (!addr) { 178 goto out; 179 } 180 181 qdict_put(options, "host", qstring_from_str(addr->host)); 182 qdict_put(options, "port", qstring_from_str(addr->port)); 183 qapi_free_InetSocketAddress(addr); 184 } 185 186 out: 187 g_free(file); 188 } 189 190 static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options, char **export, 191 Error **errp) 192 { 193 SocketAddress *saddr; 194 195 if (qdict_haskey(options, "path") == qdict_haskey(options, "host")) { 196 if (qdict_haskey(options, "path")) { 197 error_setg(errp, "path and host may not be used at the same time."); 198 } else { 199 error_setg(errp, "one of path and host must be specified."); 200 } 201 return NULL; 202 } 203 204 saddr = g_new0(SocketAddress, 1); 205 206 if (qdict_haskey(options, "path")) { 207 UnixSocketAddress *q_unix; 208 saddr->type = SOCKET_ADDRESS_KIND_UNIX; 209 q_unix = saddr->u.q_unix = g_new0(UnixSocketAddress, 1); 210 q_unix->path = g_strdup(qdict_get_str(options, "path")); 211 qdict_del(options, "path"); 212 } else { 213 InetSocketAddress *inet; 214 saddr->type = SOCKET_ADDRESS_KIND_INET; 215 inet = saddr->u.inet = g_new0(InetSocketAddress, 1); 216 inet->host = g_strdup(qdict_get_str(options, "host")); 217 if (!qdict_get_try_str(options, "port")) { 218 inet->port = g_strdup_printf("%d", NBD_DEFAULT_PORT); 219 } else { 220 inet->port = g_strdup(qdict_get_str(options, "port")); 221 } 222 qdict_del(options, "host"); 223 qdict_del(options, "port"); 224 } 225 226 s->client.is_unix = saddr->type == SOCKET_ADDRESS_KIND_UNIX; 227 228 *export = g_strdup(qdict_get_try_str(options, "export")); 229 if (*export) { 230 qdict_del(options, "export"); 231 } 232 233 return saddr; 234 } 235 236 NbdClientSession *nbd_get_client_session(BlockDriverState *bs) 237 { 238 BDRVNBDState *s = bs->opaque; 239 return &s->client; 240 } 241 242 static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr, 243 Error **errp) 244 { 245 QIOChannelSocket *sioc; 246 Error *local_err = NULL; 247 248 sioc = qio_channel_socket_new(); 249 250 qio_channel_socket_connect_sync(sioc, 251 saddr, 252 &local_err); 253 if (local_err) { 254 error_propagate(errp, local_err); 255 return NULL; 256 } 257 258 qio_channel_set_delay(QIO_CHANNEL(sioc), false); 259 260 return sioc; 261 } 262 263 264 static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp) 265 { 266 Object *obj; 267 QCryptoTLSCreds *creds; 268 269 obj = object_resolve_path_component( 270 object_get_objects_root(), id); 271 if (!obj) { 272 error_setg(errp, "No TLS credentials with id '%s'", 273 id); 274 return NULL; 275 } 276 creds = (QCryptoTLSCreds *) 277 object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS); 278 if (!creds) { 279 error_setg(errp, "Object with id '%s' is not TLS credentials", 280 id); 281 return NULL; 282 } 283 284 if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) { 285 error_setg(errp, 286 "Expecting TLS credentials with a client endpoint"); 287 return NULL; 288 } 289 object_ref(obj); 290 return creds; 291 } 292 293 294 static int nbd_open(BlockDriverState *bs, QDict *options, int flags, 295 Error **errp) 296 { 297 BDRVNBDState *s = bs->opaque; 298 char *export = NULL; 299 QIOChannelSocket *sioc = NULL; 300 SocketAddress *saddr; 301 const char *tlscredsid; 302 QCryptoTLSCreds *tlscreds = NULL; 303 const char *hostname = NULL; 304 int ret = -EINVAL; 305 306 /* Pop the config into our state object. Exit if invalid. */ 307 saddr = nbd_config(s, options, &export, errp); 308 if (!saddr) { 309 goto error; 310 } 311 312 tlscredsid = g_strdup(qdict_get_try_str(options, "tls-creds")); 313 if (tlscredsid) { 314 qdict_del(options, "tls-creds"); 315 tlscreds = nbd_get_tls_creds(tlscredsid, errp); 316 if (!tlscreds) { 317 goto error; 318 } 319 320 if (saddr->type != SOCKET_ADDRESS_KIND_INET) { 321 error_setg(errp, "TLS only supported over IP sockets"); 322 goto error; 323 } 324 hostname = saddr->u.inet->host; 325 } 326 327 /* establish TCP connection, return error if it fails 328 * TODO: Configurable retry-until-timeout behaviour. 329 */ 330 sioc = nbd_establish_connection(saddr, errp); 331 if (!sioc) { 332 ret = -ECONNREFUSED; 333 goto error; 334 } 335 336 /* NBD handshake */ 337 ret = nbd_client_init(bs, sioc, export, 338 tlscreds, hostname, errp); 339 error: 340 if (sioc) { 341 object_unref(OBJECT(sioc)); 342 } 343 if (tlscreds) { 344 object_unref(OBJECT(tlscreds)); 345 } 346 qapi_free_SocketAddress(saddr); 347 g_free(export); 348 return ret; 349 } 350 351 static int nbd_co_readv(BlockDriverState *bs, int64_t sector_num, 352 int nb_sectors, QEMUIOVector *qiov) 353 { 354 return nbd_client_co_readv(bs, sector_num, nb_sectors, qiov); 355 } 356 357 static int nbd_co_writev(BlockDriverState *bs, int64_t sector_num, 358 int nb_sectors, QEMUIOVector *qiov) 359 { 360 return nbd_client_co_writev(bs, sector_num, nb_sectors, qiov); 361 } 362 363 static int nbd_co_flush(BlockDriverState *bs) 364 { 365 return nbd_client_co_flush(bs); 366 } 367 368 static void nbd_refresh_limits(BlockDriverState *bs, Error **errp) 369 { 370 bs->bl.max_discard = UINT32_MAX >> BDRV_SECTOR_BITS; 371 bs->bl.max_transfer_length = UINT32_MAX >> BDRV_SECTOR_BITS; 372 } 373 374 static int nbd_co_discard(BlockDriverState *bs, int64_t sector_num, 375 int nb_sectors) 376 { 377 return nbd_client_co_discard(bs, sector_num, nb_sectors); 378 } 379 380 static void nbd_close(BlockDriverState *bs) 381 { 382 nbd_client_close(bs); 383 } 384 385 static int64_t nbd_getlength(BlockDriverState *bs) 386 { 387 BDRVNBDState *s = bs->opaque; 388 389 return s->client.size; 390 } 391 392 static void nbd_detach_aio_context(BlockDriverState *bs) 393 { 394 nbd_client_detach_aio_context(bs); 395 } 396 397 static void nbd_attach_aio_context(BlockDriverState *bs, 398 AioContext *new_context) 399 { 400 nbd_client_attach_aio_context(bs, new_context); 401 } 402 403 static void nbd_refresh_filename(BlockDriverState *bs, QDict *options) 404 { 405 QDict *opts = qdict_new(); 406 const char *path = qdict_get_try_str(options, "path"); 407 const char *host = qdict_get_try_str(options, "host"); 408 const char *port = qdict_get_try_str(options, "port"); 409 const char *export = qdict_get_try_str(options, "export"); 410 const char *tlscreds = qdict_get_try_str(options, "tls-creds"); 411 412 qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("nbd"))); 413 414 if (path && export) { 415 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 416 "nbd+unix:///%s?socket=%s", export, path); 417 } else if (path && !export) { 418 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 419 "nbd+unix://?socket=%s", path); 420 } else if (!path && export && port) { 421 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 422 "nbd://%s:%s/%s", host, port, export); 423 } else if (!path && export && !port) { 424 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 425 "nbd://%s/%s", host, export); 426 } else if (!path && !export && port) { 427 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 428 "nbd://%s:%s", host, port); 429 } else if (!path && !export && !port) { 430 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 431 "nbd://%s", host); 432 } 433 434 if (path) { 435 qdict_put_obj(opts, "path", QOBJECT(qstring_from_str(path))); 436 } else if (port) { 437 qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host))); 438 qdict_put_obj(opts, "port", QOBJECT(qstring_from_str(port))); 439 } else { 440 qdict_put_obj(opts, "host", QOBJECT(qstring_from_str(host))); 441 } 442 if (export) { 443 qdict_put_obj(opts, "export", QOBJECT(qstring_from_str(export))); 444 } 445 if (tlscreds) { 446 qdict_put_obj(opts, "tls-creds", QOBJECT(qstring_from_str(tlscreds))); 447 } 448 449 bs->full_open_options = opts; 450 } 451 452 static BlockDriver bdrv_nbd = { 453 .format_name = "nbd", 454 .protocol_name = "nbd", 455 .instance_size = sizeof(BDRVNBDState), 456 .bdrv_parse_filename = nbd_parse_filename, 457 .bdrv_file_open = nbd_open, 458 .bdrv_co_readv = nbd_co_readv, 459 .bdrv_co_writev = nbd_co_writev, 460 .bdrv_close = nbd_close, 461 .bdrv_co_flush_to_os = nbd_co_flush, 462 .bdrv_co_discard = nbd_co_discard, 463 .bdrv_refresh_limits = nbd_refresh_limits, 464 .bdrv_getlength = nbd_getlength, 465 .bdrv_detach_aio_context = nbd_detach_aio_context, 466 .bdrv_attach_aio_context = nbd_attach_aio_context, 467 .bdrv_refresh_filename = nbd_refresh_filename, 468 }; 469 470 static BlockDriver bdrv_nbd_tcp = { 471 .format_name = "nbd", 472 .protocol_name = "nbd+tcp", 473 .instance_size = sizeof(BDRVNBDState), 474 .bdrv_parse_filename = nbd_parse_filename, 475 .bdrv_file_open = nbd_open, 476 .bdrv_co_readv = nbd_co_readv, 477 .bdrv_co_writev = nbd_co_writev, 478 .bdrv_close = nbd_close, 479 .bdrv_co_flush_to_os = nbd_co_flush, 480 .bdrv_co_discard = nbd_co_discard, 481 .bdrv_refresh_limits = nbd_refresh_limits, 482 .bdrv_getlength = nbd_getlength, 483 .bdrv_detach_aio_context = nbd_detach_aio_context, 484 .bdrv_attach_aio_context = nbd_attach_aio_context, 485 .bdrv_refresh_filename = nbd_refresh_filename, 486 }; 487 488 static BlockDriver bdrv_nbd_unix = { 489 .format_name = "nbd", 490 .protocol_name = "nbd+unix", 491 .instance_size = sizeof(BDRVNBDState), 492 .bdrv_parse_filename = nbd_parse_filename, 493 .bdrv_file_open = nbd_open, 494 .bdrv_co_readv = nbd_co_readv, 495 .bdrv_co_writev = nbd_co_writev, 496 .bdrv_close = nbd_close, 497 .bdrv_co_flush_to_os = nbd_co_flush, 498 .bdrv_co_discard = nbd_co_discard, 499 .bdrv_refresh_limits = nbd_refresh_limits, 500 .bdrv_getlength = nbd_getlength, 501 .bdrv_detach_aio_context = nbd_detach_aio_context, 502 .bdrv_attach_aio_context = nbd_attach_aio_context, 503 .bdrv_refresh_filename = nbd_refresh_filename, 504 }; 505 506 static void bdrv_nbd_init(void) 507 { 508 bdrv_register(&bdrv_nbd); 509 bdrv_register(&bdrv_nbd_tcp); 510 bdrv_register(&bdrv_nbd_unix); 511 } 512 513 block_init(bdrv_nbd_init); 514