16542aa9cSPeter Lieven /* 26542aa9cSPeter Lieven * QEMU Block driver for native access to files on NFS shares 36542aa9cSPeter Lieven * 438f8d5e0SPeter Lieven * Copyright (c) 2014-2016 Peter Lieven <pl@kamp.de> 56542aa9cSPeter Lieven * 66542aa9cSPeter Lieven * Permission is hereby granted, free of charge, to any person obtaining a copy 76542aa9cSPeter Lieven * of this software and associated documentation files (the "Software"), to deal 86542aa9cSPeter Lieven * in the Software without restriction, including without limitation the rights 96542aa9cSPeter Lieven * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 106542aa9cSPeter Lieven * copies of the Software, and to permit persons to whom the Software is 116542aa9cSPeter Lieven * furnished to do so, subject to the following conditions: 126542aa9cSPeter Lieven * 136542aa9cSPeter Lieven * The above copyright notice and this permission notice shall be included in 146542aa9cSPeter Lieven * all copies or substantial portions of the Software. 156542aa9cSPeter Lieven * 166542aa9cSPeter Lieven * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 176542aa9cSPeter Lieven * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 186542aa9cSPeter Lieven * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 196542aa9cSPeter Lieven * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 206542aa9cSPeter Lieven * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 216542aa9cSPeter Lieven * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 226542aa9cSPeter Lieven * THE SOFTWARE. 236542aa9cSPeter Lieven */ 246542aa9cSPeter Lieven 2580c71a24SPeter Maydell #include "qemu/osdep.h" 266542aa9cSPeter Lieven 276542aa9cSPeter Lieven #include <poll.h> 286542aa9cSPeter Lieven #include "qemu-common.h" 296542aa9cSPeter Lieven #include "qemu/config-file.h" 306542aa9cSPeter Lieven #include "qemu/error-report.h" 31d165b8cbSStefan Hajnoczi #include "qapi/error.h" 326542aa9cSPeter Lieven #include "block/block_int.h" 336542aa9cSPeter Lieven #include "trace.h" 346542aa9cSPeter Lieven #include "qemu/iov.h" 356542aa9cSPeter Lieven #include "qemu/uri.h" 360d94b746SStefan Hajnoczi #include "qemu/cutils.h" 376542aa9cSPeter Lieven #include "sysemu/sysemu.h" 386542aa9cSPeter Lieven #include <nfsc/libnfs.h> 396542aa9cSPeter Lieven 4029c838cdSPeter Lieven #define QEMU_NFS_MAX_READAHEAD_SIZE 1048576 41d99b26c4SPeter Lieven #define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE) 427725b8bfSPeter Lieven #define QEMU_NFS_MAX_DEBUG_LEVEL 2 4329c838cdSPeter Lieven 446542aa9cSPeter Lieven typedef struct NFSClient { 456542aa9cSPeter Lieven struct nfs_context *context; 466542aa9cSPeter Lieven struct nfsfh *fh; 476542aa9cSPeter Lieven int events; 486542aa9cSPeter Lieven bool has_zero_init; 49471799d1SStefan Hajnoczi AioContext *aio_context; 5018a8056eSPeter Lieven blkcnt_t st_blocks; 5138f8d5e0SPeter Lieven bool cache_used; 526542aa9cSPeter Lieven } NFSClient; 536542aa9cSPeter Lieven 546542aa9cSPeter Lieven typedef struct NFSRPC { 556542aa9cSPeter Lieven int ret; 566542aa9cSPeter Lieven int complete; 576542aa9cSPeter Lieven QEMUIOVector *iov; 586542aa9cSPeter Lieven struct stat *st; 596542aa9cSPeter Lieven Coroutine *co; 60471799d1SStefan Hajnoczi NFSClient *client; 616542aa9cSPeter Lieven } NFSRPC; 626542aa9cSPeter Lieven 636542aa9cSPeter Lieven static void nfs_process_read(void *arg); 646542aa9cSPeter Lieven static void nfs_process_write(void *arg); 656542aa9cSPeter Lieven 666542aa9cSPeter Lieven static void nfs_set_events(NFSClient *client) 676542aa9cSPeter Lieven { 686542aa9cSPeter Lieven int ev = nfs_which_events(client->context); 696542aa9cSPeter Lieven if (ev != client->events) { 70dca21ef2SFam Zheng aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 71dca21ef2SFam Zheng false, 726542aa9cSPeter Lieven (ev & POLLIN) ? nfs_process_read : NULL, 73dca21ef2SFam Zheng (ev & POLLOUT) ? nfs_process_write : NULL, client); 746542aa9cSPeter Lieven 756542aa9cSPeter Lieven } 766542aa9cSPeter Lieven client->events = ev; 776542aa9cSPeter Lieven } 786542aa9cSPeter Lieven 796542aa9cSPeter Lieven static void nfs_process_read(void *arg) 806542aa9cSPeter Lieven { 816542aa9cSPeter Lieven NFSClient *client = arg; 826542aa9cSPeter Lieven nfs_service(client->context, POLLIN); 836542aa9cSPeter Lieven nfs_set_events(client); 846542aa9cSPeter Lieven } 856542aa9cSPeter Lieven 866542aa9cSPeter Lieven static void nfs_process_write(void *arg) 876542aa9cSPeter Lieven { 886542aa9cSPeter Lieven NFSClient *client = arg; 896542aa9cSPeter Lieven nfs_service(client->context, POLLOUT); 906542aa9cSPeter Lieven nfs_set_events(client); 916542aa9cSPeter Lieven } 926542aa9cSPeter Lieven 936542aa9cSPeter Lieven static void nfs_co_init_task(NFSClient *client, NFSRPC *task) 946542aa9cSPeter Lieven { 956542aa9cSPeter Lieven *task = (NFSRPC) { 966542aa9cSPeter Lieven .co = qemu_coroutine_self(), 97471799d1SStefan Hajnoczi .client = client, 986542aa9cSPeter Lieven }; 996542aa9cSPeter Lieven } 1006542aa9cSPeter Lieven 1016542aa9cSPeter Lieven static void nfs_co_generic_bh_cb(void *opaque) 1026542aa9cSPeter Lieven { 1036542aa9cSPeter Lieven NFSRPC *task = opaque; 104a2c0fe2fSPeter Lieven task->complete = 1; 1050b8b8753SPaolo Bonzini qemu_coroutine_enter(task->co); 1066542aa9cSPeter Lieven } 1076542aa9cSPeter Lieven 1086542aa9cSPeter Lieven static void 1096542aa9cSPeter Lieven nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, 1106542aa9cSPeter Lieven void *private_data) 1116542aa9cSPeter Lieven { 1126542aa9cSPeter Lieven NFSRPC *task = private_data; 1136542aa9cSPeter Lieven task->ret = ret; 1146542aa9cSPeter Lieven if (task->ret > 0 && task->iov) { 1156542aa9cSPeter Lieven if (task->ret <= task->iov->size) { 1166542aa9cSPeter Lieven qemu_iovec_from_buf(task->iov, 0, data, task->ret); 1176542aa9cSPeter Lieven } else { 1186542aa9cSPeter Lieven task->ret = -EIO; 1196542aa9cSPeter Lieven } 1206542aa9cSPeter Lieven } 1216542aa9cSPeter Lieven if (task->ret == 0 && task->st) { 1226542aa9cSPeter Lieven memcpy(task->st, data, sizeof(struct stat)); 1236542aa9cSPeter Lieven } 12420fccb18SPeter Lieven if (task->ret < 0) { 12520fccb18SPeter Lieven error_report("NFS Error: %s", nfs_get_error(nfs)); 12620fccb18SPeter Lieven } 1276542aa9cSPeter Lieven if (task->co) { 128*fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(task->client->aio_context, 129471799d1SStefan Hajnoczi nfs_co_generic_bh_cb, task); 130a2c0fe2fSPeter Lieven } else { 131a2c0fe2fSPeter Lieven task->complete = 1; 1326542aa9cSPeter Lieven } 1336542aa9cSPeter Lieven } 1346542aa9cSPeter Lieven 1356542aa9cSPeter Lieven static int coroutine_fn nfs_co_readv(BlockDriverState *bs, 1366542aa9cSPeter Lieven int64_t sector_num, int nb_sectors, 1376542aa9cSPeter Lieven QEMUIOVector *iov) 1386542aa9cSPeter Lieven { 1396542aa9cSPeter Lieven NFSClient *client = bs->opaque; 1406542aa9cSPeter Lieven NFSRPC task; 1416542aa9cSPeter Lieven 1426542aa9cSPeter Lieven nfs_co_init_task(client, &task); 1436542aa9cSPeter Lieven task.iov = iov; 1446542aa9cSPeter Lieven 1456542aa9cSPeter Lieven if (nfs_pread_async(client->context, client->fh, 1466542aa9cSPeter Lieven sector_num * BDRV_SECTOR_SIZE, 1476542aa9cSPeter Lieven nb_sectors * BDRV_SECTOR_SIZE, 1486542aa9cSPeter Lieven nfs_co_generic_cb, &task) != 0) { 1496542aa9cSPeter Lieven return -ENOMEM; 1506542aa9cSPeter Lieven } 1516542aa9cSPeter Lieven 1526542aa9cSPeter Lieven while (!task.complete) { 1536542aa9cSPeter Lieven nfs_set_events(client); 1546542aa9cSPeter Lieven qemu_coroutine_yield(); 1556542aa9cSPeter Lieven } 1566542aa9cSPeter Lieven 1576542aa9cSPeter Lieven if (task.ret < 0) { 1586542aa9cSPeter Lieven return task.ret; 1596542aa9cSPeter Lieven } 1606542aa9cSPeter Lieven 1616542aa9cSPeter Lieven /* zero pad short reads */ 1626542aa9cSPeter Lieven if (task.ret < iov->size) { 1636542aa9cSPeter Lieven qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret); 1646542aa9cSPeter Lieven } 1656542aa9cSPeter Lieven 1666542aa9cSPeter Lieven return 0; 1676542aa9cSPeter Lieven } 1686542aa9cSPeter Lieven 1696542aa9cSPeter Lieven static int coroutine_fn nfs_co_writev(BlockDriverState *bs, 1706542aa9cSPeter Lieven int64_t sector_num, int nb_sectors, 1716542aa9cSPeter Lieven QEMUIOVector *iov) 1726542aa9cSPeter Lieven { 1736542aa9cSPeter Lieven NFSClient *client = bs->opaque; 1746542aa9cSPeter Lieven NFSRPC task; 1756542aa9cSPeter Lieven char *buf = NULL; 1766542aa9cSPeter Lieven 1776542aa9cSPeter Lieven nfs_co_init_task(client, &task); 1786542aa9cSPeter Lieven 1792347dd7bSKevin Wolf buf = g_try_malloc(nb_sectors * BDRV_SECTOR_SIZE); 1802347dd7bSKevin Wolf if (nb_sectors && buf == NULL) { 1812347dd7bSKevin Wolf return -ENOMEM; 1822347dd7bSKevin Wolf } 1832347dd7bSKevin Wolf 1846542aa9cSPeter Lieven qemu_iovec_to_buf(iov, 0, buf, nb_sectors * BDRV_SECTOR_SIZE); 1856542aa9cSPeter Lieven 1866542aa9cSPeter Lieven if (nfs_pwrite_async(client->context, client->fh, 1876542aa9cSPeter Lieven sector_num * BDRV_SECTOR_SIZE, 1886542aa9cSPeter Lieven nb_sectors * BDRV_SECTOR_SIZE, 1896542aa9cSPeter Lieven buf, nfs_co_generic_cb, &task) != 0) { 1906542aa9cSPeter Lieven g_free(buf); 1916542aa9cSPeter Lieven return -ENOMEM; 1926542aa9cSPeter Lieven } 1936542aa9cSPeter Lieven 1946542aa9cSPeter Lieven while (!task.complete) { 1956542aa9cSPeter Lieven nfs_set_events(client); 1966542aa9cSPeter Lieven qemu_coroutine_yield(); 1976542aa9cSPeter Lieven } 1986542aa9cSPeter Lieven 1996542aa9cSPeter Lieven g_free(buf); 2006542aa9cSPeter Lieven 2016542aa9cSPeter Lieven if (task.ret != nb_sectors * BDRV_SECTOR_SIZE) { 2026542aa9cSPeter Lieven return task.ret < 0 ? task.ret : -EIO; 2036542aa9cSPeter Lieven } 2046542aa9cSPeter Lieven 2056542aa9cSPeter Lieven return 0; 2066542aa9cSPeter Lieven } 2076542aa9cSPeter Lieven 2086542aa9cSPeter Lieven static int coroutine_fn nfs_co_flush(BlockDriverState *bs) 2096542aa9cSPeter Lieven { 2106542aa9cSPeter Lieven NFSClient *client = bs->opaque; 2116542aa9cSPeter Lieven NFSRPC task; 2126542aa9cSPeter Lieven 2136542aa9cSPeter Lieven nfs_co_init_task(client, &task); 2146542aa9cSPeter Lieven 2156542aa9cSPeter Lieven if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, 2166542aa9cSPeter Lieven &task) != 0) { 2176542aa9cSPeter Lieven return -ENOMEM; 2186542aa9cSPeter Lieven } 2196542aa9cSPeter Lieven 2206542aa9cSPeter Lieven while (!task.complete) { 2216542aa9cSPeter Lieven nfs_set_events(client); 2226542aa9cSPeter Lieven qemu_coroutine_yield(); 2236542aa9cSPeter Lieven } 2246542aa9cSPeter Lieven 2256542aa9cSPeter Lieven return task.ret; 2266542aa9cSPeter Lieven } 2276542aa9cSPeter Lieven 2286542aa9cSPeter Lieven /* TODO Convert to fine grained options */ 2296542aa9cSPeter Lieven static QemuOptsList runtime_opts = { 2306542aa9cSPeter Lieven .name = "nfs", 2316542aa9cSPeter Lieven .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 2326542aa9cSPeter Lieven .desc = { 2336542aa9cSPeter Lieven { 2346542aa9cSPeter Lieven .name = "filename", 2356542aa9cSPeter Lieven .type = QEMU_OPT_STRING, 2366542aa9cSPeter Lieven .help = "URL to the NFS file", 2376542aa9cSPeter Lieven }, 2386542aa9cSPeter Lieven { /* end of list */ } 2396542aa9cSPeter Lieven }, 2406542aa9cSPeter Lieven }; 2416542aa9cSPeter Lieven 242471799d1SStefan Hajnoczi static void nfs_detach_aio_context(BlockDriverState *bs) 243471799d1SStefan Hajnoczi { 244471799d1SStefan Hajnoczi NFSClient *client = bs->opaque; 245471799d1SStefan Hajnoczi 246dca21ef2SFam Zheng aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 247dca21ef2SFam Zheng false, NULL, NULL, NULL); 248471799d1SStefan Hajnoczi client->events = 0; 249471799d1SStefan Hajnoczi } 250471799d1SStefan Hajnoczi 251471799d1SStefan Hajnoczi static void nfs_attach_aio_context(BlockDriverState *bs, 252471799d1SStefan Hajnoczi AioContext *new_context) 253471799d1SStefan Hajnoczi { 254471799d1SStefan Hajnoczi NFSClient *client = bs->opaque; 255471799d1SStefan Hajnoczi 256471799d1SStefan Hajnoczi client->aio_context = new_context; 257471799d1SStefan Hajnoczi nfs_set_events(client); 258471799d1SStefan Hajnoczi } 259471799d1SStefan Hajnoczi 2606542aa9cSPeter Lieven static void nfs_client_close(NFSClient *client) 2616542aa9cSPeter Lieven { 2626542aa9cSPeter Lieven if (client->context) { 2636542aa9cSPeter Lieven if (client->fh) { 2646542aa9cSPeter Lieven nfs_close(client->context, client->fh); 2656542aa9cSPeter Lieven } 266dca21ef2SFam Zheng aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), 267dca21ef2SFam Zheng false, NULL, NULL, NULL); 2686542aa9cSPeter Lieven nfs_destroy_context(client->context); 2696542aa9cSPeter Lieven } 2706542aa9cSPeter Lieven memset(client, 0, sizeof(NFSClient)); 2716542aa9cSPeter Lieven } 2726542aa9cSPeter Lieven 2736542aa9cSPeter Lieven static void nfs_file_close(BlockDriverState *bs) 2746542aa9cSPeter Lieven { 2756542aa9cSPeter Lieven NFSClient *client = bs->opaque; 2766542aa9cSPeter Lieven nfs_client_close(client); 2776542aa9cSPeter Lieven } 2786542aa9cSPeter Lieven 2796542aa9cSPeter Lieven static int64_t nfs_client_open(NFSClient *client, const char *filename, 28038f8d5e0SPeter Lieven int flags, Error **errp, int open_flags) 2816542aa9cSPeter Lieven { 2826542aa9cSPeter Lieven int ret = -EINVAL, i; 2836542aa9cSPeter Lieven struct stat st; 2846542aa9cSPeter Lieven URI *uri; 2856542aa9cSPeter Lieven QueryParams *qp = NULL; 2866542aa9cSPeter Lieven char *file = NULL, *strp = NULL; 2876542aa9cSPeter Lieven 2886542aa9cSPeter Lieven uri = uri_parse(filename); 2896542aa9cSPeter Lieven if (!uri) { 2906542aa9cSPeter Lieven error_setg(errp, "Invalid URL specified"); 2916542aa9cSPeter Lieven goto fail; 2926542aa9cSPeter Lieven } 2935f4d5e1aSMax Reitz if (!uri->server) { 2945f4d5e1aSMax Reitz error_setg(errp, "Invalid URL specified"); 2955f4d5e1aSMax Reitz goto fail; 2965f4d5e1aSMax Reitz } 2976542aa9cSPeter Lieven strp = strrchr(uri->path, '/'); 2986542aa9cSPeter Lieven if (strp == NULL) { 2996542aa9cSPeter Lieven error_setg(errp, "Invalid URL specified"); 3006542aa9cSPeter Lieven goto fail; 3016542aa9cSPeter Lieven } 3026542aa9cSPeter Lieven file = g_strdup(strp); 3036542aa9cSPeter Lieven *strp = 0; 3046542aa9cSPeter Lieven 3056542aa9cSPeter Lieven client->context = nfs_init_context(); 3066542aa9cSPeter Lieven if (client->context == NULL) { 3076542aa9cSPeter Lieven error_setg(errp, "Failed to init NFS context"); 3086542aa9cSPeter Lieven goto fail; 3096542aa9cSPeter Lieven } 3106542aa9cSPeter Lieven 3116542aa9cSPeter Lieven qp = query_params_parse(uri->query); 3126542aa9cSPeter Lieven for (i = 0; i < qp->n; i++) { 3137c24384bSPeter Lieven unsigned long long val; 3146542aa9cSPeter Lieven if (!qp->p[i].value) { 3156542aa9cSPeter Lieven error_setg(errp, "Value for NFS parameter expected: %s", 3166542aa9cSPeter Lieven qp->p[i].name); 3176542aa9cSPeter Lieven goto fail; 3186542aa9cSPeter Lieven } 3197c24384bSPeter Lieven if (parse_uint_full(qp->p[i].value, &val, 0)) { 3207c24384bSPeter Lieven error_setg(errp, "Illegal value for NFS parameter: %s", 3217c24384bSPeter Lieven qp->p[i].name); 3227c24384bSPeter Lieven goto fail; 3237c24384bSPeter Lieven } 3247c24384bSPeter Lieven if (!strcmp(qp->p[i].name, "uid")) { 3257c24384bSPeter Lieven nfs_set_uid(client->context, val); 3267c24384bSPeter Lieven } else if (!strcmp(qp->p[i].name, "gid")) { 3277c24384bSPeter Lieven nfs_set_gid(client->context, val); 3287c24384bSPeter Lieven } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) { 3297c24384bSPeter Lieven nfs_set_tcp_syncnt(client->context, val); 330f42ca3caSPeter Lieven #ifdef LIBNFS_FEATURE_READAHEAD 331f42ca3caSPeter Lieven } else if (!strcmp(qp->p[i].name, "readahead")) { 33238f8d5e0SPeter Lieven if (open_flags & BDRV_O_NOCACHE) { 33338f8d5e0SPeter Lieven error_setg(errp, "Cannot enable NFS readahead " 33438f8d5e0SPeter Lieven "if cache.direct = on"); 33538f8d5e0SPeter Lieven goto fail; 33638f8d5e0SPeter Lieven } 33729c838cdSPeter Lieven if (val > QEMU_NFS_MAX_READAHEAD_SIZE) { 33829c838cdSPeter Lieven error_report("NFS Warning: Truncating NFS readahead" 33929c838cdSPeter Lieven " size to %d", QEMU_NFS_MAX_READAHEAD_SIZE); 34029c838cdSPeter Lieven val = QEMU_NFS_MAX_READAHEAD_SIZE; 34129c838cdSPeter Lieven } 342f42ca3caSPeter Lieven nfs_set_readahead(client->context, val); 343d99b26c4SPeter Lieven #ifdef LIBNFS_FEATURE_PAGECACHE 344d99b26c4SPeter Lieven nfs_set_pagecache_ttl(client->context, 0); 345d99b26c4SPeter Lieven #endif 346d99b26c4SPeter Lieven client->cache_used = true; 347d99b26c4SPeter Lieven #endif 348d99b26c4SPeter Lieven #ifdef LIBNFS_FEATURE_PAGECACHE 349d99b26c4SPeter Lieven nfs_set_pagecache_ttl(client->context, 0); 350d99b26c4SPeter Lieven } else if (!strcmp(qp->p[i].name, "pagecache")) { 351d99b26c4SPeter Lieven if (open_flags & BDRV_O_NOCACHE) { 352d99b26c4SPeter Lieven error_setg(errp, "Cannot enable NFS pagecache " 353d99b26c4SPeter Lieven "if cache.direct = on"); 354d99b26c4SPeter Lieven goto fail; 355d99b26c4SPeter Lieven } 356d99b26c4SPeter Lieven if (val > QEMU_NFS_MAX_PAGECACHE_SIZE) { 357d99b26c4SPeter Lieven error_report("NFS Warning: Truncating NFS pagecache" 358d99b26c4SPeter Lieven " size to %d pages", QEMU_NFS_MAX_PAGECACHE_SIZE); 359d99b26c4SPeter Lieven val = QEMU_NFS_MAX_PAGECACHE_SIZE; 360d99b26c4SPeter Lieven } 361d99b26c4SPeter Lieven nfs_set_pagecache(client->context, val); 362d99b26c4SPeter Lieven nfs_set_pagecache_ttl(client->context, 0); 36338f8d5e0SPeter Lieven client->cache_used = true; 364f42ca3caSPeter Lieven #endif 3657725b8bfSPeter Lieven #ifdef LIBNFS_FEATURE_DEBUG 3667725b8bfSPeter Lieven } else if (!strcmp(qp->p[i].name, "debug")) { 3677725b8bfSPeter Lieven /* limit the maximum debug level to avoid potential flooding 3687725b8bfSPeter Lieven * of our log files. */ 3697725b8bfSPeter Lieven if (val > QEMU_NFS_MAX_DEBUG_LEVEL) { 3707725b8bfSPeter Lieven error_report("NFS Warning: Limiting NFS debug level" 3717725b8bfSPeter Lieven " to %d", QEMU_NFS_MAX_DEBUG_LEVEL); 3727725b8bfSPeter Lieven val = QEMU_NFS_MAX_DEBUG_LEVEL; 3737725b8bfSPeter Lieven } 3747725b8bfSPeter Lieven nfs_set_debug(client->context, val); 3757725b8bfSPeter Lieven #endif 3766542aa9cSPeter Lieven } else { 3776542aa9cSPeter Lieven error_setg(errp, "Unknown NFS parameter name: %s", 3786542aa9cSPeter Lieven qp->p[i].name); 3796542aa9cSPeter Lieven goto fail; 3806542aa9cSPeter Lieven } 3816542aa9cSPeter Lieven } 3826542aa9cSPeter Lieven 3836542aa9cSPeter Lieven ret = nfs_mount(client->context, uri->server, uri->path); 3846542aa9cSPeter Lieven if (ret < 0) { 3856542aa9cSPeter Lieven error_setg(errp, "Failed to mount nfs share: %s", 3866542aa9cSPeter Lieven nfs_get_error(client->context)); 3876542aa9cSPeter Lieven goto fail; 3886542aa9cSPeter Lieven } 3896542aa9cSPeter Lieven 3906542aa9cSPeter Lieven if (flags & O_CREAT) { 3916542aa9cSPeter Lieven ret = nfs_creat(client->context, file, 0600, &client->fh); 3926542aa9cSPeter Lieven if (ret < 0) { 3936542aa9cSPeter Lieven error_setg(errp, "Failed to create file: %s", 3946542aa9cSPeter Lieven nfs_get_error(client->context)); 3956542aa9cSPeter Lieven goto fail; 3966542aa9cSPeter Lieven } 3976542aa9cSPeter Lieven } else { 3986542aa9cSPeter Lieven ret = nfs_open(client->context, file, flags, &client->fh); 3996542aa9cSPeter Lieven if (ret < 0) { 4006542aa9cSPeter Lieven error_setg(errp, "Failed to open file : %s", 4016542aa9cSPeter Lieven nfs_get_error(client->context)); 4026542aa9cSPeter Lieven goto fail; 4036542aa9cSPeter Lieven } 4046542aa9cSPeter Lieven } 4056542aa9cSPeter Lieven 4066542aa9cSPeter Lieven ret = nfs_fstat(client->context, client->fh, &st); 4076542aa9cSPeter Lieven if (ret < 0) { 4086542aa9cSPeter Lieven error_setg(errp, "Failed to fstat file: %s", 4096542aa9cSPeter Lieven nfs_get_error(client->context)); 4106542aa9cSPeter Lieven goto fail; 4116542aa9cSPeter Lieven } 4126542aa9cSPeter Lieven 4136542aa9cSPeter Lieven ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE); 41418a8056eSPeter Lieven client->st_blocks = st.st_blocks; 4156542aa9cSPeter Lieven client->has_zero_init = S_ISREG(st.st_mode); 4166542aa9cSPeter Lieven goto out; 4176542aa9cSPeter Lieven fail: 4186542aa9cSPeter Lieven nfs_client_close(client); 4196542aa9cSPeter Lieven out: 4206542aa9cSPeter Lieven if (qp) { 4216542aa9cSPeter Lieven query_params_free(qp); 4226542aa9cSPeter Lieven } 4236542aa9cSPeter Lieven uri_free(uri); 4246542aa9cSPeter Lieven g_free(file); 4256542aa9cSPeter Lieven return ret; 4266542aa9cSPeter Lieven } 4276542aa9cSPeter Lieven 4286542aa9cSPeter Lieven static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, 4296542aa9cSPeter Lieven Error **errp) { 4306542aa9cSPeter Lieven NFSClient *client = bs->opaque; 4316542aa9cSPeter Lieven int64_t ret; 4326542aa9cSPeter Lieven QemuOpts *opts; 4336542aa9cSPeter Lieven Error *local_err = NULL; 4346542aa9cSPeter Lieven 435471799d1SStefan Hajnoczi client->aio_context = bdrv_get_aio_context(bs); 436471799d1SStefan Hajnoczi 4376542aa9cSPeter Lieven opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 4386542aa9cSPeter Lieven qemu_opts_absorb_qdict(opts, options, &local_err); 4390fb6395cSMarkus Armbruster if (local_err) { 4406542aa9cSPeter Lieven error_propagate(errp, local_err); 441810f4f86SFam Zheng ret = -EINVAL; 442810f4f86SFam Zheng goto out; 4436542aa9cSPeter Lieven } 4446542aa9cSPeter Lieven ret = nfs_client_open(client, qemu_opt_get(opts, "filename"), 4456542aa9cSPeter Lieven (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY, 44638f8d5e0SPeter Lieven errp, bs->open_flags); 4476542aa9cSPeter Lieven if (ret < 0) { 448810f4f86SFam Zheng goto out; 4496542aa9cSPeter Lieven } 4506542aa9cSPeter Lieven bs->total_sectors = ret; 451810f4f86SFam Zheng ret = 0; 452810f4f86SFam Zheng out: 453810f4f86SFam Zheng qemu_opts_del(opts); 454810f4f86SFam Zheng return ret; 4556542aa9cSPeter Lieven } 4566542aa9cSPeter Lieven 457fd752801SMax Reitz static QemuOptsList nfs_create_opts = { 458fd752801SMax Reitz .name = "nfs-create-opts", 459fd752801SMax Reitz .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head), 460fd752801SMax Reitz .desc = { 461fd752801SMax Reitz { 462fd752801SMax Reitz .name = BLOCK_OPT_SIZE, 463fd752801SMax Reitz .type = QEMU_OPT_SIZE, 464fd752801SMax Reitz .help = "Virtual disk size" 465fd752801SMax Reitz }, 466fd752801SMax Reitz { /* end of list */ } 467fd752801SMax Reitz } 468fd752801SMax Reitz }; 469fd752801SMax Reitz 47098c10b81SChunyan Liu static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp) 4716542aa9cSPeter Lieven { 4726542aa9cSPeter Lieven int ret = 0; 4736542aa9cSPeter Lieven int64_t total_size = 0; 4745839e53bSMarkus Armbruster NFSClient *client = g_new0(NFSClient, 1); 4756542aa9cSPeter Lieven 476471799d1SStefan Hajnoczi client->aio_context = qemu_get_aio_context(); 477471799d1SStefan Hajnoczi 4786542aa9cSPeter Lieven /* Read out options */ 479c2eb918eSHu Tao total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 480c2eb918eSHu Tao BDRV_SECTOR_SIZE); 4816542aa9cSPeter Lieven 48238f8d5e0SPeter Lieven ret = nfs_client_open(client, url, O_CREAT, errp, 0); 4836542aa9cSPeter Lieven if (ret < 0) { 4846542aa9cSPeter Lieven goto out; 4856542aa9cSPeter Lieven } 4866542aa9cSPeter Lieven ret = nfs_ftruncate(client->context, client->fh, total_size); 4876542aa9cSPeter Lieven nfs_client_close(client); 4886542aa9cSPeter Lieven out: 4896542aa9cSPeter Lieven g_free(client); 4906542aa9cSPeter Lieven return ret; 4916542aa9cSPeter Lieven } 4926542aa9cSPeter Lieven 4936542aa9cSPeter Lieven static int nfs_has_zero_init(BlockDriverState *bs) 4946542aa9cSPeter Lieven { 4956542aa9cSPeter Lieven NFSClient *client = bs->opaque; 4966542aa9cSPeter Lieven return client->has_zero_init; 4976542aa9cSPeter Lieven } 4986542aa9cSPeter Lieven 4996542aa9cSPeter Lieven static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) 5006542aa9cSPeter Lieven { 5016542aa9cSPeter Lieven NFSClient *client = bs->opaque; 5026542aa9cSPeter Lieven NFSRPC task = {0}; 5036542aa9cSPeter Lieven struct stat st; 5046542aa9cSPeter Lieven 50518a8056eSPeter Lieven if (bdrv_is_read_only(bs) && 50618a8056eSPeter Lieven !(bs->open_flags & BDRV_O_NOCACHE)) { 50718a8056eSPeter Lieven return client->st_blocks * 512; 50818a8056eSPeter Lieven } 50918a8056eSPeter Lieven 5106542aa9cSPeter Lieven task.st = &st; 5116542aa9cSPeter Lieven if (nfs_fstat_async(client->context, client->fh, nfs_co_generic_cb, 5126542aa9cSPeter Lieven &task) != 0) { 5136542aa9cSPeter Lieven return -ENOMEM; 5146542aa9cSPeter Lieven } 5156542aa9cSPeter Lieven 5166542aa9cSPeter Lieven while (!task.complete) { 5176542aa9cSPeter Lieven nfs_set_events(client); 518471799d1SStefan Hajnoczi aio_poll(client->aio_context, true); 5196542aa9cSPeter Lieven } 5206542aa9cSPeter Lieven 521055c6f91SPeter Lieven return (task.ret < 0 ? task.ret : st.st_blocks * 512); 5226542aa9cSPeter Lieven } 5236542aa9cSPeter Lieven 5246542aa9cSPeter Lieven static int nfs_file_truncate(BlockDriverState *bs, int64_t offset) 5256542aa9cSPeter Lieven { 5266542aa9cSPeter Lieven NFSClient *client = bs->opaque; 5276542aa9cSPeter Lieven return nfs_ftruncate(client->context, client->fh, offset); 5286542aa9cSPeter Lieven } 5296542aa9cSPeter Lieven 53018a8056eSPeter Lieven /* Note that this will not re-establish a connection with the NFS server 53118a8056eSPeter Lieven * - it is effectively a NOP. */ 53218a8056eSPeter Lieven static int nfs_reopen_prepare(BDRVReopenState *state, 53318a8056eSPeter Lieven BlockReopenQueue *queue, Error **errp) 53418a8056eSPeter Lieven { 53518a8056eSPeter Lieven NFSClient *client = state->bs->opaque; 53618a8056eSPeter Lieven struct stat st; 53718a8056eSPeter Lieven int ret = 0; 53818a8056eSPeter Lieven 53918a8056eSPeter Lieven if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) { 54018a8056eSPeter Lieven error_setg(errp, "Cannot open a read-only mount as read-write"); 54118a8056eSPeter Lieven return -EACCES; 54218a8056eSPeter Lieven } 54318a8056eSPeter Lieven 54438f8d5e0SPeter Lieven if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) { 545d99b26c4SPeter Lieven error_setg(errp, "Cannot disable cache if libnfs readahead or" 546d99b26c4SPeter Lieven " pagecache is enabled"); 54738f8d5e0SPeter Lieven return -EINVAL; 54838f8d5e0SPeter Lieven } 54938f8d5e0SPeter Lieven 55018a8056eSPeter Lieven /* Update cache for read-only reopens */ 55118a8056eSPeter Lieven if (!(state->flags & BDRV_O_RDWR)) { 55218a8056eSPeter Lieven ret = nfs_fstat(client->context, client->fh, &st); 55318a8056eSPeter Lieven if (ret < 0) { 55418a8056eSPeter Lieven error_setg(errp, "Failed to fstat file: %s", 55518a8056eSPeter Lieven nfs_get_error(client->context)); 55618a8056eSPeter Lieven return ret; 55718a8056eSPeter Lieven } 55818a8056eSPeter Lieven client->st_blocks = st.st_blocks; 55918a8056eSPeter Lieven } 56018a8056eSPeter Lieven 56118a8056eSPeter Lieven return 0; 56218a8056eSPeter Lieven } 56318a8056eSPeter Lieven 564d99b26c4SPeter Lieven #ifdef LIBNFS_FEATURE_PAGECACHE 565d99b26c4SPeter Lieven static void nfs_invalidate_cache(BlockDriverState *bs, 566d99b26c4SPeter Lieven Error **errp) 567d99b26c4SPeter Lieven { 568d99b26c4SPeter Lieven NFSClient *client = bs->opaque; 569d99b26c4SPeter Lieven nfs_pagecache_invalidate(client->context, client->fh); 570d99b26c4SPeter Lieven } 571d99b26c4SPeter Lieven #endif 572d99b26c4SPeter Lieven 5736542aa9cSPeter Lieven static BlockDriver bdrv_nfs = { 5746542aa9cSPeter Lieven .format_name = "nfs", 5756542aa9cSPeter Lieven .protocol_name = "nfs", 5766542aa9cSPeter Lieven 5776542aa9cSPeter Lieven .instance_size = sizeof(NFSClient), 5786542aa9cSPeter Lieven .bdrv_needs_filename = true, 579fd752801SMax Reitz .create_opts = &nfs_create_opts, 580fd752801SMax Reitz 5816542aa9cSPeter Lieven .bdrv_has_zero_init = nfs_has_zero_init, 5826542aa9cSPeter Lieven .bdrv_get_allocated_file_size = nfs_get_allocated_file_size, 5836542aa9cSPeter Lieven .bdrv_truncate = nfs_file_truncate, 5846542aa9cSPeter Lieven 5856542aa9cSPeter Lieven .bdrv_file_open = nfs_file_open, 5866542aa9cSPeter Lieven .bdrv_close = nfs_file_close, 587c282e1fdSChunyan Liu .bdrv_create = nfs_file_create, 58818a8056eSPeter Lieven .bdrv_reopen_prepare = nfs_reopen_prepare, 5896542aa9cSPeter Lieven 5906542aa9cSPeter Lieven .bdrv_co_readv = nfs_co_readv, 5916542aa9cSPeter Lieven .bdrv_co_writev = nfs_co_writev, 5926542aa9cSPeter Lieven .bdrv_co_flush_to_disk = nfs_co_flush, 593471799d1SStefan Hajnoczi 594471799d1SStefan Hajnoczi .bdrv_detach_aio_context = nfs_detach_aio_context, 595471799d1SStefan Hajnoczi .bdrv_attach_aio_context = nfs_attach_aio_context, 596d99b26c4SPeter Lieven 597d99b26c4SPeter Lieven #ifdef LIBNFS_FEATURE_PAGECACHE 598d99b26c4SPeter Lieven .bdrv_invalidate_cache = nfs_invalidate_cache, 599d99b26c4SPeter Lieven #endif 6006542aa9cSPeter Lieven }; 6016542aa9cSPeter Lieven 6026542aa9cSPeter Lieven static void nfs_block_init(void) 6036542aa9cSPeter Lieven { 6046542aa9cSPeter Lieven bdrv_register(&bdrv_nfs); 6056542aa9cSPeter Lieven } 6066542aa9cSPeter Lieven 6076542aa9cSPeter Lieven block_init(nfs_block_init); 608