1 /* 2 * QEMU Block driver for native access to files on NFS shares 3 * 4 * Copyright (c) 2014-2016 Peter Lieven <pl@kamp.de> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 25 #include "qemu/osdep.h" 26 27 #include <poll.h> 28 #include "qemu-common.h" 29 #include "qemu/config-file.h" 30 #include "qemu/error-report.h" 31 #include "qapi/error.h" 32 #include "block/block_int.h" 33 #include "trace.h" 34 #include "qemu/iov.h" 35 #include "qemu/uri.h" 36 #include "qemu/cutils.h" 37 #include "sysemu/sysemu.h" 38 #include "qapi/qmp/qdict.h" 39 #include "qapi/qmp/qint.h" 40 #include "qapi/qmp/qstring.h" 41 #include "qapi-visit.h" 42 #include "qapi/qobject-input-visitor.h" 43 #include "qapi/qobject-output-visitor.h" 44 #include <nfsc/libnfs.h> 45 46 47 #define QEMU_NFS_MAX_READAHEAD_SIZE 1048576 48 #define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE) 49 #define QEMU_NFS_MAX_DEBUG_LEVEL 2 50 51 typedef struct NFSClient { 52 struct nfs_context *context; 53 struct nfsfh *fh; 54 int events; 55 bool has_zero_init; 56 AioContext *aio_context; 57 QemuMutex mutex; 58 blkcnt_t st_blocks; 59 bool cache_used; 60 NFSServer *server; 61 char *path; 62 int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug; 63 } NFSClient; 64 65 typedef struct NFSRPC { 66 BlockDriverState *bs; 67 int ret; 68 int complete; 69 QEMUIOVector *iov; 70 struct stat *st; 71 Coroutine *co; 72 NFSClient *client; 73 } NFSRPC; 74 75 static int nfs_parse_uri(const char *filename, QDict *options, Error **errp) 76 { 77 URI *uri = NULL; 78 QueryParams *qp = NULL; 79 int ret = -EINVAL, i; 80 81 uri = uri_parse(filename); 82 if (!uri) { 83 error_setg(errp, "Invalid URI specified"); 84 goto out; 85 } 86 if (strcmp(uri->scheme, "nfs") != 0) { 87 error_setg(errp, "URI scheme must be 'nfs'"); 88 goto out; 89 } 90 91 if (!uri->server) { 92 error_setg(errp, "missing hostname in URI"); 93 goto out; 94 } 95 96 if (!uri->path) { 97 error_setg(errp, "missing file path in URI"); 98 goto out; 99 } 100 101 qp = query_params_parse(uri->query); 102 if (!qp) { 103 error_setg(errp, "could not parse query parameters"); 104 goto out; 105 } 106 107 qdict_put(options, "server.host", qstring_from_str(uri->server)); 108 qdict_put(options, "server.type", qstring_from_str("inet")); 109 qdict_put(options, "path", qstring_from_str(uri->path)); 110 111 for (i = 0; i < qp->n; i++) { 112 unsigned long long val; 113 if (!qp->p[i].value) { 114 error_setg(errp, "Value for NFS parameter expected: %s", 115 qp->p[i].name); 116 goto out; 117 } 118 if (parse_uint_full(qp->p[i].value, &val, 0)) { 119 error_setg(errp, "Illegal value for NFS parameter: %s", 120 qp->p[i].name); 121 goto out; 122 } 123 if (!strcmp(qp->p[i].name, "uid")) { 124 qdict_put(options, "user", 125 qstring_from_str(qp->p[i].value)); 126 } else if (!strcmp(qp->p[i].name, "gid")) { 127 qdict_put(options, "group", 128 qstring_from_str(qp->p[i].value)); 129 } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) { 130 qdict_put(options, "tcp-syn-count", 131 qstring_from_str(qp->p[i].value)); 132 } else if (!strcmp(qp->p[i].name, "readahead")) { 133 qdict_put(options, "readahead-size", 134 qstring_from_str(qp->p[i].value)); 135 } else if (!strcmp(qp->p[i].name, "pagecache")) { 136 qdict_put(options, "page-cache-size", 137 qstring_from_str(qp->p[i].value)); 138 } else if (!strcmp(qp->p[i].name, "debug")) { 139 qdict_put(options, "debug", 140 qstring_from_str(qp->p[i].value)); 141 } else { 142 error_setg(errp, "Unknown NFS parameter name: %s", 143 qp->p[i].name); 144 goto out; 145 } 146 } 147 ret = 0; 148 out: 149 if (qp) { 150 query_params_free(qp); 151 } 152 if (uri) { 153 uri_free(uri); 154 } 155 return ret; 156 } 157 158 static bool nfs_has_filename_options_conflict(QDict *options, Error **errp) 159 { 160 const QDictEntry *qe; 161 162 for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) { 163 if (!strcmp(qe->key, "host") || 164 !strcmp(qe->key, "path") || 165 !strcmp(qe->key, "user") || 166 !strcmp(qe->key, "group") || 167 !strcmp(qe->key, "tcp-syn-count") || 168 !strcmp(qe->key, "readahead-size") || 169 !strcmp(qe->key, "page-cache-size") || 170 !strcmp(qe->key, "debug") || 171 strstart(qe->key, "server.", NULL)) 172 { 173 error_setg(errp, "Option %s cannot be used with a filename", 174 qe->key); 175 return true; 176 } 177 } 178 179 return false; 180 } 181 182 static void nfs_parse_filename(const char *filename, QDict *options, 183 Error **errp) 184 { 185 if (nfs_has_filename_options_conflict(options, errp)) { 186 return; 187 } 188 189 nfs_parse_uri(filename, options, errp); 190 } 191 192 static void nfs_process_read(void *arg); 193 static void nfs_process_write(void *arg); 194 195 /* Called with QemuMutex held. */ 196 static void nfs_set_events(NFSClient *client) 197 { 198 int ev = nfs_which_events(client->context); 199 if (ev != client->events) { 200 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 201 false, 202 (ev & POLLIN) ? nfs_process_read : NULL, 203 (ev & POLLOUT) ? nfs_process_write : NULL, 204 NULL, client); 205 206 } 207 client->events = ev; 208 } 209 210 static void nfs_process_read(void *arg) 211 { 212 NFSClient *client = arg; 213 214 qemu_mutex_lock(&client->mutex); 215 nfs_service(client->context, POLLIN); 216 nfs_set_events(client); 217 qemu_mutex_unlock(&client->mutex); 218 } 219 220 static void nfs_process_write(void *arg) 221 { 222 NFSClient *client = arg; 223 224 qemu_mutex_lock(&client->mutex); 225 nfs_service(client->context, POLLOUT); 226 nfs_set_events(client); 227 qemu_mutex_unlock(&client->mutex); 228 } 229 230 static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task) 231 { 232 *task = (NFSRPC) { 233 .co = qemu_coroutine_self(), 234 .bs = bs, 235 .client = bs->opaque, 236 }; 237 } 238 239 static void nfs_co_generic_bh_cb(void *opaque) 240 { 241 NFSRPC *task = opaque; 242 243 task->complete = 1; 244 aio_co_wake(task->co); 245 } 246 247 /* Called (via nfs_service) with QemuMutex held. */ 248 static void 249 nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, 250 void *private_data) 251 { 252 NFSRPC *task = private_data; 253 task->ret = ret; 254 assert(!task->st); 255 if (task->ret > 0 && task->iov) { 256 if (task->ret <= task->iov->size) { 257 qemu_iovec_from_buf(task->iov, 0, data, task->ret); 258 } else { 259 task->ret = -EIO; 260 } 261 } 262 if (task->ret < 0) { 263 error_report("NFS Error: %s", nfs_get_error(nfs)); 264 } 265 aio_bh_schedule_oneshot(task->client->aio_context, 266 nfs_co_generic_bh_cb, task); 267 } 268 269 static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offset, 270 uint64_t bytes, QEMUIOVector *iov, 271 int flags) 272 { 273 NFSClient *client = bs->opaque; 274 NFSRPC task; 275 276 nfs_co_init_task(bs, &task); 277 task.iov = iov; 278 279 qemu_mutex_lock(&client->mutex); 280 if (nfs_pread_async(client->context, client->fh, 281 offset, bytes, nfs_co_generic_cb, &task) != 0) { 282 qemu_mutex_unlock(&client->mutex); 283 return -ENOMEM; 284 } 285 286 nfs_set_events(client); 287 qemu_mutex_unlock(&client->mutex); 288 while (!task.complete) { 289 qemu_coroutine_yield(); 290 } 291 292 if (task.ret < 0) { 293 return task.ret; 294 } 295 296 /* zero pad short reads */ 297 if (task.ret < iov->size) { 298 qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret); 299 } 300 301 return 0; 302 } 303 304 static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offset, 305 uint64_t bytes, QEMUIOVector *iov, 306 int flags) 307 { 308 NFSClient *client = bs->opaque; 309 NFSRPC task; 310 char *buf = NULL; 311 bool my_buffer = false; 312 313 nfs_co_init_task(bs, &task); 314 315 if (iov->niov != 1) { 316 buf = g_try_malloc(bytes); 317 if (bytes && buf == NULL) { 318 return -ENOMEM; 319 } 320 qemu_iovec_to_buf(iov, 0, buf, bytes); 321 my_buffer = true; 322 } else { 323 buf = iov->iov[0].iov_base; 324 } 325 326 qemu_mutex_lock(&client->mutex); 327 if (nfs_pwrite_async(client->context, client->fh, 328 offset, bytes, buf, 329 nfs_co_generic_cb, &task) != 0) { 330 qemu_mutex_unlock(&client->mutex); 331 if (my_buffer) { 332 g_free(buf); 333 } 334 return -ENOMEM; 335 } 336 337 nfs_set_events(client); 338 qemu_mutex_unlock(&client->mutex); 339 while (!task.complete) { 340 qemu_coroutine_yield(); 341 } 342 343 if (my_buffer) { 344 g_free(buf); 345 } 346 347 if (task.ret != bytes) { 348 return task.ret < 0 ? task.ret : -EIO; 349 } 350 351 return 0; 352 } 353 354 static int coroutine_fn nfs_co_flush(BlockDriverState *bs) 355 { 356 NFSClient *client = bs->opaque; 357 NFSRPC task; 358 359 nfs_co_init_task(bs, &task); 360 361 qemu_mutex_lock(&client->mutex); 362 if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, 363 &task) != 0) { 364 qemu_mutex_unlock(&client->mutex); 365 return -ENOMEM; 366 } 367 368 nfs_set_events(client); 369 qemu_mutex_unlock(&client->mutex); 370 while (!task.complete) { 371 qemu_coroutine_yield(); 372 } 373 374 return task.ret; 375 } 376 377 static QemuOptsList runtime_opts = { 378 .name = "nfs", 379 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 380 .desc = { 381 { 382 .name = "path", 383 .type = QEMU_OPT_STRING, 384 .help = "Path of the image on the host", 385 }, 386 { 387 .name = "user", 388 .type = QEMU_OPT_NUMBER, 389 .help = "UID value to use when talking to the server", 390 }, 391 { 392 .name = "group", 393 .type = QEMU_OPT_NUMBER, 394 .help = "GID value to use when talking to the server", 395 }, 396 { 397 .name = "tcp-syn-count", 398 .type = QEMU_OPT_NUMBER, 399 .help = "Number of SYNs to send during the session establish", 400 }, 401 { 402 .name = "readahead-size", 403 .type = QEMU_OPT_NUMBER, 404 .help = "Set the readahead size in bytes", 405 }, 406 { 407 .name = "page-cache-size", 408 .type = QEMU_OPT_NUMBER, 409 .help = "Set the pagecache size in bytes", 410 }, 411 { 412 .name = "debug", 413 .type = QEMU_OPT_NUMBER, 414 .help = "Set the NFS debug level (max 2)", 415 }, 416 { /* end of list */ } 417 }, 418 }; 419 420 static void nfs_detach_aio_context(BlockDriverState *bs) 421 { 422 NFSClient *client = bs->opaque; 423 424 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 425 false, NULL, NULL, NULL, NULL); 426 client->events = 0; 427 } 428 429 static void nfs_attach_aio_context(BlockDriverState *bs, 430 AioContext *new_context) 431 { 432 NFSClient *client = bs->opaque; 433 434 client->aio_context = new_context; 435 nfs_set_events(client); 436 } 437 438 static void nfs_client_close(NFSClient *client) 439 { 440 if (client->context) { 441 if (client->fh) { 442 nfs_close(client->context, client->fh); 443 } 444 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 445 false, NULL, NULL, NULL, NULL); 446 nfs_destroy_context(client->context); 447 } 448 memset(client, 0, sizeof(NFSClient)); 449 } 450 451 static void nfs_file_close(BlockDriverState *bs) 452 { 453 NFSClient *client = bs->opaque; 454 nfs_client_close(client); 455 qemu_mutex_destroy(&client->mutex); 456 } 457 458 static NFSServer *nfs_config(QDict *options, Error **errp) 459 { 460 NFSServer *server = NULL; 461 QDict *addr = NULL; 462 QObject *crumpled_addr = NULL; 463 Visitor *iv = NULL; 464 Error *local_error = NULL; 465 466 qdict_extract_subqdict(options, &addr, "server."); 467 if (!qdict_size(addr)) { 468 error_setg(errp, "NFS server address missing"); 469 goto out; 470 } 471 472 crumpled_addr = qdict_crumple(addr, errp); 473 if (!crumpled_addr) { 474 goto out; 475 } 476 477 /* 478 * Caution: this works only because all scalar members of 479 * NFSServer are QString in @crumpled_addr. The visitor expects 480 * @crumpled_addr to be typed according to the QAPI schema. It 481 * is when @options come from -blockdev or blockdev_add. But when 482 * they come from -drive, they're all QString. 483 */ 484 iv = qobject_input_visitor_new(crumpled_addr); 485 visit_type_NFSServer(iv, NULL, &server, &local_error); 486 if (local_error) { 487 error_propagate(errp, local_error); 488 goto out; 489 } 490 491 out: 492 QDECREF(addr); 493 qobject_decref(crumpled_addr); 494 visit_free(iv); 495 return server; 496 } 497 498 499 static int64_t nfs_client_open(NFSClient *client, QDict *options, 500 int flags, int open_flags, Error **errp) 501 { 502 int ret = -EINVAL; 503 QemuOpts *opts = NULL; 504 Error *local_err = NULL; 505 struct stat st; 506 char *file = NULL, *strp = NULL; 507 508 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 509 qemu_opts_absorb_qdict(opts, options, &local_err); 510 if (local_err) { 511 error_propagate(errp, local_err); 512 ret = -EINVAL; 513 goto fail; 514 } 515 516 client->path = g_strdup(qemu_opt_get(opts, "path")); 517 if (!client->path) { 518 ret = -EINVAL; 519 error_setg(errp, "No path was specified"); 520 goto fail; 521 } 522 523 strp = strrchr(client->path, '/'); 524 if (strp == NULL) { 525 error_setg(errp, "Invalid URL specified"); 526 goto fail; 527 } 528 file = g_strdup(strp); 529 *strp = 0; 530 531 /* Pop the config into our state object, Exit if invalid */ 532 client->server = nfs_config(options, errp); 533 if (!client->server) { 534 ret = -EINVAL; 535 goto fail; 536 } 537 538 client->context = nfs_init_context(); 539 if (client->context == NULL) { 540 error_setg(errp, "Failed to init NFS context"); 541 goto fail; 542 } 543 544 if (qemu_opt_get(opts, "user")) { 545 client->uid = qemu_opt_get_number(opts, "user", 0); 546 nfs_set_uid(client->context, client->uid); 547 } 548 549 if (qemu_opt_get(opts, "group")) { 550 client->gid = qemu_opt_get_number(opts, "group", 0); 551 nfs_set_gid(client->context, client->gid); 552 } 553 554 if (qemu_opt_get(opts, "tcp-syn-count")) { 555 client->tcp_syncnt = qemu_opt_get_number(opts, "tcp-syn-count", 0); 556 nfs_set_tcp_syncnt(client->context, client->tcp_syncnt); 557 } 558 559 #ifdef LIBNFS_FEATURE_READAHEAD 560 if (qemu_opt_get(opts, "readahead-size")) { 561 if (open_flags & BDRV_O_NOCACHE) { 562 error_setg(errp, "Cannot enable NFS readahead " 563 "if cache.direct = on"); 564 goto fail; 565 } 566 client->readahead = qemu_opt_get_number(opts, "readahead-size", 0); 567 if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) { 568 error_report("NFS Warning: Truncating NFS readahead " 569 "size to %d", QEMU_NFS_MAX_READAHEAD_SIZE); 570 client->readahead = QEMU_NFS_MAX_READAHEAD_SIZE; 571 } 572 nfs_set_readahead(client->context, client->readahead); 573 #ifdef LIBNFS_FEATURE_PAGECACHE 574 nfs_set_pagecache_ttl(client->context, 0); 575 #endif 576 client->cache_used = true; 577 } 578 #endif 579 580 #ifdef LIBNFS_FEATURE_PAGECACHE 581 if (qemu_opt_get(opts, "page-cache-size")) { 582 if (open_flags & BDRV_O_NOCACHE) { 583 error_setg(errp, "Cannot enable NFS pagecache " 584 "if cache.direct = on"); 585 goto fail; 586 } 587 client->pagecache = qemu_opt_get_number(opts, "page-cache-size", 0); 588 if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) { 589 error_report("NFS Warning: Truncating NFS pagecache " 590 "size to %d pages", QEMU_NFS_MAX_PAGECACHE_SIZE); 591 client->pagecache = QEMU_NFS_MAX_PAGECACHE_SIZE; 592 } 593 nfs_set_pagecache(client->context, client->pagecache); 594 nfs_set_pagecache_ttl(client->context, 0); 595 client->cache_used = true; 596 } 597 #endif 598 599 #ifdef LIBNFS_FEATURE_DEBUG 600 if (qemu_opt_get(opts, "debug")) { 601 client->debug = qemu_opt_get_number(opts, "debug", 0); 602 /* limit the maximum debug level to avoid potential flooding 603 * of our log files. */ 604 if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) { 605 error_report("NFS Warning: Limiting NFS debug level " 606 "to %d", QEMU_NFS_MAX_DEBUG_LEVEL); 607 client->debug = QEMU_NFS_MAX_DEBUG_LEVEL; 608 } 609 nfs_set_debug(client->context, client->debug); 610 } 611 #endif 612 613 ret = nfs_mount(client->context, client->server->host, client->path); 614 if (ret < 0) { 615 error_setg(errp, "Failed to mount nfs share: %s", 616 nfs_get_error(client->context)); 617 goto fail; 618 } 619 620 if (flags & O_CREAT) { 621 ret = nfs_creat(client->context, file, 0600, &client->fh); 622 if (ret < 0) { 623 error_setg(errp, "Failed to create file: %s", 624 nfs_get_error(client->context)); 625 goto fail; 626 } 627 } else { 628 ret = nfs_open(client->context, file, flags, &client->fh); 629 if (ret < 0) { 630 error_setg(errp, "Failed to open file : %s", 631 nfs_get_error(client->context)); 632 goto fail; 633 } 634 } 635 636 ret = nfs_fstat(client->context, client->fh, &st); 637 if (ret < 0) { 638 error_setg(errp, "Failed to fstat file: %s", 639 nfs_get_error(client->context)); 640 goto fail; 641 } 642 643 ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE); 644 client->st_blocks = st.st_blocks; 645 client->has_zero_init = S_ISREG(st.st_mode); 646 *strp = '/'; 647 goto out; 648 649 fail: 650 nfs_client_close(client); 651 out: 652 qemu_opts_del(opts); 653 g_free(file); 654 return ret; 655 } 656 657 static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, 658 Error **errp) { 659 NFSClient *client = bs->opaque; 660 int64_t ret; 661 662 client->aio_context = bdrv_get_aio_context(bs); 663 664 ret = nfs_client_open(client, options, 665 (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY, 666 bs->open_flags, errp); 667 if (ret < 0) { 668 return ret; 669 } 670 qemu_mutex_init(&client->mutex); 671 bs->total_sectors = ret; 672 ret = 0; 673 return ret; 674 } 675 676 static QemuOptsList nfs_create_opts = { 677 .name = "nfs-create-opts", 678 .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head), 679 .desc = { 680 { 681 .name = BLOCK_OPT_SIZE, 682 .type = QEMU_OPT_SIZE, 683 .help = "Virtual disk size" 684 }, 685 { /* end of list */ } 686 } 687 }; 688 689 static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp) 690 { 691 int ret = 0; 692 int64_t total_size = 0; 693 NFSClient *client = g_new0(NFSClient, 1); 694 QDict *options = NULL; 695 696 client->aio_context = qemu_get_aio_context(); 697 698 /* Read out options */ 699 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 700 BDRV_SECTOR_SIZE); 701 702 options = qdict_new(); 703 ret = nfs_parse_uri(url, options, errp); 704 if (ret < 0) { 705 goto out; 706 } 707 708 ret = nfs_client_open(client, options, O_CREAT, 0, errp); 709 if (ret < 0) { 710 goto out; 711 } 712 ret = nfs_ftruncate(client->context, client->fh, total_size); 713 nfs_client_close(client); 714 out: 715 QDECREF(options); 716 g_free(client); 717 return ret; 718 } 719 720 static int nfs_has_zero_init(BlockDriverState *bs) 721 { 722 NFSClient *client = bs->opaque; 723 return client->has_zero_init; 724 } 725 726 /* Called (via nfs_service) with QemuMutex held. */ 727 static void 728 nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data, 729 void *private_data) 730 { 731 NFSRPC *task = private_data; 732 task->ret = ret; 733 if (task->ret == 0) { 734 memcpy(task->st, data, sizeof(struct stat)); 735 } 736 if (task->ret < 0) { 737 error_report("NFS Error: %s", nfs_get_error(nfs)); 738 } 739 task->complete = 1; 740 bdrv_wakeup(task->bs); 741 } 742 743 static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) 744 { 745 NFSClient *client = bs->opaque; 746 NFSRPC task = {0}; 747 struct stat st; 748 749 if (bdrv_is_read_only(bs) && 750 !(bs->open_flags & BDRV_O_NOCACHE)) { 751 return client->st_blocks * 512; 752 } 753 754 task.bs = bs; 755 task.st = &st; 756 if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_file_size_cb, 757 &task) != 0) { 758 return -ENOMEM; 759 } 760 761 nfs_set_events(client); 762 BDRV_POLL_WHILE(bs, !task.complete); 763 764 return (task.ret < 0 ? task.ret : st.st_blocks * 512); 765 } 766 767 static int nfs_file_truncate(BlockDriverState *bs, int64_t offset) 768 { 769 NFSClient *client = bs->opaque; 770 return nfs_ftruncate(client->context, client->fh, offset); 771 } 772 773 /* Note that this will not re-establish a connection with the NFS server 774 * - it is effectively a NOP. */ 775 static int nfs_reopen_prepare(BDRVReopenState *state, 776 BlockReopenQueue *queue, Error **errp) 777 { 778 NFSClient *client = state->bs->opaque; 779 struct stat st; 780 int ret = 0; 781 782 if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) { 783 error_setg(errp, "Cannot open a read-only mount as read-write"); 784 return -EACCES; 785 } 786 787 if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) { 788 error_setg(errp, "Cannot disable cache if libnfs readahead or" 789 " pagecache is enabled"); 790 return -EINVAL; 791 } 792 793 /* Update cache for read-only reopens */ 794 if (!(state->flags & BDRV_O_RDWR)) { 795 ret = nfs_fstat(client->context, client->fh, &st); 796 if (ret < 0) { 797 error_setg(errp, "Failed to fstat file: %s", 798 nfs_get_error(client->context)); 799 return ret; 800 } 801 client->st_blocks = st.st_blocks; 802 } 803 804 return 0; 805 } 806 807 static void nfs_refresh_filename(BlockDriverState *bs, QDict *options) 808 { 809 NFSClient *client = bs->opaque; 810 QDict *opts = qdict_new(); 811 QObject *server_qdict; 812 Visitor *ov; 813 814 qdict_put(opts, "driver", qstring_from_str("nfs")); 815 816 if (client->uid && !client->gid) { 817 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 818 "nfs://%s%s?uid=%" PRId64, client->server->host, client->path, 819 client->uid); 820 } else if (!client->uid && client->gid) { 821 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 822 "nfs://%s%s?gid=%" PRId64, client->server->host, client->path, 823 client->gid); 824 } else if (client->uid && client->gid) { 825 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 826 "nfs://%s%s?uid=%" PRId64 "&gid=%" PRId64, 827 client->server->host, client->path, client->uid, client->gid); 828 } else { 829 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 830 "nfs://%s%s", client->server->host, client->path); 831 } 832 833 ov = qobject_output_visitor_new(&server_qdict); 834 visit_type_NFSServer(ov, NULL, &client->server, &error_abort); 835 visit_complete(ov, &server_qdict); 836 qdict_put_obj(opts, "server", server_qdict); 837 qdict_put(opts, "path", qstring_from_str(client->path)); 838 839 if (client->uid) { 840 qdict_put(opts, "user", qint_from_int(client->uid)); 841 } 842 if (client->gid) { 843 qdict_put(opts, "group", qint_from_int(client->gid)); 844 } 845 if (client->tcp_syncnt) { 846 qdict_put(opts, "tcp-syn-cnt", 847 qint_from_int(client->tcp_syncnt)); 848 } 849 if (client->readahead) { 850 qdict_put(opts, "readahead-size", 851 qint_from_int(client->readahead)); 852 } 853 if (client->pagecache) { 854 qdict_put(opts, "page-cache-size", 855 qint_from_int(client->pagecache)); 856 } 857 if (client->debug) { 858 qdict_put(opts, "debug", qint_from_int(client->debug)); 859 } 860 861 visit_free(ov); 862 qdict_flatten(opts); 863 bs->full_open_options = opts; 864 } 865 866 #ifdef LIBNFS_FEATURE_PAGECACHE 867 static void nfs_invalidate_cache(BlockDriverState *bs, 868 Error **errp) 869 { 870 NFSClient *client = bs->opaque; 871 nfs_pagecache_invalidate(client->context, client->fh); 872 } 873 #endif 874 875 static BlockDriver bdrv_nfs = { 876 .format_name = "nfs", 877 .protocol_name = "nfs", 878 879 .instance_size = sizeof(NFSClient), 880 .bdrv_parse_filename = nfs_parse_filename, 881 .create_opts = &nfs_create_opts, 882 883 .bdrv_has_zero_init = nfs_has_zero_init, 884 .bdrv_get_allocated_file_size = nfs_get_allocated_file_size, 885 .bdrv_truncate = nfs_file_truncate, 886 887 .bdrv_file_open = nfs_file_open, 888 .bdrv_close = nfs_file_close, 889 .bdrv_create = nfs_file_create, 890 .bdrv_reopen_prepare = nfs_reopen_prepare, 891 892 .bdrv_co_preadv = nfs_co_preadv, 893 .bdrv_co_pwritev = nfs_co_pwritev, 894 .bdrv_co_flush_to_disk = nfs_co_flush, 895 896 .bdrv_detach_aio_context = nfs_detach_aio_context, 897 .bdrv_attach_aio_context = nfs_attach_aio_context, 898 .bdrv_refresh_filename = nfs_refresh_filename, 899 900 #ifdef LIBNFS_FEATURE_PAGECACHE 901 .bdrv_invalidate_cache = nfs_invalidate_cache, 902 #endif 903 }; 904 905 static void nfs_block_init(void) 906 { 907 bdrv_register(&bdrv_nfs); 908 } 909 910 block_init(nfs_block_init); 911