From nobody Tue Oct 28 11:46:27 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1599119172; cv=none; d=zohomail.com; s=zohoarc; b=Bg2HLmQetlA+XaGz1p07rgX0z55h0y6C0wJ9DkPez7SNq9aWiJKli5koe36nmBB44PWWKx3vze4bvngfoQqQ1CC5CRrBBTTghVablcbIUhQ1Dyw1DSaC00ploKYTgW1FpcpOOUVzzxQUsWUSg60J01LG1B/rbMTVC2gx+9Q/rpI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1599119172; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=H8XrF8Pb9GWB51Qq/Erw8qteOrJrg0KP5nGwFRkDrXA=; b=oL+CYb0xWdKx3FFro+XBukyjhr10Fr3ACNbCu3Re0Ox/2yBb89/Cq70RLNtnsh97MZ7zguApy+ndtIJEUu/gSwV5bBXWojTidRq45iU/g5qRfduNsU2fptMq7Isqb0SpWQn5ZGxxk1dijKnZGcyqQcq/kGihTPFssivSLlJpEvI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1599119172243316.7239690429741; Thu, 3 Sep 2020 00:46:12 -0700 (PDT) Received: from localhost ([::1]:50522 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kDjwh-0004M9-98 for importer@patchew.org; Thu, 03 Sep 2020 03:46:11 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:43388) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kDjuS-00006I-Kp for qemu-devel@nongnu.org; Thu, 03 Sep 2020 03:43:52 -0400 Received: from mail-pg1-x532.google.com ([2607:f8b0:4864:20::532]:32781) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kDjuO-0003sL-CU for qemu-devel@nongnu.org; Thu, 03 Sep 2020 03:43:52 -0400 Received: by mail-pg1-x532.google.com with SMTP id e33so1464308pgm.0 for ; Thu, 03 Sep 2020 00:43:48 -0700 (PDT) Received: from localhost.localdomain ([222.95.248.6]) by smtp.googlemail.com with ESMTPSA id o6sm1512472pju.25.2020.09.03.00.43.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 03 Sep 2020 00:43:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=H8XrF8Pb9GWB51Qq/Erw8qteOrJrg0KP5nGwFRkDrXA=; b=MgGhlS/pEz0BkLa5HNQZumnxoFHs2L91ynvwZ/aWelU62FuTrzy9DpAGI+FuttUe2B 8G0PFkzsqF/tUNefYKi5zHm0S5nQopxwtEoLoQLXfFZSGa0dgHCnOKxXtcgWf1dAOH7e SPc9kEml2JZMy84d/g3IRiEiLtBqrKgV9vZibihswQleFOEnP50c3KsGtDpAYgpDvQVa e0e50yPxCEAysbb3L8lliIhXEIBsi5RqnKAFPDjGKIy8oZUgcK5rt8+7FEXZWl6oJbbh 3d10rlO5UCOcdAxDvvwIZr6RqRCLrx6iTt5yPfy0nE01Sr6NLNP1T3vuLZFgb2A9VKKW bRTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=H8XrF8Pb9GWB51Qq/Erw8qteOrJrg0KP5nGwFRkDrXA=; b=VsiFdsVh+0SRX4Jaa7nvdQyD2Ei2Hs3haesOcR9NIYRl3s+dlNe4o83rCMtlEx4gLi h6OR2jmYge6LUkGD1XcUAWGrvemWE4hL4ao0ZUphHNp+CAW0IDB7h1qqDAccGivW2m5s iMlIKB/ctcM/YJLG80mcpWCzKlJkU6+wkJPAju7QXv56sASyWD5L4hDW8ihNOMViw4Mf kgzIjSjeY3yWnTdSyR2xgMxTUgIwCH0JZcU7430N5aSMNBsEiL1qMAiEySs/1txxWafM HggTPJrd9B1JBLnbxZVE0MY5p7VfESUCYz35HZr/HrBkFNPde6OrTEF3+JGeUFOczaQH BU0g== X-Gm-Message-State: AOAM533csRUHbkfFomjBTGjs8CBNtTunfGhjO8N1yzbm5z1LVHAlXuAg nLhQpNviNJfxIQW/qCengz7SszOxEJnOmQEo X-Google-Smtp-Source: ABdhPJxsbsX/06Oq+q7KLJH29b+x81/h7UNM6zh0A5N/X4tpFbMm18fLDZojvmJBw8J56nxl1TL1cg== X-Received: by 2002:a62:d44e:0:b029:13c:1611:652f with SMTP id u14-20020a62d44e0000b029013c1611652fmr911552pfl.15.1599119025539; Thu, 03 Sep 2020 00:43:45 -0700 (PDT) From: Yonggang Luo To: qemu-devel@nongnu.org Subject: [PATCH v3 06/12] block: Fixes nfs on msys2/mingw Date: Thu, 3 Sep 2020 15:43:07 +0800 Message-Id: <20200903074313.1498-7-luoyonggang@gmail.com> X-Mailer: git-send-email 2.28.0.windows.1 In-Reply-To: <20200903074313.1498-1-luoyonggang@gmail.com> References: <20200903074313.1498-1-luoyonggang@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::532; envelope-from=luoyonggang@gmail.com; helo=mail-pg1-x532.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Paolo Bonzini , Yonggang Luo Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: pass (identity @gmail.com) Content-Type: text/plain; charset="utf-8" Signed-off-by: Yonggang Luo --- block/nfs.c | 1812 ++++++++++++++++++++++++++------------------------- 1 file changed, 910 insertions(+), 902 deletions(-) diff --git a/block/nfs.c b/block/nfs.c index 61a249a9fc..34b2cd5708 100644 --- a/block/nfs.c +++ b/block/nfs.c @@ -1,902 +1,910 @@ -/* - * QEMU Block driver for native access to files on NFS shares - * - * Copyright (c) 2014-2017 Peter Lieven - * - * Permission is hereby granted, free of charge, to any person obtaining a= copy - * of this software and associated documentation files (the "Software"), t= o deal - * in the Software without restriction, including without limitation the r= ights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included= in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS= OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OT= HER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING= FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS = IN - * THE SOFTWARE. - */ - -#include "qemu/osdep.h" - -#include -#include "qemu/config-file.h" -#include "qemu/error-report.h" -#include "qapi/error.h" -#include "block/block_int.h" -#include "block/qdict.h" -#include "trace.h" -#include "qemu/iov.h" -#include "qemu/main-loop.h" -#include "qemu/module.h" -#include "qemu/option.h" -#include "qemu/uri.h" -#include "qemu/cutils.h" -#include "sysemu/sysemu.h" -#include "sysemu/replay.h" -#include "qapi/qapi-visit-block-core.h" -#include "qapi/qmp/qdict.h" -#include "qapi/qmp/qstring.h" -#include "qapi/qobject-input-visitor.h" -#include "qapi/qobject-output-visitor.h" -#include - - -#define QEMU_NFS_MAX_READAHEAD_SIZE 1048576 -#define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE) -#define QEMU_NFS_MAX_DEBUG_LEVEL 2 - -typedef struct NFSClient { - struct nfs_context *context; - struct nfsfh *fh; - int events; - bool has_zero_init; - AioContext *aio_context; - QemuMutex mutex; - blkcnt_t st_blocks; - bool cache_used; - NFSServer *server; - char *path; - int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug; -} NFSClient; - -typedef struct NFSRPC { - BlockDriverState *bs; - int ret; - int complete; - QEMUIOVector *iov; - struct stat *st; - Coroutine *co; - NFSClient *client; -} NFSRPC; - -static int nfs_parse_uri(const char *filename, QDict *options, Error **err= p) -{ - URI *uri =3D NULL; - QueryParams *qp =3D NULL; - int ret =3D -EINVAL, i; - - uri =3D uri_parse(filename); - if (!uri) { - error_setg(errp, "Invalid URI specified"); - goto out; - } - if (g_strcmp0(uri->scheme, "nfs") !=3D 0) { - error_setg(errp, "URI scheme must be 'nfs'"); - goto out; - } - - if (!uri->server) { - error_setg(errp, "missing hostname in URI"); - goto out; - } - - if (!uri->path) { - error_setg(errp, "missing file path in URI"); - goto out; - } - - qp =3D query_params_parse(uri->query); - if (!qp) { - error_setg(errp, "could not parse query parameters"); - goto out; - } - - qdict_put_str(options, "server.host", uri->server); - qdict_put_str(options, "server.type", "inet"); - qdict_put_str(options, "path", uri->path); - - for (i =3D 0; i < qp->n; i++) { - unsigned long long val; - if (!qp->p[i].value) { - error_setg(errp, "Value for NFS parameter expected: %s", - qp->p[i].name); - goto out; - } - if (parse_uint_full(qp->p[i].value, &val, 0)) { - error_setg(errp, "Illegal value for NFS parameter: %s", - qp->p[i].name); - goto out; - } - if (!strcmp(qp->p[i].name, "uid")) { - qdict_put_str(options, "user", qp->p[i].value); - } else if (!strcmp(qp->p[i].name, "gid")) { - qdict_put_str(options, "group", qp->p[i].value); - } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) { - qdict_put_str(options, "tcp-syn-count", qp->p[i].value); - } else if (!strcmp(qp->p[i].name, "readahead")) { - qdict_put_str(options, "readahead-size", qp->p[i].value); - } else if (!strcmp(qp->p[i].name, "pagecache")) { - qdict_put_str(options, "page-cache-size", qp->p[i].value); - } else if (!strcmp(qp->p[i].name, "debug")) { - qdict_put_str(options, "debug", qp->p[i].value); - } else { - error_setg(errp, "Unknown NFS parameter name: %s", - qp->p[i].name); - goto out; - } - } - ret =3D 0; -out: - if (qp) { - query_params_free(qp); - } - if (uri) { - uri_free(uri); - } - return ret; -} - -static bool nfs_has_filename_options_conflict(QDict *options, Error **errp) -{ - const QDictEntry *qe; - - for (qe =3D qdict_first(options); qe; qe =3D qdict_next(options, qe)) { - if (!strcmp(qe->key, "host") || - !strcmp(qe->key, "path") || - !strcmp(qe->key, "user") || - !strcmp(qe->key, "group") || - !strcmp(qe->key, "tcp-syn-count") || - !strcmp(qe->key, "readahead-size") || - !strcmp(qe->key, "page-cache-size") || - !strcmp(qe->key, "debug") || - strstart(qe->key, "server.", NULL)) - { - error_setg(errp, "Option %s cannot be used with a filename", - qe->key); - return true; - } - } - - return false; -} - -static void nfs_parse_filename(const char *filename, QDict *options, - Error **errp) -{ - if (nfs_has_filename_options_conflict(options, errp)) { - return; - } - - nfs_parse_uri(filename, options, errp); -} - -static void nfs_process_read(void *arg); -static void nfs_process_write(void *arg); - -/* Called with QemuMutex held. */ -static void nfs_set_events(NFSClient *client) -{ - int ev =3D nfs_which_events(client->context); - if (ev !=3D client->events) { - aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context= ), - false, - (ev & POLLIN) ? nfs_process_read : NULL, - (ev & POLLOUT) ? nfs_process_write : NULL, - NULL, client); - - } - client->events =3D ev; -} - -static void nfs_process_read(void *arg) -{ - NFSClient *client =3D arg; - - qemu_mutex_lock(&client->mutex); - nfs_service(client->context, POLLIN); - nfs_set_events(client); - qemu_mutex_unlock(&client->mutex); -} - -static void nfs_process_write(void *arg) -{ - NFSClient *client =3D arg; - - qemu_mutex_lock(&client->mutex); - nfs_service(client->context, POLLOUT); - nfs_set_events(client); - qemu_mutex_unlock(&client->mutex); -} - -static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task) -{ - *task =3D (NFSRPC) { - .co =3D qemu_coroutine_self(), - .bs =3D bs, - .client =3D bs->opaque, - }; -} - -static void nfs_co_generic_bh_cb(void *opaque) -{ - NFSRPC *task =3D opaque; - - task->complete =3D 1; - aio_co_wake(task->co); -} - -/* Called (via nfs_service) with QemuMutex held. */ -static void -nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, - void *private_data) -{ - NFSRPC *task =3D private_data; - task->ret =3D ret; - assert(!task->st); - if (task->ret > 0 && task->iov) { - if (task->ret <=3D task->iov->size) { - qemu_iovec_from_buf(task->iov, 0, data, task->ret); - } else { - task->ret =3D -EIO; - } - } - if (task->ret < 0) { - error_report("NFS Error: %s", nfs_get_error(nfs)); - } - replay_bh_schedule_oneshot_event(task->client->aio_context, - nfs_co_generic_bh_cb, task); -} - -static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offse= t, - uint64_t bytes, QEMUIOVector *iov, - int flags) -{ - NFSClient *client =3D bs->opaque; - NFSRPC task; - - nfs_co_init_task(bs, &task); - task.iov =3D iov; - - WITH_QEMU_LOCK_GUARD(&client->mutex) { - if (nfs_pread_async(client->context, client->fh, - offset, bytes, nfs_co_generic_cb, &task) !=3D = 0) { - return -ENOMEM; - } - - nfs_set_events(client); - } - while (!task.complete) { - qemu_coroutine_yield(); - } - - if (task.ret < 0) { - return task.ret; - } - - /* zero pad short reads */ - if (task.ret < iov->size) { - qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret); - } - - return 0; -} - -static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offs= et, - uint64_t bytes, QEMUIOVector *iov, - int flags) -{ - NFSClient *client =3D bs->opaque; - NFSRPC task; - char *buf =3D NULL; - bool my_buffer =3D false; - - nfs_co_init_task(bs, &task); - - if (iov->niov !=3D 1) { - buf =3D g_try_malloc(bytes); - if (bytes && buf =3D=3D NULL) { - return -ENOMEM; - } - qemu_iovec_to_buf(iov, 0, buf, bytes); - my_buffer =3D true; - } else { - buf =3D iov->iov[0].iov_base; - } - - WITH_QEMU_LOCK_GUARD(&client->mutex) { - if (nfs_pwrite_async(client->context, client->fh, - offset, bytes, buf, - nfs_co_generic_cb, &task) !=3D 0) { - if (my_buffer) { - g_free(buf); - } - return -ENOMEM; - } - - nfs_set_events(client); - } - while (!task.complete) { - qemu_coroutine_yield(); - } - - if (my_buffer) { - g_free(buf); - } - - if (task.ret !=3D bytes) { - return task.ret < 0 ? task.ret : -EIO; - } - - return 0; -} - -static int coroutine_fn nfs_co_flush(BlockDriverState *bs) -{ - NFSClient *client =3D bs->opaque; - NFSRPC task; - - nfs_co_init_task(bs, &task); - - WITH_QEMU_LOCK_GUARD(&client->mutex) { - if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, - &task) !=3D 0) { - return -ENOMEM; - } - - nfs_set_events(client); - } - while (!task.complete) { - qemu_coroutine_yield(); - } - - return task.ret; -} - -static void nfs_detach_aio_context(BlockDriverState *bs) -{ - NFSClient *client =3D bs->opaque; - - aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), - false, NULL, NULL, NULL, NULL); - client->events =3D 0; -} - -static void nfs_attach_aio_context(BlockDriverState *bs, - AioContext *new_context) -{ - NFSClient *client =3D bs->opaque; - - client->aio_context =3D new_context; - nfs_set_events(client); -} - -static void nfs_client_close(NFSClient *client) -{ - if (client->context) { - qemu_mutex_lock(&client->mutex); - aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context= ), - false, NULL, NULL, NULL, NULL); - qemu_mutex_unlock(&client->mutex); - if (client->fh) { - nfs_close(client->context, client->fh); - client->fh =3D NULL; - } -#ifdef LIBNFS_FEATURE_UMOUNT - nfs_umount(client->context); -#endif - nfs_destroy_context(client->context); - client->context =3D NULL; - } - g_free(client->path); - qemu_mutex_destroy(&client->mutex); - qapi_free_NFSServer(client->server); - client->server =3D NULL; -} - -static void nfs_file_close(BlockDriverState *bs) -{ - NFSClient *client =3D bs->opaque; - nfs_client_close(client); -} - -static int64_t nfs_client_open(NFSClient *client, BlockdevOptionsNfs *opts, - int flags, int open_flags, Error **errp) -{ - int64_t ret =3D -EINVAL; - struct stat st; - char *file =3D NULL, *strp =3D NULL; - - qemu_mutex_init(&client->mutex); - - client->path =3D g_strdup(opts->path); - - strp =3D strrchr(client->path, '/'); - if (strp =3D=3D NULL) { - error_setg(errp, "Invalid URL specified"); - goto fail; - } - file =3D g_strdup(strp); - *strp =3D 0; - - /* Steal the NFSServer object from opts; set the original pointer to N= ULL - * to avoid use after free and double free. */ - client->server =3D opts->server; - opts->server =3D NULL; - - client->context =3D nfs_init_context(); - if (client->context =3D=3D NULL) { - error_setg(errp, "Failed to init NFS context"); - goto fail; - } - - if (opts->has_user) { - client->uid =3D opts->user; - nfs_set_uid(client->context, client->uid); - } - - if (opts->has_group) { - client->gid =3D opts->group; - nfs_set_gid(client->context, client->gid); - } - - if (opts->has_tcp_syn_count) { - client->tcp_syncnt =3D opts->tcp_syn_count; - nfs_set_tcp_syncnt(client->context, client->tcp_syncnt); - } - -#ifdef LIBNFS_FEATURE_READAHEAD - if (opts->has_readahead_size) { - if (open_flags & BDRV_O_NOCACHE) { - error_setg(errp, "Cannot enable NFS readahead " - "if cache.direct =3D on"); - goto fail; - } - client->readahead =3D opts->readahead_size; - if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) { - warn_report("Truncating NFS readahead size to %d", - QEMU_NFS_MAX_READAHEAD_SIZE); - client->readahead =3D QEMU_NFS_MAX_READAHEAD_SIZE; - } - nfs_set_readahead(client->context, client->readahead); -#ifdef LIBNFS_FEATURE_PAGECACHE - nfs_set_pagecache_ttl(client->context, 0); -#endif - client->cache_used =3D true; - } -#endif - -#ifdef LIBNFS_FEATURE_PAGECACHE - if (opts->has_page_cache_size) { - if (open_flags & BDRV_O_NOCACHE) { - error_setg(errp, "Cannot enable NFS pagecache " - "if cache.direct =3D on"); - goto fail; - } - client->pagecache =3D opts->page_cache_size; - if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) { - warn_report("Truncating NFS pagecache size to %d pages", - QEMU_NFS_MAX_PAGECACHE_SIZE); - client->pagecache =3D QEMU_NFS_MAX_PAGECACHE_SIZE; - } - nfs_set_pagecache(client->context, client->pagecache); - nfs_set_pagecache_ttl(client->context, 0); - client->cache_used =3D true; - } -#endif - -#ifdef LIBNFS_FEATURE_DEBUG - if (opts->has_debug) { - client->debug =3D opts->debug; - /* limit the maximum debug level to avoid potential flooding - * of our log files. */ - if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) { - warn_report("Limiting NFS debug level to %d", - QEMU_NFS_MAX_DEBUG_LEVEL); - client->debug =3D QEMU_NFS_MAX_DEBUG_LEVEL; - } - nfs_set_debug(client->context, client->debug); - } -#endif - - ret =3D nfs_mount(client->context, client->server->host, client->path); - if (ret < 0) { - error_setg(errp, "Failed to mount nfs share: %s", - nfs_get_error(client->context)); - goto fail; - } - - if (flags & O_CREAT) { - ret =3D nfs_creat(client->context, file, 0600, &client->fh); - if (ret < 0) { - error_setg(errp, "Failed to create file: %s", - nfs_get_error(client->context)); - goto fail; - } - } else { - ret =3D nfs_open(client->context, file, flags, &client->fh); - if (ret < 0) { - error_setg(errp, "Failed to open file : %s", - nfs_get_error(client->context)); - goto fail; - } - } - - ret =3D nfs_fstat(client->context, client->fh, &st); - if (ret < 0) { - error_setg(errp, "Failed to fstat file: %s", - nfs_get_error(client->context)); - goto fail; - } - - ret =3D DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE); - client->st_blocks =3D st.st_blocks; - client->has_zero_init =3D S_ISREG(st.st_mode); - *strp =3D '/'; - goto out; - -fail: - nfs_client_close(client); -out: - g_free(file); - return ret; -} - -static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options, - Error **errp) -{ - BlockdevOptionsNfs *opts =3D NULL; - Visitor *v; - const QDictEntry *e; - - v =3D qobject_input_visitor_new_flat_confused(options, errp); - if (!v) { - return NULL; - } - - visit_type_BlockdevOptionsNfs(v, NULL, &opts, errp); - visit_free(v); - if (!opts) { - return NULL; - } - - /* Remove the processed options from the QDict (the visitor processes - * _all_ options in the QDict) */ - while ((e =3D qdict_first(options))) { - qdict_del(options, e->key); - } - - return opts; -} - -static int64_t nfs_client_open_qdict(NFSClient *client, QDict *options, - int flags, int open_flags, Error **er= rp) -{ - BlockdevOptionsNfs *opts; - int ret; - - opts =3D nfs_options_qdict_to_qapi(options, errp); - if (opts =3D=3D NULL) { - ret =3D -EINVAL; - goto fail; - } - - ret =3D nfs_client_open(client, opts, flags, open_flags, errp); -fail: - qapi_free_BlockdevOptionsNfs(opts); - return ret; -} - -static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, - Error **errp) { - NFSClient *client =3D bs->opaque; - int64_t ret; - - client->aio_context =3D bdrv_get_aio_context(bs); - - ret =3D nfs_client_open_qdict(client, options, - (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY, - bs->open_flags, errp); - if (ret < 0) { - return ret; - } - - bs->total_sectors =3D ret; - if (client->has_zero_init) { - bs->supported_truncate_flags =3D BDRV_REQ_ZERO_WRITE; - } - return 0; -} - -static QemuOptsList nfs_create_opts =3D { - .name =3D "nfs-create-opts", - .head =3D QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head), - .desc =3D { - { - .name =3D BLOCK_OPT_SIZE, - .type =3D QEMU_OPT_SIZE, - .help =3D "Virtual disk size" - }, - { /* end of list */ } - } -}; - -static int nfs_file_co_create(BlockdevCreateOptions *options, Error **errp) -{ - BlockdevCreateOptionsNfs *opts =3D &options->u.nfs; - NFSClient *client =3D g_new0(NFSClient, 1); - int ret; - - assert(options->driver =3D=3D BLOCKDEV_DRIVER_NFS); - - client->aio_context =3D qemu_get_aio_context(); - - ret =3D nfs_client_open(client, opts->location, O_CREAT, 0, errp); - if (ret < 0) { - goto out; - } - ret =3D nfs_ftruncate(client->context, client->fh, opts->size); - nfs_client_close(client); - -out: - g_free(client); - return ret; -} - -static int coroutine_fn nfs_file_co_create_opts(BlockDriver *drv, - const char *url, - QemuOpts *opts, - Error **errp) -{ - BlockdevCreateOptions *create_options; - BlockdevCreateOptionsNfs *nfs_opts; - QDict *options; - int ret; - - create_options =3D g_new0(BlockdevCreateOptions, 1); - create_options->driver =3D BLOCKDEV_DRIVER_NFS; - nfs_opts =3D &create_options->u.nfs; - - /* Read out options */ - nfs_opts->size =3D ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE= , 0), - BDRV_SECTOR_SIZE); - - options =3D qdict_new(); - ret =3D nfs_parse_uri(url, options, errp); - if (ret < 0) { - goto out; - } - - nfs_opts->location =3D nfs_options_qdict_to_qapi(options, errp); - if (nfs_opts->location =3D=3D NULL) { - ret =3D -EINVAL; - goto out; - } - - ret =3D nfs_file_co_create(create_options, errp); - if (ret < 0) { - goto out; - } - - ret =3D 0; -out: - qobject_unref(options); - qapi_free_BlockdevCreateOptions(create_options); - return ret; -} - -static int nfs_has_zero_init(BlockDriverState *bs) -{ - NFSClient *client =3D bs->opaque; - return client->has_zero_init; -} - -/* Called (via nfs_service) with QemuMutex held. */ -static void -nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *dat= a, - void *private_data) -{ - NFSRPC *task =3D private_data; - task->ret =3D ret; - if (task->ret =3D=3D 0) { - memcpy(task->st, data, sizeof(struct stat)); - } - if (task->ret < 0) { - error_report("NFS Error: %s", nfs_get_error(nfs)); - } - - /* Set task->complete before reading bs->wakeup. */ - atomic_mb_set(&task->complete, 1); - bdrv_wakeup(task->bs); -} - -static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) -{ - NFSClient *client =3D bs->opaque; - NFSRPC task =3D {0}; - struct stat st; - - if (bdrv_is_read_only(bs) && - !(bs->open_flags & BDRV_O_NOCACHE)) { - return client->st_blocks * 512; - } - - task.bs =3D bs; - task.st =3D &st; - if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_fil= e_size_cb, - &task) !=3D 0) { - return -ENOMEM; - } - - nfs_set_events(client); - BDRV_POLL_WHILE(bs, !task.complete); - - return (task.ret < 0 ? task.ret : st.st_blocks * 512); -} - -static int coroutine_fn -nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, - PreallocMode prealloc, BdrvRequestFlags flags, - Error **errp) -{ - NFSClient *client =3D bs->opaque; - int ret; - - if (prealloc !=3D PREALLOC_MODE_OFF) { - error_setg(errp, "Unsupported preallocation mode '%s'", - PreallocMode_str(prealloc)); - return -ENOTSUP; - } - - ret =3D nfs_ftruncate(client->context, client->fh, offset); - if (ret < 0) { - error_setg_errno(errp, -ret, "Failed to truncate file"); - return ret; - } - - return 0; -} - -/* Note that this will not re-establish a connection with the NFS server - * - it is effectively a NOP. */ -static int nfs_reopen_prepare(BDRVReopenState *state, - BlockReopenQueue *queue, Error **errp) -{ - NFSClient *client =3D state->bs->opaque; - struct stat st; - int ret =3D 0; - - if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) { - error_setg(errp, "Cannot open a read-only mount as read-write"); - return -EACCES; - } - - if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) { - error_setg(errp, "Cannot disable cache if libnfs readahead or" - " pagecache is enabled"); - return -EINVAL; - } - - /* Update cache for read-only reopens */ - if (!(state->flags & BDRV_O_RDWR)) { - ret =3D nfs_fstat(client->context, client->fh, &st); - if (ret < 0) { - error_setg(errp, "Failed to fstat file: %s", - nfs_get_error(client->context)); - return ret; - } - client->st_blocks =3D st.st_blocks; - } - - return 0; -} - -static void nfs_refresh_filename(BlockDriverState *bs) -{ - NFSClient *client =3D bs->opaque; - - if (client->uid && !client->gid) { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nfs://%s%s?uid=3D%" PRId64, client->server->host, client= ->path, - client->uid); - } else if (!client->uid && client->gid) { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nfs://%s%s?gid=3D%" PRId64, client->server->host, client= ->path, - client->gid); - } else if (client->uid && client->gid) { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nfs://%s%s?uid=3D%" PRId64 "&gid=3D%" PRId64, - client->server->host, client->path, client->uid, client->= gid); - } else { - snprintf(bs->exact_filename, sizeof(bs->exact_filename), - "nfs://%s%s", client->server->host, client->path); - } -} - -static char *nfs_dirname(BlockDriverState *bs, Error **errp) -{ - NFSClient *client =3D bs->opaque; - - if (client->uid || client->gid) { - bdrv_refresh_filename(bs); - error_setg(errp, "Cannot generate a base directory for NFS node '%= s'", - bs->filename); - return NULL; - } - - return g_strdup_printf("nfs://%s%s/", client->server->host, client->pa= th); -} - -#ifdef LIBNFS_FEATURE_PAGECACHE -static void coroutine_fn nfs_co_invalidate_cache(BlockDriverState *bs, - Error **errp) -{ - NFSClient *client =3D bs->opaque; - nfs_pagecache_invalidate(client->context, client->fh); -} -#endif - -static const char *nfs_strong_runtime_opts[] =3D { - "path", - "user", - "group", - "server.", - - NULL -}; - -static BlockDriver bdrv_nfs =3D { - .format_name =3D "nfs", - .protocol_name =3D "nfs", - - .instance_size =3D sizeof(NFSClient), - .bdrv_parse_filename =3D nfs_parse_filename, - .create_opts =3D &nfs_create_opts, - - .bdrv_has_zero_init =3D nfs_has_zero_init, - .bdrv_get_allocated_file_size =3D nfs_get_allocated_file_size, - .bdrv_co_truncate =3D nfs_file_co_truncate, - - .bdrv_file_open =3D nfs_file_open, - .bdrv_close =3D nfs_file_close, - .bdrv_co_create =3D nfs_file_co_create, - .bdrv_co_create_opts =3D nfs_file_co_create_opts, - .bdrv_reopen_prepare =3D nfs_reopen_prepare, - - .bdrv_co_preadv =3D nfs_co_preadv, - .bdrv_co_pwritev =3D nfs_co_pwritev, - .bdrv_co_flush_to_disk =3D nfs_co_flush, - - .bdrv_detach_aio_context =3D nfs_detach_aio_context, - .bdrv_attach_aio_context =3D nfs_attach_aio_context, - .bdrv_refresh_filename =3D nfs_refresh_filename, - .bdrv_dirname =3D nfs_dirname, - - .strong_runtime_opts =3D nfs_strong_runtime_opts, - -#ifdef LIBNFS_FEATURE_PAGECACHE - .bdrv_co_invalidate_cache =3D nfs_co_invalidate_cache, -#endif -}; - -static void nfs_block_init(void) -{ - bdrv_register(&bdrv_nfs); -} - -block_init(nfs_block_init); +/* + * QEMU Block driver for native access to files on NFS shares + * + * Copyright (c) 2014-2017 Peter Lieven + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included= in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS= OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OT= HER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING= FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS = IN + * THE SOFTWARE. + */ + +#include "qemu/osdep.h" + +#if !defined(_WIN32) +#include +#endif +#include "qemu/config-file.h" +#include "qemu/error-report.h" +#include "qapi/error.h" +#include "block/block_int.h" +#include "block/qdict.h" +#include "trace.h" +#include "qemu/iov.h" +#include "qemu/main-loop.h" +#include "qemu/module.h" +#include "qemu/option.h" +#include "qemu/uri.h" +#include "qemu/cutils.h" +#include "sysemu/sysemu.h" +#include "sysemu/replay.h" +#include "qapi/qapi-visit-block-core.h" +#include "qapi/qmp/qdict.h" +#include "qapi/qmp/qstring.h" +#include "qapi/qobject-input-visitor.h" +#include "qapi/qobject-output-visitor.h" +#include + + +#define QEMU_NFS_MAX_READAHEAD_SIZE 1048576 +#define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE) +#define QEMU_NFS_MAX_DEBUG_LEVEL 2 + +#if defined (_WIN32) +#define nfs_stat __stat64 +#else +#define nfs_stat stat +#endif + +typedef struct NFSClient { + struct nfs_context *context; + struct nfsfh *fh; + int events; + bool has_zero_init; + AioContext *aio_context; + QemuMutex mutex; + int64_t st_size; + bool cache_used; + NFSServer *server; + char *path; + int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug; +} NFSClient; + +typedef struct NFSRPC { + BlockDriverState *bs; + int ret; + int complete; + QEMUIOVector *iov; + struct nfs_stat *st; + Coroutine *co; + NFSClient *client; +} NFSRPC; + +static int nfs_parse_uri(const char *filename, QDict *options, Error **err= p) +{ + URI *uri =3D NULL; + QueryParams *qp =3D NULL; + int ret =3D -EINVAL, i; + + uri =3D uri_parse(filename); + if (!uri) { + error_setg(errp, "Invalid URI specified"); + goto out; + } + if (g_strcmp0(uri->scheme, "nfs") !=3D 0) { + error_setg(errp, "URI scheme must be 'nfs'"); + goto out; + } + + if (!uri->server) { + error_setg(errp, "missing hostname in URI"); + goto out; + } + + if (!uri->path) { + error_setg(errp, "missing file path in URI"); + goto out; + } + + qp =3D query_params_parse(uri->query); + if (!qp) { + error_setg(errp, "could not parse query parameters"); + goto out; + } + + qdict_put_str(options, "server.host", uri->server); + qdict_put_str(options, "server.type", "inet"); + qdict_put_str(options, "path", uri->path); + + for (i =3D 0; i < qp->n; i++) { + unsigned long long val; + if (!qp->p[i].value) { + error_setg(errp, "Value for NFS parameter expected: %s", + qp->p[i].name); + goto out; + } + if (parse_uint_full(qp->p[i].value, &val, 0)) { + error_setg(errp, "Illegal value for NFS parameter: %s", + qp->p[i].name); + goto out; + } + if (!strcmp(qp->p[i].name, "uid")) { + qdict_put_str(options, "user", qp->p[i].value); + } else if (!strcmp(qp->p[i].name, "gid")) { + qdict_put_str(options, "group", qp->p[i].value); + } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) { + qdict_put_str(options, "tcp-syn-count", qp->p[i].value); + } else if (!strcmp(qp->p[i].name, "readahead")) { + qdict_put_str(options, "readahead-size", qp->p[i].value); + } else if (!strcmp(qp->p[i].name, "pagecache")) { + qdict_put_str(options, "page-cache-size", qp->p[i].value); + } else if (!strcmp(qp->p[i].name, "debug")) { + qdict_put_str(options, "debug", qp->p[i].value); + } else { + error_setg(errp, "Unknown NFS parameter name: %s", + qp->p[i].name); + goto out; + } + } + ret =3D 0; +out: + if (qp) { + query_params_free(qp); + } + if (uri) { + uri_free(uri); + } + return ret; +} + +static bool nfs_has_filename_options_conflict(QDict *options, Error **errp) +{ + const QDictEntry *qe; + + for (qe =3D qdict_first(options); qe; qe =3D qdict_next(options, qe)) { + if (!strcmp(qe->key, "host") || + !strcmp(qe->key, "path") || + !strcmp(qe->key, "user") || + !strcmp(qe->key, "group") || + !strcmp(qe->key, "tcp-syn-count") || + !strcmp(qe->key, "readahead-size") || + !strcmp(qe->key, "page-cache-size") || + !strcmp(qe->key, "debug") || + strstart(qe->key, "server.", NULL)) + { + error_setg(errp, "Option %s cannot be used with a filename", + qe->key); + return true; + } + } + + return false; +} + +static void nfs_parse_filename(const char *filename, QDict *options, + Error **errp) +{ + if (nfs_has_filename_options_conflict(options, errp)) { + return; + } + + nfs_parse_uri(filename, options, errp); +} + +static void nfs_process_read(void *arg); +static void nfs_process_write(void *arg); + +/* Called with QemuMutex held. */ +static void nfs_set_events(NFSClient *client) +{ + int ev =3D nfs_which_events(client->context); + if (ev !=3D client->events) { + aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context= ), + false, + (ev & POLLIN) ? nfs_process_read : NULL, + (ev & POLLOUT) ? nfs_process_write : NULL, + NULL, client); + + } + client->events =3D ev; +} + +static void nfs_process_read(void *arg) +{ + NFSClient *client =3D arg; + + qemu_mutex_lock(&client->mutex); + nfs_service(client->context, POLLIN); + nfs_set_events(client); + qemu_mutex_unlock(&client->mutex); +} + +static void nfs_process_write(void *arg) +{ + NFSClient *client =3D arg; + + qemu_mutex_lock(&client->mutex); + nfs_service(client->context, POLLOUT); + nfs_set_events(client); + qemu_mutex_unlock(&client->mutex); +} + +static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task) +{ + *task =3D (NFSRPC) { + .co =3D qemu_coroutine_self(), + .bs =3D bs, + .client =3D bs->opaque, + }; +} + +static void nfs_co_generic_bh_cb(void *opaque) +{ + NFSRPC *task =3D opaque; + + task->complete =3D 1; + aio_co_wake(task->co); +} + +/* Called (via nfs_service) with QemuMutex held. */ +static void +nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, + void *private_data) +{ + NFSRPC *task =3D private_data; + task->ret =3D ret; + assert(!task->st); + if (task->ret > 0 && task->iov) { + if (task->ret <=3D task->iov->size) { + qemu_iovec_from_buf(task->iov, 0, data, task->ret); + } else { + task->ret =3D -EIO; + } + } + if (task->ret < 0) { + error_report("NFS Error: %s", nfs_get_error(nfs)); + } + replay_bh_schedule_oneshot_event(task->client->aio_context, + nfs_co_generic_bh_cb, task); +} + +static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offse= t, + uint64_t bytes, QEMUIOVector *iov, + int flags) +{ + NFSClient *client =3D bs->opaque; + NFSRPC task; + + nfs_co_init_task(bs, &task); + task.iov =3D iov; + + WITH_QEMU_LOCK_GUARD(&client->mutex) { + if (nfs_pread_async(client->context, client->fh, + offset, bytes, nfs_co_generic_cb, &task) !=3D = 0) { + return -ENOMEM; + } + + nfs_set_events(client); + } + while (!task.complete) { + qemu_coroutine_yield(); + } + + if (task.ret < 0) { + return task.ret; + } + + /* zero pad short reads */ + if (task.ret < iov->size) { + qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret); + } + + return 0; +} + +static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offs= et, + uint64_t bytes, QEMUIOVector *iov, + int flags) +{ + NFSClient *client =3D bs->opaque; + NFSRPC task; + char *buf =3D NULL; + bool my_buffer =3D false; + + nfs_co_init_task(bs, &task); + + if (iov->niov !=3D 1) { + buf =3D g_try_malloc(bytes); + if (bytes && buf =3D=3D NULL) { + return -ENOMEM; + } + qemu_iovec_to_buf(iov, 0, buf, bytes); + my_buffer =3D true; + } else { + buf =3D iov->iov[0].iov_base; + } + + WITH_QEMU_LOCK_GUARD(&client->mutex) { + if (nfs_pwrite_async(client->context, client->fh, + offset, bytes, buf, + nfs_co_generic_cb, &task) !=3D 0) { + if (my_buffer) { + g_free(buf); + } + return -ENOMEM; + } + + nfs_set_events(client); + } + while (!task.complete) { + qemu_coroutine_yield(); + } + + if (my_buffer) { + g_free(buf); + } + + if (task.ret !=3D bytes) { + return task.ret < 0 ? task.ret : -EIO; + } + + return 0; +} + +static int coroutine_fn nfs_co_flush(BlockDriverState *bs) +{ + NFSClient *client =3D bs->opaque; + NFSRPC task; + + nfs_co_init_task(bs, &task); + + WITH_QEMU_LOCK_GUARD(&client->mutex) { + if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, + &task) !=3D 0) { + return -ENOMEM; + } + + nfs_set_events(client); + } + while (!task.complete) { + qemu_coroutine_yield(); + } + + return task.ret; +} + +static void nfs_detach_aio_context(BlockDriverState *bs) +{ + NFSClient *client =3D bs->opaque; + + aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context), + false, NULL, NULL, NULL, NULL); + client->events =3D 0; +} + +static void nfs_attach_aio_context(BlockDriverState *bs, + AioContext *new_context) +{ + NFSClient *client =3D bs->opaque; + + client->aio_context =3D new_context; + nfs_set_events(client); +} + +static void nfs_client_close(NFSClient *client) +{ + if (client->context) { + qemu_mutex_lock(&client->mutex); + aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context= ), + false, NULL, NULL, NULL, NULL); + qemu_mutex_unlock(&client->mutex); + if (client->fh) { + nfs_close(client->context, client->fh); + client->fh =3D NULL; + } +#ifdef LIBNFS_FEATURE_UMOUNT + nfs_umount(client->context); +#endif + nfs_destroy_context(client->context); + client->context =3D NULL; + } + g_free(client->path); + qemu_mutex_destroy(&client->mutex); + qapi_free_NFSServer(client->server); + client->server =3D NULL; +} + +static void nfs_file_close(BlockDriverState *bs) +{ + NFSClient *client =3D bs->opaque; + nfs_client_close(client); +} + +static int64_t nfs_client_open(NFSClient *client, BlockdevOptionsNfs *opts, + int flags, int open_flags, Error **errp) +{ + int64_t ret =3D -EINVAL; + struct nfs_stat st; + char *file =3D NULL, *strp =3D NULL; + + qemu_mutex_init(&client->mutex); + + client->path =3D g_strdup(opts->path); + + strp =3D strrchr(client->path, '/'); + if (strp =3D=3D NULL) { + error_setg(errp, "Invalid URL specified"); + goto fail; + } + file =3D g_strdup(strp); + *strp =3D 0; + + /* Steal the NFSServer object from opts; set the original pointer to N= ULL + * to avoid use after free and double free. */ + client->server =3D opts->server; + opts->server =3D NULL; + + client->context =3D nfs_init_context(); + if (client->context =3D=3D NULL) { + error_setg(errp, "Failed to init NFS context"); + goto fail; + } + + if (opts->has_user) { + client->uid =3D opts->user; + nfs_set_uid(client->context, client->uid); + } + + if (opts->has_group) { + client->gid =3D opts->group; + nfs_set_gid(client->context, client->gid); + } + + if (opts->has_tcp_syn_count) { + client->tcp_syncnt =3D opts->tcp_syn_count; + nfs_set_tcp_syncnt(client->context, client->tcp_syncnt); + } + +#ifdef LIBNFS_FEATURE_READAHEAD + if (opts->has_readahead_size) { + if (open_flags & BDRV_O_NOCACHE) { + error_setg(errp, "Cannot enable NFS readahead " + "if cache.direct =3D on"); + goto fail; + } + client->readahead =3D opts->readahead_size; + if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) { + warn_report("Truncating NFS readahead size to %d", + QEMU_NFS_MAX_READAHEAD_SIZE); + client->readahead =3D QEMU_NFS_MAX_READAHEAD_SIZE; + } + nfs_set_readahead(client->context, client->readahead); +#ifdef LIBNFS_FEATURE_PAGECACHE + nfs_set_pagecache_ttl(client->context, 0); +#endif + client->cache_used =3D true; + } +#endif + +#ifdef LIBNFS_FEATURE_PAGECACHE + if (opts->has_page_cache_size) { + if (open_flags & BDRV_O_NOCACHE) { + error_setg(errp, "Cannot enable NFS pagecache " + "if cache.direct =3D on"); + goto fail; + } + client->pagecache =3D opts->page_cache_size; + if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) { + warn_report("Truncating NFS pagecache size to %d pages", + QEMU_NFS_MAX_PAGECACHE_SIZE); + client->pagecache =3D QEMU_NFS_MAX_PAGECACHE_SIZE; + } + nfs_set_pagecache(client->context, client->pagecache); + nfs_set_pagecache_ttl(client->context, 0); + client->cache_used =3D true; + } +#endif + +#ifdef LIBNFS_FEATURE_DEBUG + if (opts->has_debug) { + client->debug =3D opts->debug; + /* limit the maximum debug level to avoid potential flooding + * of our log files. */ + if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) { + warn_report("Limiting NFS debug level to %d", + QEMU_NFS_MAX_DEBUG_LEVEL); + client->debug =3D QEMU_NFS_MAX_DEBUG_LEVEL; + } + nfs_set_debug(client->context, client->debug); + } +#endif + + ret =3D nfs_mount(client->context, client->server->host, client->path); + if (ret < 0) { + error_setg(errp, "Failed to mount nfs share: %s", + nfs_get_error(client->context)); + goto fail; + } + + if (flags & O_CREAT) { + ret =3D nfs_creat(client->context, file, 0600, &client->fh); + if (ret < 0) { + error_setg(errp, "Failed to create file: %s", + nfs_get_error(client->context)); + goto fail; + } + } else { + ret =3D nfs_open(client->context, file, flags, &client->fh); + if (ret < 0) { + error_setg(errp, "Failed to open file : %s", + nfs_get_error(client->context)); + goto fail; + } + } + + ret =3D nfs_fstat(client->context, client->fh, &st); + if (ret < 0) { + error_setg(errp, "Failed to fstat file: %s", + nfs_get_error(client->context)); + goto fail; + } + + ret =3D DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE); + client->st_size =3D st.st_size; + client->has_zero_init =3D S_ISREG(st.st_mode); + *strp =3D '/'; + goto out; + +fail: + nfs_client_close(client); +out: + g_free(file); + return ret; +} + +static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options, + Error **errp) +{ + BlockdevOptionsNfs *opts =3D NULL; + Visitor *v; + const QDictEntry *e; + + v =3D qobject_input_visitor_new_flat_confused(options, errp); + if (!v) { + return NULL; + } + + visit_type_BlockdevOptionsNfs(v, NULL, &opts, errp); + visit_free(v); + if (!opts) { + return NULL; + } + + /* Remove the processed options from the QDict (the visitor processes + * _all_ options in the QDict) */ + while ((e =3D qdict_first(options))) { + qdict_del(options, e->key); + } + + return opts; +} + +static int64_t nfs_client_open_qdict(NFSClient *client, QDict *options, + int flags, int open_flags, Error **er= rp) +{ + BlockdevOptionsNfs *opts; + int ret; + + opts =3D nfs_options_qdict_to_qapi(options, errp); + if (opts =3D=3D NULL) { + ret =3D -EINVAL; + goto fail; + } + + ret =3D nfs_client_open(client, opts, flags, open_flags, errp); +fail: + qapi_free_BlockdevOptionsNfs(opts); + return ret; +} + +static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) { + NFSClient *client =3D bs->opaque; + int64_t ret; + + client->aio_context =3D bdrv_get_aio_context(bs); + + ret =3D nfs_client_open_qdict(client, options, + (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY, + bs->open_flags, errp); + if (ret < 0) { + return ret; + } + + bs->total_sectors =3D ret; + if (client->has_zero_init) { + bs->supported_truncate_flags =3D BDRV_REQ_ZERO_WRITE; + } + return 0; +} + +static QemuOptsList nfs_create_opts =3D { + .name =3D "nfs-create-opts", + .head =3D QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head), + .desc =3D { + { + .name =3D BLOCK_OPT_SIZE, + .type =3D QEMU_OPT_SIZE, + .help =3D "Virtual disk size" + }, + { /* end of list */ } + } +}; + +static int nfs_file_co_create(BlockdevCreateOptions *options, Error **errp) +{ + BlockdevCreateOptionsNfs *opts =3D &options->u.nfs; + NFSClient *client =3D g_new0(NFSClient, 1); + int ret; + + assert(options->driver =3D=3D BLOCKDEV_DRIVER_NFS); + + client->aio_context =3D qemu_get_aio_context(); + + ret =3D nfs_client_open(client, opts->location, O_CREAT, 0, errp); + if (ret < 0) { + goto out; + } + ret =3D nfs_ftruncate(client->context, client->fh, opts->size); + nfs_client_close(client); + +out: + g_free(client); + return ret; +} + +static int coroutine_fn nfs_file_co_create_opts(BlockDriver *drv, + const char *url, + QemuOpts *opts, + Error **errp) +{ + BlockdevCreateOptions *create_options; + BlockdevCreateOptionsNfs *nfs_opts; + QDict *options; + int ret; + + create_options =3D g_new0(BlockdevCreateOptions, 1); + create_options->driver =3D BLOCKDEV_DRIVER_NFS; + nfs_opts =3D &create_options->u.nfs; + + /* Read out options */ + nfs_opts->size =3D ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE= , 0), + BDRV_SECTOR_SIZE); + + options =3D qdict_new(); + ret =3D nfs_parse_uri(url, options, errp); + if (ret < 0) { + goto out; + } + + nfs_opts->location =3D nfs_options_qdict_to_qapi(options, errp); + if (nfs_opts->location =3D=3D NULL) { + ret =3D -EINVAL; + goto out; + } + + ret =3D nfs_file_co_create(create_options, errp); + if (ret < 0) { + goto out; + } + + ret =3D 0; +out: + qobject_unref(options); + qapi_free_BlockdevCreateOptions(create_options); + return ret; +} + +static int nfs_has_zero_init(BlockDriverState *bs) +{ + NFSClient *client =3D bs->opaque; + return client->has_zero_init; +} + +/* Called (via nfs_service) with QemuMutex held. */ +static void +nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *dat= a, + void *private_data) +{ + NFSRPC *task =3D private_data; + task->ret =3D ret; + if (task->ret =3D=3D 0) { + memcpy(task->st, data, sizeof(struct stat)); + } + if (task->ret < 0) { + error_report("NFS Error: %s", nfs_get_error(nfs)); + } + + /* Set task->complete before reading bs->wakeup. */ + atomic_mb_set(&task->complete, 1); + bdrv_wakeup(task->bs); +} + +static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) +{ + NFSClient *client =3D bs->opaque; + NFSRPC task =3D {0}; + struct nfs_stat st; + + if (bdrv_is_read_only(bs) && + !(bs->open_flags & BDRV_O_NOCACHE)) { + return client->st_size; + } + + task.bs =3D bs; + task.st =3D &st; + if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_fil= e_size_cb, + &task) !=3D 0) { + return -ENOMEM; + } + + nfs_set_events(client); + BDRV_POLL_WHILE(bs, !task.complete); + + return (task.ret < 0 ? task.ret : st.st_size); +} + +static int coroutine_fn +nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, + PreallocMode prealloc, BdrvRequestFlags flags, + Error **errp) +{ + NFSClient *client =3D bs->opaque; + int ret; + + if (prealloc !=3D PREALLOC_MODE_OFF) { + error_setg(errp, "Unsupported preallocation mode '%s'", + PreallocMode_str(prealloc)); + return -ENOTSUP; + } + + ret =3D nfs_ftruncate(client->context, client->fh, offset); + if (ret < 0) { + error_setg_errno(errp, -ret, "Failed to truncate file"); + return ret; + } + + return 0; +} + +/* Note that this will not re-establish a connection with the NFS server + * - it is effectively a NOP. */ +static int nfs_reopen_prepare(BDRVReopenState *state, + BlockReopenQueue *queue, Error **errp) +{ + NFSClient *client =3D state->bs->opaque; + struct nfs_stat st; + int ret =3D 0; + + if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) { + error_setg(errp, "Cannot open a read-only mount as read-write"); + return -EACCES; + } + + if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) { + error_setg(errp, "Cannot disable cache if libnfs readahead or" + " pagecache is enabled"); + return -EINVAL; + } + + /* Update cache for read-only reopens */ + if (!(state->flags & BDRV_O_RDWR)) { + ret =3D nfs_fstat(client->context, client->fh, &st); + if (ret < 0) { + error_setg(errp, "Failed to fstat file: %s", + nfs_get_error(client->context)); + return ret; + } + client->st_size =3D st.st_size; + } + + return 0; +} + +static void nfs_refresh_filename(BlockDriverState *bs) +{ + NFSClient *client =3D bs->opaque; + + if (client->uid && !client->gid) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nfs://%s%s?uid=3D%" PRId64, client->server->host, client= ->path, + client->uid); + } else if (!client->uid && client->gid) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nfs://%s%s?gid=3D%" PRId64, client->server->host, client= ->path, + client->gid); + } else if (client->uid && client->gid) { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nfs://%s%s?uid=3D%" PRId64 "&gid=3D%" PRId64, + client->server->host, client->path, client->uid, client->= gid); + } else { + snprintf(bs->exact_filename, sizeof(bs->exact_filename), + "nfs://%s%s", client->server->host, client->path); + } +} + +static char *nfs_dirname(BlockDriverState *bs, Error **errp) +{ + NFSClient *client =3D bs->opaque; + + if (client->uid || client->gid) { + bdrv_refresh_filename(bs); + error_setg(errp, "Cannot generate a base directory for NFS node '%= s'", + bs->filename); + return NULL; + } + + return g_strdup_printf("nfs://%s%s/", client->server->host, client->pa= th); +} + +#ifdef LIBNFS_FEATURE_PAGECACHE +static void coroutine_fn nfs_co_invalidate_cache(BlockDriverState *bs, + Error **errp) +{ + NFSClient *client =3D bs->opaque; + nfs_pagecache_invalidate(client->context, client->fh); +} +#endif + +static const char *nfs_strong_runtime_opts[] =3D { + "path", + "user", + "group", + "server.", + + NULL +}; + +static BlockDriver bdrv_nfs =3D { + .format_name =3D "nfs", + .protocol_name =3D "nfs", + + .instance_size =3D sizeof(NFSClient), + .bdrv_parse_filename =3D nfs_parse_filename, + .create_opts =3D &nfs_create_opts, + + .bdrv_has_zero_init =3D nfs_has_zero_init, + .bdrv_get_allocated_file_size =3D nfs_get_allocated_file_size, + .bdrv_co_truncate =3D nfs_file_co_truncate, + + .bdrv_file_open =3D nfs_file_open, + .bdrv_close =3D nfs_file_close, + .bdrv_co_create =3D nfs_file_co_create, + .bdrv_co_create_opts =3D nfs_file_co_create_opts, + .bdrv_reopen_prepare =3D nfs_reopen_prepare, + + .bdrv_co_preadv =3D nfs_co_preadv, + .bdrv_co_pwritev =3D nfs_co_pwritev, + .bdrv_co_flush_to_disk =3D nfs_co_flush, + + .bdrv_detach_aio_context =3D nfs_detach_aio_context, + .bdrv_attach_aio_context =3D nfs_attach_aio_context, + .bdrv_refresh_filename =3D nfs_refresh_filename, + .bdrv_dirname =3D nfs_dirname, + + .strong_runtime_opts =3D nfs_strong_runtime_opts, + +#ifdef LIBNFS_FEATURE_PAGECACHE + .bdrv_co_invalidate_cache =3D nfs_co_invalidate_cache, +#endif +}; + +static void nfs_block_init(void) +{ + bdrv_register(&bdrv_nfs); +} + +block_init(nfs_block_init); --=20 2.28.0.windows.1