1 /* 2 * QEMU Block driver for native access to files on NFS shares 3 * 4 * Copyright (c) 2014-2017 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 #if !defined(_WIN32) 28 #include <poll.h> 29 #endif 30 #include "qemu/config-file.h" 31 #include "qemu/error-report.h" 32 #include "qapi/error.h" 33 #include "block/block-io.h" 34 #include "block/block_int.h" 35 #include "block/qdict.h" 36 #include "trace.h" 37 #include "qemu/iov.h" 38 #include "qemu/main-loop.h" 39 #include "qemu/module.h" 40 #include "qemu/option.h" 41 #include "qemu/uri.h" 42 #include "qemu/cutils.h" 43 #include "sysemu/replay.h" 44 #include "qapi/qapi-visit-block-core.h" 45 #include "qapi/qmp/qdict.h" 46 #include "qapi/qmp/qstring.h" 47 #include "qapi/qobject-input-visitor.h" 48 #include "qapi/qobject-output-visitor.h" 49 #include <nfsc/libnfs.h> 50 51 52 #define QEMU_NFS_MAX_READAHEAD_SIZE 1048576 53 #define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE) 54 #define QEMU_NFS_MAX_DEBUG_LEVEL 2 55 56 typedef struct NFSClient { 57 struct nfs_context *context; 58 struct nfsfh *fh; 59 int events; 60 bool has_zero_init; 61 AioContext *aio_context; 62 QemuMutex mutex; 63 uint64_t st_blocks; 64 bool cache_used; 65 NFSServer *server; 66 char *path; 67 int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug; 68 } NFSClient; 69 70 typedef struct NFSRPC { 71 BlockDriverState *bs; 72 int ret; 73 int complete; 74 QEMUIOVector *iov; 75 struct stat *st; 76 Coroutine *co; 77 NFSClient *client; 78 } NFSRPC; 79 80 static int nfs_parse_uri(const char *filename, QDict *options, Error **errp) 81 { 82 URI *uri = NULL; 83 QueryParams *qp = NULL; 84 int ret = -EINVAL, i; 85 86 uri = uri_parse(filename); 87 if (!uri) { 88 error_setg(errp, "Invalid URI specified"); 89 goto out; 90 } 91 if (g_strcmp0(uri->scheme, "nfs") != 0) { 92 error_setg(errp, "URI scheme must be 'nfs'"); 93 goto out; 94 } 95 96 if (!uri->server) { 97 error_setg(errp, "missing hostname in URI"); 98 goto out; 99 } 100 101 if (!uri->path) { 102 error_setg(errp, "missing file path in URI"); 103 goto out; 104 } 105 106 qp = query_params_parse(uri->query); 107 if (!qp) { 108 error_setg(errp, "could not parse query parameters"); 109 goto out; 110 } 111 112 qdict_put_str(options, "server.host", uri->server); 113 qdict_put_str(options, "server.type", "inet"); 114 qdict_put_str(options, "path", uri->path); 115 116 for (i = 0; i < qp->n; i++) { 117 unsigned long long val; 118 if (!qp->p[i].value) { 119 error_setg(errp, "Value for NFS parameter expected: %s", 120 qp->p[i].name); 121 goto out; 122 } 123 if (parse_uint_full(qp->p[i].value, &val, 0)) { 124 error_setg(errp, "Illegal value for NFS parameter: %s", 125 qp->p[i].name); 126 goto out; 127 } 128 if (!strcmp(qp->p[i].name, "uid")) { 129 qdict_put_str(options, "user", qp->p[i].value); 130 } else if (!strcmp(qp->p[i].name, "gid")) { 131 qdict_put_str(options, "group", qp->p[i].value); 132 } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) { 133 qdict_put_str(options, "tcp-syn-count", qp->p[i].value); 134 } else if (!strcmp(qp->p[i].name, "readahead")) { 135 qdict_put_str(options, "readahead-size", qp->p[i].value); 136 } else if (!strcmp(qp->p[i].name, "pagecache")) { 137 qdict_put_str(options, "page-cache-size", qp->p[i].value); 138 } else if (!strcmp(qp->p[i].name, "debug")) { 139 qdict_put_str(options, "debug", qp->p[i].value); 140 } else { 141 error_setg(errp, "Unknown NFS parameter name: %s", 142 qp->p[i].name); 143 goto out; 144 } 145 } 146 ret = 0; 147 out: 148 if (qp) { 149 query_params_free(qp); 150 } 151 uri_free(uri); 152 return ret; 153 } 154 155 static bool nfs_has_filename_options_conflict(QDict *options, Error **errp) 156 { 157 const QDictEntry *qe; 158 159 for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) { 160 if (!strcmp(qe->key, "host") || 161 !strcmp(qe->key, "path") || 162 !strcmp(qe->key, "user") || 163 !strcmp(qe->key, "group") || 164 !strcmp(qe->key, "tcp-syn-count") || 165 !strcmp(qe->key, "readahead-size") || 166 !strcmp(qe->key, "page-cache-size") || 167 !strcmp(qe->key, "debug") || 168 strstart(qe->key, "server.", NULL)) 169 { 170 error_setg(errp, "Option %s cannot be used with a filename", 171 qe->key); 172 return true; 173 } 174 } 175 176 return false; 177 } 178 179 static void nfs_parse_filename(const char *filename, QDict *options, 180 Error **errp) 181 { 182 if (nfs_has_filename_options_conflict(options, errp)) { 183 return; 184 } 185 186 nfs_parse_uri(filename, options, errp); 187 } 188 189 static void nfs_process_read(void *arg); 190 static void nfs_process_write(void *arg); 191 192 /* Called with QemuMutex held. */ 193 static void nfs_set_events(NFSClient *client) 194 { 195 int ev = nfs_which_events(client->context); 196 if (ev != client->events) { 197 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 198 false, 199 (ev & POLLIN) ? nfs_process_read : NULL, 200 (ev & POLLOUT) ? nfs_process_write : NULL, 201 NULL, NULL, client); 202 203 } 204 client->events = ev; 205 } 206 207 static void nfs_process_read(void *arg) 208 { 209 NFSClient *client = arg; 210 211 qemu_mutex_lock(&client->mutex); 212 nfs_service(client->context, POLLIN); 213 nfs_set_events(client); 214 qemu_mutex_unlock(&client->mutex); 215 } 216 217 static void nfs_process_write(void *arg) 218 { 219 NFSClient *client = arg; 220 221 qemu_mutex_lock(&client->mutex); 222 nfs_service(client->context, POLLOUT); 223 nfs_set_events(client); 224 qemu_mutex_unlock(&client->mutex); 225 } 226 227 static void coroutine_fn nfs_co_init_task(BlockDriverState *bs, NFSRPC *task) 228 { 229 *task = (NFSRPC) { 230 .co = qemu_coroutine_self(), 231 .bs = bs, 232 .client = bs->opaque, 233 }; 234 } 235 236 static void nfs_co_generic_bh_cb(void *opaque) 237 { 238 NFSRPC *task = opaque; 239 240 task->complete = 1; 241 aio_co_wake(task->co); 242 } 243 244 /* Called (via nfs_service) with QemuMutex held. */ 245 static void 246 nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, 247 void *private_data) 248 { 249 NFSRPC *task = private_data; 250 task->ret = ret; 251 assert(!task->st); 252 if (task->ret > 0 && task->iov) { 253 if (task->ret <= task->iov->size) { 254 qemu_iovec_from_buf(task->iov, 0, data, task->ret); 255 } else { 256 task->ret = -EIO; 257 } 258 } 259 if (task->ret < 0) { 260 error_report("NFS Error: %s", nfs_get_error(nfs)); 261 } 262 replay_bh_schedule_oneshot_event(task->client->aio_context, 263 nfs_co_generic_bh_cb, task); 264 } 265 266 static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, int64_t offset, 267 int64_t bytes, QEMUIOVector *iov, 268 BdrvRequestFlags flags) 269 { 270 NFSClient *client = bs->opaque; 271 NFSRPC task; 272 273 nfs_co_init_task(bs, &task); 274 task.iov = iov; 275 276 WITH_QEMU_LOCK_GUARD(&client->mutex) { 277 if (nfs_pread_async(client->context, client->fh, 278 offset, bytes, nfs_co_generic_cb, &task) != 0) { 279 return -ENOMEM; 280 } 281 282 nfs_set_events(client); 283 } 284 while (!task.complete) { 285 qemu_coroutine_yield(); 286 } 287 288 if (task.ret < 0) { 289 return task.ret; 290 } 291 292 /* zero pad short reads */ 293 if (task.ret < iov->size) { 294 qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret); 295 } 296 297 return 0; 298 } 299 300 static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, int64_t offset, 301 int64_t bytes, QEMUIOVector *iov, 302 BdrvRequestFlags flags) 303 { 304 NFSClient *client = bs->opaque; 305 NFSRPC task; 306 char *buf = NULL; 307 bool my_buffer = false; 308 309 nfs_co_init_task(bs, &task); 310 311 if (iov->niov != 1) { 312 buf = g_try_malloc(bytes); 313 if (bytes && buf == NULL) { 314 return -ENOMEM; 315 } 316 qemu_iovec_to_buf(iov, 0, buf, bytes); 317 my_buffer = true; 318 } else { 319 buf = iov->iov[0].iov_base; 320 } 321 322 WITH_QEMU_LOCK_GUARD(&client->mutex) { 323 if (nfs_pwrite_async(client->context, client->fh, 324 offset, bytes, buf, 325 nfs_co_generic_cb, &task) != 0) { 326 if (my_buffer) { 327 g_free(buf); 328 } 329 return -ENOMEM; 330 } 331 332 nfs_set_events(client); 333 } 334 while (!task.complete) { 335 qemu_coroutine_yield(); 336 } 337 338 if (my_buffer) { 339 g_free(buf); 340 } 341 342 if (task.ret != bytes) { 343 return task.ret < 0 ? task.ret : -EIO; 344 } 345 346 return 0; 347 } 348 349 static int coroutine_fn nfs_co_flush(BlockDriverState *bs) 350 { 351 NFSClient *client = bs->opaque; 352 NFSRPC task; 353 354 nfs_co_init_task(bs, &task); 355 356 WITH_QEMU_LOCK_GUARD(&client->mutex) { 357 if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, 358 &task) != 0) { 359 return -ENOMEM; 360 } 361 362 nfs_set_events(client); 363 } 364 while (!task.complete) { 365 qemu_coroutine_yield(); 366 } 367 368 return task.ret; 369 } 370 371 static void nfs_detach_aio_context(BlockDriverState *bs) 372 { 373 NFSClient *client = bs->opaque; 374 375 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 376 false, NULL, NULL, NULL, NULL, NULL); 377 client->events = 0; 378 } 379 380 static void nfs_attach_aio_context(BlockDriverState *bs, 381 AioContext *new_context) 382 { 383 NFSClient *client = bs->opaque; 384 385 client->aio_context = new_context; 386 nfs_set_events(client); 387 } 388 389 static void nfs_client_close(NFSClient *client) 390 { 391 if (client->context) { 392 qemu_mutex_lock(&client->mutex); 393 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 394 false, NULL, NULL, NULL, NULL, NULL); 395 qemu_mutex_unlock(&client->mutex); 396 if (client->fh) { 397 nfs_close(client->context, client->fh); 398 client->fh = NULL; 399 } 400 #ifdef LIBNFS_FEATURE_UMOUNT 401 nfs_umount(client->context); 402 #endif 403 nfs_destroy_context(client->context); 404 client->context = NULL; 405 } 406 g_free(client->path); 407 qemu_mutex_destroy(&client->mutex); 408 qapi_free_NFSServer(client->server); 409 client->server = NULL; 410 } 411 412 static void nfs_file_close(BlockDriverState *bs) 413 { 414 NFSClient *client = bs->opaque; 415 nfs_client_close(client); 416 } 417 418 static int64_t nfs_client_open(NFSClient *client, BlockdevOptionsNfs *opts, 419 int flags, int open_flags, Error **errp) 420 { 421 int64_t ret = -EINVAL; 422 #ifdef _WIN32 423 struct __stat64 st; 424 #else 425 struct stat st; 426 #endif 427 char *file = NULL, *strp = NULL; 428 429 qemu_mutex_init(&client->mutex); 430 431 client->path = g_strdup(opts->path); 432 433 strp = strrchr(client->path, '/'); 434 if (strp == NULL) { 435 error_setg(errp, "Invalid URL specified"); 436 goto fail; 437 } 438 file = g_strdup(strp); 439 *strp = 0; 440 441 /* Steal the NFSServer object from opts; set the original pointer to NULL 442 * to avoid use after free and double free. */ 443 client->server = opts->server; 444 opts->server = NULL; 445 446 client->context = nfs_init_context(); 447 if (client->context == NULL) { 448 error_setg(errp, "Failed to init NFS context"); 449 goto fail; 450 } 451 452 if (opts->has_user) { 453 client->uid = opts->user; 454 nfs_set_uid(client->context, client->uid); 455 } 456 457 if (opts->has_group) { 458 client->gid = opts->group; 459 nfs_set_gid(client->context, client->gid); 460 } 461 462 if (opts->has_tcp_syn_count) { 463 client->tcp_syncnt = opts->tcp_syn_count; 464 nfs_set_tcp_syncnt(client->context, client->tcp_syncnt); 465 } 466 467 #ifdef LIBNFS_FEATURE_READAHEAD 468 if (opts->has_readahead_size) { 469 if (open_flags & BDRV_O_NOCACHE) { 470 error_setg(errp, "Cannot enable NFS readahead " 471 "if cache.direct = on"); 472 goto fail; 473 } 474 client->readahead = opts->readahead_size; 475 if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) { 476 warn_report("Truncating NFS readahead size to %d", 477 QEMU_NFS_MAX_READAHEAD_SIZE); 478 client->readahead = QEMU_NFS_MAX_READAHEAD_SIZE; 479 } 480 nfs_set_readahead(client->context, client->readahead); 481 #ifdef LIBNFS_FEATURE_PAGECACHE 482 nfs_set_pagecache_ttl(client->context, 0); 483 #endif 484 client->cache_used = true; 485 } 486 #endif 487 488 #ifdef LIBNFS_FEATURE_PAGECACHE 489 if (opts->has_page_cache_size) { 490 if (open_flags & BDRV_O_NOCACHE) { 491 error_setg(errp, "Cannot enable NFS pagecache " 492 "if cache.direct = on"); 493 goto fail; 494 } 495 client->pagecache = opts->page_cache_size; 496 if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) { 497 warn_report("Truncating NFS pagecache size to %d pages", 498 QEMU_NFS_MAX_PAGECACHE_SIZE); 499 client->pagecache = QEMU_NFS_MAX_PAGECACHE_SIZE; 500 } 501 nfs_set_pagecache(client->context, client->pagecache); 502 nfs_set_pagecache_ttl(client->context, 0); 503 client->cache_used = true; 504 } 505 #endif 506 507 #ifdef LIBNFS_FEATURE_DEBUG 508 if (opts->has_debug) { 509 client->debug = opts->debug; 510 /* limit the maximum debug level to avoid potential flooding 511 * of our log files. */ 512 if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) { 513 warn_report("Limiting NFS debug level to %d", 514 QEMU_NFS_MAX_DEBUG_LEVEL); 515 client->debug = QEMU_NFS_MAX_DEBUG_LEVEL; 516 } 517 nfs_set_debug(client->context, client->debug); 518 } 519 #endif 520 521 ret = nfs_mount(client->context, client->server->host, client->path); 522 if (ret < 0) { 523 error_setg(errp, "Failed to mount nfs share: %s", 524 nfs_get_error(client->context)); 525 goto fail; 526 } 527 528 if (flags & O_CREAT) { 529 ret = nfs_creat(client->context, file, 0600, &client->fh); 530 if (ret < 0) { 531 error_setg(errp, "Failed to create file: %s", 532 nfs_get_error(client->context)); 533 goto fail; 534 } 535 } else { 536 ret = nfs_open(client->context, file, flags, &client->fh); 537 if (ret < 0) { 538 error_setg(errp, "Failed to open file : %s", 539 nfs_get_error(client->context)); 540 goto fail; 541 } 542 } 543 544 ret = nfs_fstat(client->context, client->fh, &st); 545 if (ret < 0) { 546 error_setg(errp, "Failed to fstat file: %s", 547 nfs_get_error(client->context)); 548 goto fail; 549 } 550 551 ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE); 552 #if !defined(_WIN32) 553 client->st_blocks = st.st_blocks; 554 #endif 555 client->has_zero_init = S_ISREG(st.st_mode); 556 *strp = '/'; 557 goto out; 558 559 fail: 560 nfs_client_close(client); 561 out: 562 g_free(file); 563 return ret; 564 } 565 566 static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options, 567 Error **errp) 568 { 569 BlockdevOptionsNfs *opts = NULL; 570 Visitor *v; 571 const QDictEntry *e; 572 573 v = qobject_input_visitor_new_flat_confused(options, errp); 574 if (!v) { 575 return NULL; 576 } 577 578 visit_type_BlockdevOptionsNfs(v, NULL, &opts, errp); 579 visit_free(v); 580 if (!opts) { 581 return NULL; 582 } 583 584 /* Remove the processed options from the QDict (the visitor processes 585 * _all_ options in the QDict) */ 586 while ((e = qdict_first(options))) { 587 qdict_del(options, e->key); 588 } 589 590 return opts; 591 } 592 593 static int64_t nfs_client_open_qdict(NFSClient *client, QDict *options, 594 int flags, int open_flags, Error **errp) 595 { 596 BlockdevOptionsNfs *opts; 597 int64_t ret; 598 599 opts = nfs_options_qdict_to_qapi(options, errp); 600 if (opts == NULL) { 601 ret = -EINVAL; 602 goto fail; 603 } 604 605 ret = nfs_client_open(client, opts, flags, open_flags, errp); 606 fail: 607 qapi_free_BlockdevOptionsNfs(opts); 608 return ret; 609 } 610 611 static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, 612 Error **errp) { 613 NFSClient *client = bs->opaque; 614 int64_t ret; 615 616 client->aio_context = bdrv_get_aio_context(bs); 617 618 ret = nfs_client_open_qdict(client, options, 619 (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY, 620 bs->open_flags, errp); 621 if (ret < 0) { 622 return ret; 623 } 624 625 bs->total_sectors = ret; 626 if (client->has_zero_init) { 627 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; 628 } 629 return 0; 630 } 631 632 static QemuOptsList nfs_create_opts = { 633 .name = "nfs-create-opts", 634 .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head), 635 .desc = { 636 { 637 .name = BLOCK_OPT_SIZE, 638 .type = QEMU_OPT_SIZE, 639 .help = "Virtual disk size" 640 }, 641 { /* end of list */ } 642 } 643 }; 644 645 static int nfs_file_co_create(BlockdevCreateOptions *options, Error **errp) 646 { 647 BlockdevCreateOptionsNfs *opts = &options->u.nfs; 648 NFSClient *client = g_new0(NFSClient, 1); 649 int ret; 650 651 assert(options->driver == BLOCKDEV_DRIVER_NFS); 652 653 client->aio_context = qemu_get_aio_context(); 654 655 ret = nfs_client_open(client, opts->location, O_CREAT, 0, errp); 656 if (ret < 0) { 657 goto out; 658 } 659 ret = nfs_ftruncate(client->context, client->fh, opts->size); 660 nfs_client_close(client); 661 662 out: 663 g_free(client); 664 return ret; 665 } 666 667 static int coroutine_fn nfs_file_co_create_opts(BlockDriver *drv, 668 const char *url, 669 QemuOpts *opts, 670 Error **errp) 671 { 672 BlockdevCreateOptions *create_options; 673 BlockdevCreateOptionsNfs *nfs_opts; 674 QDict *options; 675 int ret; 676 677 create_options = g_new0(BlockdevCreateOptions, 1); 678 create_options->driver = BLOCKDEV_DRIVER_NFS; 679 nfs_opts = &create_options->u.nfs; 680 681 /* Read out options */ 682 nfs_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 683 BDRV_SECTOR_SIZE); 684 685 options = qdict_new(); 686 ret = nfs_parse_uri(url, options, errp); 687 if (ret < 0) { 688 goto out; 689 } 690 691 nfs_opts->location = nfs_options_qdict_to_qapi(options, errp); 692 if (nfs_opts->location == NULL) { 693 ret = -EINVAL; 694 goto out; 695 } 696 697 ret = nfs_file_co_create(create_options, errp); 698 if (ret < 0) { 699 goto out; 700 } 701 702 ret = 0; 703 out: 704 qobject_unref(options); 705 qapi_free_BlockdevCreateOptions(create_options); 706 return ret; 707 } 708 709 static int nfs_has_zero_init(BlockDriverState *bs) 710 { 711 NFSClient *client = bs->opaque; 712 return client->has_zero_init; 713 } 714 715 #if !defined(_WIN32) 716 /* Called (via nfs_service) with QemuMutex held. */ 717 static void 718 nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data, 719 void *private_data) 720 { 721 NFSRPC *task = private_data; 722 task->ret = ret; 723 if (task->ret == 0) { 724 memcpy(task->st, data, sizeof(struct stat)); 725 } 726 if (task->ret < 0) { 727 error_report("NFS Error: %s", nfs_get_error(nfs)); 728 } 729 replay_bh_schedule_oneshot_event(task->client->aio_context, 730 nfs_co_generic_bh_cb, task); 731 } 732 733 static int64_t coroutine_fn nfs_co_get_allocated_file_size(BlockDriverState *bs) 734 { 735 NFSClient *client = bs->opaque; 736 NFSRPC task = {0}; 737 struct stat st; 738 739 if (bdrv_is_read_only(bs) && 740 !(bs->open_flags & BDRV_O_NOCACHE)) { 741 return client->st_blocks * 512; 742 } 743 744 nfs_co_init_task(bs, &task); 745 task.st = &st; 746 WITH_QEMU_LOCK_GUARD(&client->mutex) { 747 if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_file_size_cb, 748 &task) != 0) { 749 return -ENOMEM; 750 } 751 752 nfs_set_events(client); 753 } 754 while (!task.complete) { 755 qemu_coroutine_yield(); 756 } 757 758 return (task.ret < 0 ? task.ret : st.st_blocks * 512); 759 } 760 #endif 761 762 static int coroutine_fn 763 nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, 764 PreallocMode prealloc, BdrvRequestFlags flags, 765 Error **errp) 766 { 767 NFSClient *client = bs->opaque; 768 int ret; 769 770 if (prealloc != PREALLOC_MODE_OFF) { 771 error_setg(errp, "Unsupported preallocation mode '%s'", 772 PreallocMode_str(prealloc)); 773 return -ENOTSUP; 774 } 775 776 ret = nfs_ftruncate(client->context, client->fh, offset); 777 if (ret < 0) { 778 error_setg_errno(errp, -ret, "Failed to truncate file"); 779 return ret; 780 } 781 782 return 0; 783 } 784 785 /* Note that this will not re-establish a connection with the NFS server 786 * - it is effectively a NOP. */ 787 static int nfs_reopen_prepare(BDRVReopenState *state, 788 BlockReopenQueue *queue, Error **errp) 789 { 790 NFSClient *client = state->bs->opaque; 791 #ifdef _WIN32 792 struct __stat64 st; 793 #else 794 struct stat st; 795 #endif 796 int ret = 0; 797 798 if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) { 799 error_setg(errp, "Cannot open a read-only mount as read-write"); 800 return -EACCES; 801 } 802 803 if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) { 804 error_setg(errp, "Cannot disable cache if libnfs readahead or" 805 " pagecache is enabled"); 806 return -EINVAL; 807 } 808 809 /* Update cache for read-only reopens */ 810 if (!(state->flags & BDRV_O_RDWR)) { 811 ret = nfs_fstat(client->context, client->fh, &st); 812 if (ret < 0) { 813 error_setg(errp, "Failed to fstat file: %s", 814 nfs_get_error(client->context)); 815 return ret; 816 } 817 #if !defined(_WIN32) 818 client->st_blocks = st.st_blocks; 819 #endif 820 } 821 822 return 0; 823 } 824 825 static void nfs_refresh_filename(BlockDriverState *bs) 826 { 827 NFSClient *client = bs->opaque; 828 829 if (client->uid && !client->gid) { 830 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 831 "nfs://%s%s?uid=%" PRId64, client->server->host, client->path, 832 client->uid); 833 } else if (!client->uid && client->gid) { 834 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 835 "nfs://%s%s?gid=%" PRId64, client->server->host, client->path, 836 client->gid); 837 } else if (client->uid && client->gid) { 838 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 839 "nfs://%s%s?uid=%" PRId64 "&gid=%" PRId64, 840 client->server->host, client->path, client->uid, client->gid); 841 } else { 842 snprintf(bs->exact_filename, sizeof(bs->exact_filename), 843 "nfs://%s%s", client->server->host, client->path); 844 } 845 } 846 847 static char *nfs_dirname(BlockDriverState *bs, Error **errp) 848 { 849 NFSClient *client = bs->opaque; 850 851 if (client->uid || client->gid) { 852 bdrv_refresh_filename(bs); 853 error_setg(errp, "Cannot generate a base directory for NFS node '%s'", 854 bs->filename); 855 return NULL; 856 } 857 858 return g_strdup_printf("nfs://%s%s/", client->server->host, client->path); 859 } 860 861 #ifdef LIBNFS_FEATURE_PAGECACHE 862 static void coroutine_fn nfs_co_invalidate_cache(BlockDriverState *bs, 863 Error **errp) 864 { 865 NFSClient *client = bs->opaque; 866 nfs_pagecache_invalidate(client->context, client->fh); 867 } 868 #endif 869 870 static const char *nfs_strong_runtime_opts[] = { 871 "path", 872 "user", 873 "group", 874 "server.", 875 876 NULL 877 }; 878 879 static BlockDriver bdrv_nfs = { 880 .format_name = "nfs", 881 .protocol_name = "nfs", 882 883 .instance_size = sizeof(NFSClient), 884 .bdrv_parse_filename = nfs_parse_filename, 885 .create_opts = &nfs_create_opts, 886 887 .bdrv_has_zero_init = nfs_has_zero_init, 888 /* libnfs does not provide the allocated filesize of a file on win32. */ 889 #if !defined(_WIN32) 890 .bdrv_co_get_allocated_file_size = nfs_co_get_allocated_file_size, 891 #endif 892 .bdrv_co_truncate = nfs_file_co_truncate, 893 894 .bdrv_file_open = nfs_file_open, 895 .bdrv_close = nfs_file_close, 896 .bdrv_co_create = nfs_file_co_create, 897 .bdrv_co_create_opts = nfs_file_co_create_opts, 898 .bdrv_reopen_prepare = nfs_reopen_prepare, 899 900 .bdrv_co_preadv = nfs_co_preadv, 901 .bdrv_co_pwritev = nfs_co_pwritev, 902 .bdrv_co_flush_to_disk = nfs_co_flush, 903 904 .bdrv_detach_aio_context = nfs_detach_aio_context, 905 .bdrv_attach_aio_context = nfs_attach_aio_context, 906 .bdrv_refresh_filename = nfs_refresh_filename, 907 .bdrv_dirname = nfs_dirname, 908 909 .strong_runtime_opts = nfs_strong_runtime_opts, 910 911 #ifdef LIBNFS_FEATURE_PAGECACHE 912 .bdrv_co_invalidate_cache = nfs_co_invalidate_cache, 913 #endif 914 }; 915 916 static void nfs_block_init(void) 917 { 918 bdrv_register(&bdrv_nfs); 919 } 920 921 block_init(nfs_block_init); 922