blob: c24df49747d36c72d4b943621b774bedc7bd048c [file] [log] [blame]
Peter Lieven6542aa92014-02-03 10:26:13 +01001/*
2 * QEMU Block driver for native access to files on NFS shares
3 *
Peter Lievenf1a7ff72017-11-27 17:00:07 +01004 * Copyright (c) 2014-2017 Peter Lieven <pl@kamp.de>
Peter Lieven6542aa92014-02-03 10:26:13 +01005 *
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
Peter Maydell80c71a22016-01-18 18:01:42 +000025#include "qemu/osdep.h"
Peter Lieven6542aa92014-02-03 10:26:13 +010026
Yonggang Luoc63b0202020-11-05 20:31:15 +080027#if !defined(_WIN32)
Peter Lieven6542aa92014-02-03 10:26:13 +010028#include <poll.h>
Yonggang Luoc63b0202020-11-05 20:31:15 +080029#endif
Peter Lieven6542aa92014-02-03 10:26:13 +010030#include "qemu/config-file.h"
31#include "qemu/error-report.h"
Stefan Hajnoczid165b8c2016-03-30 13:46:33 +010032#include "qapi/error.h"
Markus Armbrustere2c1c342022-12-21 14:35:49 +010033#include "block/block-io.h"
Peter Lieven6542aa92014-02-03 10:26:13 +010034#include "block/block_int.h"
Max Reitz609f45e2018-06-14 21:14:28 +020035#include "block/qdict.h"
Peter Lieven6542aa92014-02-03 10:26:13 +010036#include "trace.h"
37#include "qemu/iov.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020038#include "qemu/main-loop.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020039#include "qemu/module.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010040#include "qemu/option.h"
Peter Lieven6542aa92014-02-03 10:26:13 +010041#include "qemu/uri.h"
Stefan Hajnoczi0d94b742016-03-30 13:46:34 +010042#include "qemu/cutils.h"
Pavel Dovgalyuke4ec5ad2019-09-17 14:58:19 +030043#include "sysemu/replay.h"
Markus Armbruster9af23982018-02-11 10:36:01 +010044#include "qapi/qapi-visit-block-core.h"
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053045#include "qapi/qmp/qdict.h"
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053046#include "qapi/qmp/qstring.h"
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053047#include "qapi/qobject-input-visitor.h"
48#include "qapi/qobject-output-visitor.h"
Peter Lieven6542aa92014-02-03 10:26:13 +010049#include <nfsc/libnfs.h>
50
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053051
Peter Lieven29c838c2015-06-26 13:14:01 +020052#define QEMU_NFS_MAX_READAHEAD_SIZE 1048576
Peter Lievend99b26c2016-05-19 14:48:03 +020053#define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE)
Peter Lieven7725b8b2015-11-09 08:09:33 +010054#define QEMU_NFS_MAX_DEBUG_LEVEL 2
Peter Lieven29c838c2015-06-26 13:14:01 +020055
Peter Lieven6542aa92014-02-03 10:26:13 +010056typedef struct NFSClient {
57 struct nfs_context *context;
58 struct nfsfh *fh;
59 int events;
60 bool has_zero_init;
Stefan Hajnoczi471799d2014-05-08 16:34:44 +020061 AioContext *aio_context;
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +010062 QemuMutex mutex;
Yonggang Luoc63b0202020-11-05 20:31:15 +080063 uint64_t st_blocks;
Peter Lieven38f8d5e2016-05-19 14:48:02 +020064 bool cache_used;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053065 NFSServer *server;
66 char *path;
67 int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug;
Peter Lieven6542aa92014-02-03 10:26:13 +010068} NFSClient;
69
70typedef struct NFSRPC {
Paolo Bonzinid7464272016-10-27 12:48:57 +020071 BlockDriverState *bs;
Peter Lieven6542aa92014-02-03 10:26:13 +010072 int ret;
73 int complete;
74 QEMUIOVector *iov;
75 struct stat *st;
76 Coroutine *co;
Stefan Hajnoczi471799d2014-05-08 16:34:44 +020077 NFSClient *client;
Peter Lieven6542aa92014-02-03 10:26:13 +010078} NFSRPC;
79
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053080static 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 }
Max Reitzf69165a2017-06-13 22:57:26 +020091 if (g_strcmp0(uri->scheme, "nfs") != 0) {
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +053092 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
Eric Blake46f5ac22017-04-27 16:58:17 -0500112 qdict_put_str(options, "server.host", uri->server);
113 qdict_put_str(options, "server.type", "inet");
114 qdict_put_str(options, "path", uri->path);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530115
116 for (i = 0; i < qp->n; i++) {
Eric Blakebd1386c2023-05-22 14:04:29 -0500117 uint64_t val;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530118 if (!qp->p[i].value) {
119 error_setg(errp, "Value for NFS parameter expected: %s",
120 qp->p[i].name);
121 goto out;
122 }
Eric Blakebd1386c2023-05-22 14:04:29 -0500123 if (parse_uint_full(qp->p[i].value, 0, &val)) {
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530124 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")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500129 qdict_put_str(options, "user", qp->p[i].value);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530130 } else if (!strcmp(qp->p[i].name, "gid")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500131 qdict_put_str(options, "group", qp->p[i].value);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530132 } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500133 qdict_put_str(options, "tcp-syn-count", qp->p[i].value);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530134 } else if (!strcmp(qp->p[i].name, "readahead")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500135 qdict_put_str(options, "readahead-size", qp->p[i].value);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530136 } else if (!strcmp(qp->p[i].name, "pagecache")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500137 qdict_put_str(options, "page-cache-size", qp->p[i].value);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530138 } else if (!strcmp(qp->p[i].name, "debug")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500139 qdict_put_str(options, "debug", qp->p[i].value);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530140 } else {
141 error_setg(errp, "Unknown NFS parameter name: %s",
142 qp->p[i].name);
143 goto out;
144 }
145 }
146 ret = 0;
147out:
148 if (qp) {
149 query_params_free(qp);
150 }
Heinrich Schuchardtc2615bd2021-06-29 08:36:02 +0200151 uri_free(uri);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530152 return ret;
153}
154
155static 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") ||
Prasanna Kumar Kalever7103d912016-11-02 22:20:37 +0530167 !strcmp(qe->key, "debug") ||
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530168 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
179static 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
Peter Lieven6542aa92014-02-03 10:26:13 +0100189static void nfs_process_read(void *arg);
190static void nfs_process_write(void *arg);
191
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100192/* Called with QemuMutex held. */
Peter Lieven6542aa92014-02-03 10:26:13 +0100193static void nfs_set_events(NFSClient *client)
194{
195 int ev = nfs_which_events(client->context);
196 if (ev != client->events) {
Fam Zhengdca21ef2015-10-23 11:08:05 +0800197 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200198 (ev & POLLIN) ? nfs_process_read : NULL,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +0000199 (ev & POLLOUT) ? nfs_process_write : NULL,
Stefan Hajnoczi826cc322021-12-07 13:23:31 +0000200 NULL, NULL, client);
Peter Lieven6542aa92014-02-03 10:26:13 +0100201
202 }
203 client->events = ev;
204}
205
206static void nfs_process_read(void *arg)
207{
208 NFSClient *client = arg;
Paolo Bonzini9d456652017-02-13 14:52:30 +0100209
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100210 qemu_mutex_lock(&client->mutex);
Peter Lieven6542aa92014-02-03 10:26:13 +0100211 nfs_service(client->context, POLLIN);
212 nfs_set_events(client);
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100213 qemu_mutex_unlock(&client->mutex);
Peter Lieven6542aa92014-02-03 10:26:13 +0100214}
215
216static void nfs_process_write(void *arg)
217{
218 NFSClient *client = arg;
Paolo Bonzini9d456652017-02-13 14:52:30 +0100219
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100220 qemu_mutex_lock(&client->mutex);
Peter Lieven6542aa92014-02-03 10:26:13 +0100221 nfs_service(client->context, POLLOUT);
222 nfs_set_events(client);
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100223 qemu_mutex_unlock(&client->mutex);
Peter Lieven6542aa92014-02-03 10:26:13 +0100224}
225
Paolo Bonziniee15ee32022-09-22 10:49:09 +0200226static void coroutine_fn nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)
Peter Lieven6542aa92014-02-03 10:26:13 +0100227{
228 *task = (NFSRPC) {
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200229 .co = qemu_coroutine_self(),
Paolo Bonzinid7464272016-10-27 12:48:57 +0200230 .bs = bs,
231 .client = bs->opaque,
Peter Lieven6542aa92014-02-03 10:26:13 +0100232 };
233}
234
235static void nfs_co_generic_bh_cb(void *opaque)
236{
237 NFSRPC *task = opaque;
Paolo Bonzini19196312017-02-13 14:52:31 +0100238
Peter Lievena2c0fe22014-06-10 09:42:47 +0200239 task->complete = 1;
Paolo Bonzini19196312017-02-13 14:52:31 +0100240 aio_co_wake(task->co);
Peter Lieven6542aa92014-02-03 10:26:13 +0100241}
242
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100243/* Called (via nfs_service) with QemuMutex held. */
Peter Lieven6542aa92014-02-03 10:26:13 +0100244static void
245nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data,
246 void *private_data)
247{
248 NFSRPC *task = private_data;
Peter Lieven6542aa92014-02-03 10:26:13 +0100249 task->ret = ret;
Paolo Bonzinid7464272016-10-27 12:48:57 +0200250 assert(!task->st);
Peter Lieven6542aa92014-02-03 10:26:13 +0100251 if (task->ret > 0 && task->iov) {
252 if (task->ret <= task->iov->size) {
253 qemu_iovec_from_buf(task->iov, 0, data, task->ret);
254 } else {
255 task->ret = -EIO;
256 }
257 }
Peter Lieven20fccb12014-03-17 09:37:21 +0100258 if (task->ret < 0) {
259 error_report("NFS Error: %s", nfs_get_error(nfs));
260 }
Pavel Dovgalyuke4ec5ad2019-09-17 14:58:19 +0300261 replay_bh_schedule_oneshot_event(task->client->aio_context,
262 nfs_co_generic_bh_cb, task);
Peter Lieven6542aa92014-02-03 10:26:13 +0100263}
264
Vladimir Sementsov-Ogievskiyf7ef38d2021-09-03 13:27:59 +0300265static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, int64_t offset,
266 int64_t bytes, QEMUIOVector *iov,
267 BdrvRequestFlags flags)
Peter Lieven6542aa92014-02-03 10:26:13 +0100268{
269 NFSClient *client = bs->opaque;
270 NFSRPC task;
271
Paolo Bonzinid7464272016-10-27 12:48:57 +0200272 nfs_co_init_task(bs, &task);
Peter Lieven6542aa92014-02-03 10:26:13 +0100273 task.iov = iov;
274
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700275 WITH_QEMU_LOCK_GUARD(&client->mutex) {
276 if (nfs_pread_async(client->context, client->fh,
277 offset, bytes, nfs_co_generic_cb, &task) != 0) {
278 return -ENOMEM;
279 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100280
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700281 nfs_set_events(client);
282 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100283 while (!task.complete) {
Peter Lieven6542aa92014-02-03 10:26:13 +0100284 qemu_coroutine_yield();
285 }
286
287 if (task.ret < 0) {
288 return task.ret;
289 }
290
291 /* zero pad short reads */
292 if (task.ret < iov->size) {
293 qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret);
294 }
295
296 return 0;
297}
298
Vladimir Sementsov-Ogievskiye75abed2021-09-03 13:28:00 +0300299static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, int64_t offset,
300 int64_t bytes, QEMUIOVector *iov,
301 BdrvRequestFlags flags)
Peter Lieven6542aa92014-02-03 10:26:13 +0100302{
303 NFSClient *client = bs->opaque;
304 NFSRPC task;
305 char *buf = NULL;
Peter Lievenef503a82017-02-17 17:39:01 +0100306 bool my_buffer = false;
Peter Lieven6542aa92014-02-03 10:26:13 +0100307
Paolo Bonzinid7464272016-10-27 12:48:57 +0200308 nfs_co_init_task(bs, &task);
Peter Lieven6542aa92014-02-03 10:26:13 +0100309
Peter Lievenef503a82017-02-17 17:39:01 +0100310 if (iov->niov != 1) {
311 buf = g_try_malloc(bytes);
312 if (bytes && buf == NULL) {
313 return -ENOMEM;
314 }
315 qemu_iovec_to_buf(iov, 0, buf, bytes);
316 my_buffer = true;
317 } else {
318 buf = iov->iov[0].iov_base;
Kevin Wolf2347dd72014-05-20 13:31:20 +0200319 }
320
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700321 WITH_QEMU_LOCK_GUARD(&client->mutex) {
322 if (nfs_pwrite_async(client->context, client->fh,
323 offset, bytes, buf,
324 nfs_co_generic_cb, &task) != 0) {
325 if (my_buffer) {
326 g_free(buf);
327 }
328 return -ENOMEM;
Peter Lievenef503a82017-02-17 17:39:01 +0100329 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100330
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700331 nfs_set_events(client);
332 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100333 while (!task.complete) {
Peter Lieven6542aa92014-02-03 10:26:13 +0100334 qemu_coroutine_yield();
335 }
336
Peter Lievenef503a82017-02-17 17:39:01 +0100337 if (my_buffer) {
338 g_free(buf);
339 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100340
Peter Lieven69785a22017-02-17 17:39:00 +0100341 if (task.ret != bytes) {
Peter Lieven6542aa92014-02-03 10:26:13 +0100342 return task.ret < 0 ? task.ret : -EIO;
343 }
344
345 return 0;
346}
347
348static int coroutine_fn nfs_co_flush(BlockDriverState *bs)
349{
350 NFSClient *client = bs->opaque;
351 NFSRPC task;
352
Paolo Bonzinid7464272016-10-27 12:48:57 +0200353 nfs_co_init_task(bs, &task);
Peter Lieven6542aa92014-02-03 10:26:13 +0100354
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700355 WITH_QEMU_LOCK_GUARD(&client->mutex) {
356 if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb,
357 &task) != 0) {
358 return -ENOMEM;
359 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100360
Daniel Brodsky6e8a3552020-04-03 21:21:08 -0700361 nfs_set_events(client);
362 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100363 while (!task.complete) {
Peter Lieven6542aa92014-02-03 10:26:13 +0100364 qemu_coroutine_yield();
365 }
366
367 return task.ret;
368}
369
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200370static void nfs_detach_aio_context(BlockDriverState *bs)
371{
372 NFSClient *client = bs->opaque;
373
Fam Zhengdca21ef2015-10-23 11:08:05 +0800374 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
Stefan Hajnoczi60f782b2023-05-16 15:02:38 -0400375 NULL, NULL, NULL, NULL, NULL);
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200376 client->events = 0;
377}
378
379static void nfs_attach_aio_context(BlockDriverState *bs,
380 AioContext *new_context)
381{
382 NFSClient *client = bs->opaque;
383
384 client->aio_context = new_context;
385 nfs_set_events(client);
386}
387
Peter Lieven6542aa92014-02-03 10:26:13 +0100388static void nfs_client_close(NFSClient *client)
389{
390 if (client->context) {
Peter Lieven601dc652019-09-10 17:41:09 +0200391 qemu_mutex_lock(&client->mutex);
392 aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
Stefan Hajnoczi60f782b2023-05-16 15:02:38 -0400393 NULL, NULL, NULL, NULL, NULL);
Peter Lieven601dc652019-09-10 17:41:09 +0200394 qemu_mutex_unlock(&client->mutex);
Peter Lieven6542aa92014-02-03 10:26:13 +0100395 if (client->fh) {
396 nfs_close(client->context, client->fh);
Jeff Cody113fe792017-08-07 18:29:09 -0400397 client->fh = NULL;
Peter Lieven6542aa92014-02-03 10:26:13 +0100398 }
Peter Lievend2c6bec2019-09-10 17:41:10 +0200399#ifdef LIBNFS_FEATURE_UMOUNT
400 nfs_umount(client->context);
401#endif
Peter Lieven6542aa92014-02-03 10:26:13 +0100402 nfs_destroy_context(client->context);
Jeff Cody113fe792017-08-07 18:29:09 -0400403 client->context = NULL;
Peter Lieven6542aa92014-02-03 10:26:13 +0100404 }
Jeff Cody113fe792017-08-07 18:29:09 -0400405 g_free(client->path);
406 qemu_mutex_destroy(&client->mutex);
407 qapi_free_NFSServer(client->server);
408 client->server = NULL;
Peter Lieven6542aa92014-02-03 10:26:13 +0100409}
410
411static void nfs_file_close(BlockDriverState *bs)
412{
413 NFSClient *client = bs->opaque;
414 nfs_client_close(client);
415}
416
Kevin Wolfc22a0342018-01-31 19:47:48 +0100417static int64_t nfs_client_open(NFSClient *client, BlockdevOptionsNfs *opts,
Fam Zhengcb8d4bf2017-04-21 20:27:05 +0800418 int flags, int open_flags, Error **errp)
Peter Lieven6542aa92014-02-03 10:26:13 +0100419{
Peter Lievenf1a7ff72017-11-27 17:00:07 +0100420 int64_t ret = -EINVAL;
Bin Mengebdebe42022-09-08 21:28:15 +0800421#ifdef _WIN32
422 struct __stat64 st;
423#else
Peter Lieven6542aa92014-02-03 10:26:13 +0100424 struct stat st;
Bin Mengebdebe42022-09-08 21:28:15 +0800425#endif
Peter Lieven6542aa92014-02-03 10:26:13 +0100426 char *file = NULL, *strp = NULL;
427
Jeff Cody113fe792017-08-07 18:29:09 -0400428 qemu_mutex_init(&client->mutex);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530429
Kevin Wolfc22a0342018-01-31 19:47:48 +0100430 client->path = g_strdup(opts->path);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530431
432 strp = strrchr(client->path, '/');
Peter Lieven6542aa92014-02-03 10:26:13 +0100433 if (strp == NULL) {
434 error_setg(errp, "Invalid URL specified");
435 goto fail;
436 }
437 file = g_strdup(strp);
438 *strp = 0;
439
Kevin Wolfc22a0342018-01-31 19:47:48 +0100440 /* Steal the NFSServer object from opts; set the original pointer to NULL
441 * to avoid use after free and double free. */
442 client->server = opts->server;
443 opts->server = NULL;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530444
Peter Lieven6542aa92014-02-03 10:26:13 +0100445 client->context = nfs_init_context();
446 if (client->context == NULL) {
447 error_setg(errp, "Failed to init NFS context");
448 goto fail;
449 }
450
Kevin Wolfc22a0342018-01-31 19:47:48 +0100451 if (opts->has_user) {
452 client->uid = opts->user;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530453 nfs_set_uid(client->context, client->uid);
Peter Lieven6542aa92014-02-03 10:26:13 +0100454 }
455
Kevin Wolfc22a0342018-01-31 19:47:48 +0100456 if (opts->has_group) {
457 client->gid = opts->group;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530458 nfs_set_gid(client->context, client->gid);
459 }
460
Kevin Wolfc22a0342018-01-31 19:47:48 +0100461 if (opts->has_tcp_syn_count) {
462 client->tcp_syncnt = opts->tcp_syn_count;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530463 nfs_set_tcp_syncnt(client->context, client->tcp_syncnt);
464 }
465
466#ifdef LIBNFS_FEATURE_READAHEAD
Kevin Wolfc22a0342018-01-31 19:47:48 +0100467 if (opts->has_readahead_size) {
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530468 if (open_flags & BDRV_O_NOCACHE) {
469 error_setg(errp, "Cannot enable NFS readahead "
470 "if cache.direct = on");
471 goto fail;
472 }
Kevin Wolfc22a0342018-01-31 19:47:48 +0100473 client->readahead = opts->readahead_size;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530474 if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) {
Alistair Francis3dc6f862017-07-12 06:57:41 -0700475 warn_report("Truncating NFS readahead size to %d",
476 QEMU_NFS_MAX_READAHEAD_SIZE);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530477 client->readahead = QEMU_NFS_MAX_READAHEAD_SIZE;
478 }
479 nfs_set_readahead(client->context, client->readahead);
480#ifdef LIBNFS_FEATURE_PAGECACHE
481 nfs_set_pagecache_ttl(client->context, 0);
482#endif
483 client->cache_used = true;
484 }
485#endif
486
487#ifdef LIBNFS_FEATURE_PAGECACHE
Kevin Wolfc22a0342018-01-31 19:47:48 +0100488 if (opts->has_page_cache_size) {
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530489 if (open_flags & BDRV_O_NOCACHE) {
490 error_setg(errp, "Cannot enable NFS pagecache "
491 "if cache.direct = on");
492 goto fail;
493 }
Kevin Wolfc22a0342018-01-31 19:47:48 +0100494 client->pagecache = opts->page_cache_size;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530495 if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) {
Alistair Francis3dc6f862017-07-12 06:57:41 -0700496 warn_report("Truncating NFS pagecache size to %d pages",
497 QEMU_NFS_MAX_PAGECACHE_SIZE);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530498 client->pagecache = QEMU_NFS_MAX_PAGECACHE_SIZE;
499 }
500 nfs_set_pagecache(client->context, client->pagecache);
501 nfs_set_pagecache_ttl(client->context, 0);
502 client->cache_used = true;
503 }
504#endif
505
506#ifdef LIBNFS_FEATURE_DEBUG
Kevin Wolfc22a0342018-01-31 19:47:48 +0100507 if (opts->has_debug) {
508 client->debug = opts->debug;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530509 /* limit the maximum debug level to avoid potential flooding
510 * of our log files. */
511 if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) {
Alistair Francis3dc6f862017-07-12 06:57:41 -0700512 warn_report("Limiting NFS debug level to %d",
513 QEMU_NFS_MAX_DEBUG_LEVEL);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530514 client->debug = QEMU_NFS_MAX_DEBUG_LEVEL;
515 }
516 nfs_set_debug(client->context, client->debug);
517 }
518#endif
519
520 ret = nfs_mount(client->context, client->server->host, client->path);
Peter Lieven6542aa92014-02-03 10:26:13 +0100521 if (ret < 0) {
522 error_setg(errp, "Failed to mount nfs share: %s",
523 nfs_get_error(client->context));
524 goto fail;
525 }
526
527 if (flags & O_CREAT) {
528 ret = nfs_creat(client->context, file, 0600, &client->fh);
529 if (ret < 0) {
530 error_setg(errp, "Failed to create file: %s",
531 nfs_get_error(client->context));
532 goto fail;
533 }
534 } else {
535 ret = nfs_open(client->context, file, flags, &client->fh);
536 if (ret < 0) {
537 error_setg(errp, "Failed to open file : %s",
538 nfs_get_error(client->context));
539 goto fail;
540 }
541 }
542
543 ret = nfs_fstat(client->context, client->fh, &st);
544 if (ret < 0) {
545 error_setg(errp, "Failed to fstat file: %s",
546 nfs_get_error(client->context));
547 goto fail;
548 }
549
550 ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE);
Yonggang Luoc63b0202020-11-05 20:31:15 +0800551#if !defined(_WIN32)
Peter Lieven18a80562015-08-27 12:30:41 +0200552 client->st_blocks = st.st_blocks;
Yonggang Luoc63b0202020-11-05 20:31:15 +0800553#endif
Peter Lieven6542aa92014-02-03 10:26:13 +0100554 client->has_zero_init = S_ISREG(st.st_mode);
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530555 *strp = '/';
Peter Lieven6542aa92014-02-03 10:26:13 +0100556 goto out;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530557
Peter Lieven6542aa92014-02-03 10:26:13 +0100558fail:
559 nfs_client_close(client);
560out:
Peter Lieven6542aa92014-02-03 10:26:13 +0100561 g_free(file);
562 return ret;
563}
564
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100565static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
566 Error **errp)
Kevin Wolfc22a0342018-01-31 19:47:48 +0100567{
568 BlockdevOptionsNfs *opts = NULL;
Kevin Wolfc22a0342018-01-31 19:47:48 +0100569 Visitor *v;
Kevin Wolfc82be422018-05-16 18:08:16 +0200570 const QDictEntry *e;
Kevin Wolfc22a0342018-01-31 19:47:48 +0100571
Markus Armbrusteraf910622018-06-14 21:14:33 +0200572 v = qobject_input_visitor_new_flat_confused(options, errp);
573 if (!v) {
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100574 return NULL;
Kevin Wolfc22a0342018-01-31 19:47:48 +0100575 }
576
Markus Armbrusterb11a0932020-07-07 18:06:07 +0200577 visit_type_BlockdevOptionsNfs(v, NULL, &opts, errp);
Kevin Wolfc22a0342018-01-31 19:47:48 +0100578 visit_free(v);
Markus Armbrusterb11a0932020-07-07 18:06:07 +0200579 if (!opts) {
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100580 return NULL;
581 }
582
Kevin Wolfc82be422018-05-16 18:08:16 +0200583 /* Remove the processed options from the QDict (the visitor processes
584 * _all_ options in the QDict) */
585 while ((e = qdict_first(options))) {
586 qdict_del(options, e->key);
587 }
588
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100589 return opts;
590}
591
592static int64_t nfs_client_open_qdict(NFSClient *client, QDict *options,
593 int flags, int open_flags, Error **errp)
594{
595 BlockdevOptionsNfs *opts;
Peter Lieven182454d2020-12-09 13:17:35 +0100596 int64_t ret;
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100597
598 opts = nfs_options_qdict_to_qapi(options, errp);
599 if (opts == NULL) {
Kevin Wolfc22a0342018-01-31 19:47:48 +0100600 ret = -EINVAL;
601 goto fail;
602 }
603
604 ret = nfs_client_open(client, opts, flags, open_flags, errp);
605fail:
Kevin Wolfc22a0342018-01-31 19:47:48 +0100606 qapi_free_BlockdevOptionsNfs(opts);
607 return ret;
608}
609
Peter Lieven6542aa92014-02-03 10:26:13 +0100610static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
611 Error **errp) {
612 NFSClient *client = bs->opaque;
613 int64_t ret;
Peter Lieven6542aa92014-02-03 10:26:13 +0100614
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200615 client->aio_context = bdrv_get_aio_context(bs);
616
Kevin Wolfc22a0342018-01-31 19:47:48 +0100617 ret = nfs_client_open_qdict(client, options,
618 (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY,
619 bs->open_flags, errp);
Peter Lieven6542aa92014-02-03 10:26:13 +0100620 if (ret < 0) {
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530621 return ret;
Peter Lieven6542aa92014-02-03 10:26:13 +0100622 }
Jeff Cody113fe792017-08-07 18:29:09 -0400623
Peter Lieven6542aa92014-02-03 10:26:13 +0100624 bs->total_sectors = ret;
Eric Blake8f23aaf2020-04-28 15:28:59 -0500625 if (client->has_zero_init) {
626 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
627 }
Simran Singhalb3ac2b92020-04-01 22:23:14 +0530628 return 0;
Peter Lieven6542aa92014-02-03 10:26:13 +0100629}
630
Max Reitzfd752802014-12-02 18:32:44 +0100631static QemuOptsList nfs_create_opts = {
632 .name = "nfs-create-opts",
633 .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head),
634 .desc = {
635 {
636 .name = BLOCK_OPT_SIZE,
637 .type = QEMU_OPT_SIZE,
638 .help = "Virtual disk size"
639 },
640 { /* end of list */ }
641 }
642};
643
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100644static int nfs_file_co_create(BlockdevCreateOptions *options, Error **errp)
Peter Lieven6542aa92014-02-03 10:26:13 +0100645{
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100646 BlockdevCreateOptionsNfs *opts = &options->u.nfs;
Markus Armbruster5839e532014-08-19 10:31:08 +0200647 NFSClient *client = g_new0(NFSClient, 1);
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100648 int ret;
649
650 assert(options->driver == BLOCKDEV_DRIVER_NFS);
Peter Lieven6542aa92014-02-03 10:26:13 +0100651
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200652 client->aio_context = qemu_get_aio_context();
653
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100654 ret = nfs_client_open(client, opts->location, O_CREAT, 0, errp);
655 if (ret < 0) {
656 goto out;
657 }
658 ret = nfs_ftruncate(client->context, client->fh, opts->size);
659 nfs_client_close(client);
660
661out:
662 g_free(client);
663 return ret;
664}
665
Maxim Levitskyb92902d2020-03-26 03:12:17 +0200666static int coroutine_fn nfs_file_co_create_opts(BlockDriver *drv,
667 const char *url,
668 QemuOpts *opts,
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100669 Error **errp)
670{
671 BlockdevCreateOptions *create_options;
672 BlockdevCreateOptionsNfs *nfs_opts;
673 QDict *options;
674 int ret;
675
676 create_options = g_new0(BlockdevCreateOptions, 1);
677 create_options->driver = BLOCKDEV_DRIVER_NFS;
678 nfs_opts = &create_options->u.nfs;
679
Peter Lieven6542aa92014-02-03 10:26:13 +0100680 /* Read out options */
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100681 nfs_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
682 BDRV_SECTOR_SIZE);
Peter Lieven6542aa92014-02-03 10:26:13 +0100683
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530684 options = qdict_new();
685 ret = nfs_parse_uri(url, options, errp);
686 if (ret < 0) {
687 goto out;
688 }
689
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100690 nfs_opts->location = nfs_options_qdict_to_qapi(options, errp);
691 if (nfs_opts->location == NULL) {
692 ret = -EINVAL;
693 goto out;
694 }
695
696 ret = nfs_file_co_create(create_options, errp);
Peter Lieven6542aa92014-02-03 10:26:13 +0100697 if (ret < 0) {
698 goto out;
699 }
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100700
701 ret = 0;
Peter Lieven6542aa92014-02-03 10:26:13 +0100702out:
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200703 qobject_unref(options);
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100704 qapi_free_BlockdevCreateOptions(create_options);
Peter Lieven6542aa92014-02-03 10:26:13 +0100705 return ret;
706}
707
708static int nfs_has_zero_init(BlockDriverState *bs)
709{
710 NFSClient *client = bs->opaque;
711 return client->has_zero_init;
712}
713
Yonggang Luoc63b0202020-11-05 20:31:15 +0800714#if !defined(_WIN32)
Paolo Bonzini37d1e4d2017-02-22 19:07:24 +0100715/* Called (via nfs_service) with QemuMutex held. */
Paolo Bonzinid7464272016-10-27 12:48:57 +0200716static void
717nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data,
718 void *private_data)
719{
720 NFSRPC *task = private_data;
721 task->ret = ret;
722 if (task->ret == 0) {
723 memcpy(task->st, data, sizeof(struct stat));
724 }
725 if (task->ret < 0) {
726 error_report("NFS Error: %s", nfs_get_error(nfs));
727 }
Paolo Bonzini3fe64ab2023-04-12 13:26:06 +0200728 replay_bh_schedule_oneshot_event(task->client->aio_context,
729 nfs_co_generic_bh_cb, task);
Paolo Bonzinid7464272016-10-27 12:48:57 +0200730}
731
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +0100732static int64_t coroutine_fn nfs_co_get_allocated_file_size(BlockDriverState *bs)
Peter Lieven6542aa92014-02-03 10:26:13 +0100733{
734 NFSClient *client = bs->opaque;
735 NFSRPC task = {0};
736 struct stat st;
737
Peter Lieven18a80562015-08-27 12:30:41 +0200738 if (bdrv_is_read_only(bs) &&
739 !(bs->open_flags & BDRV_O_NOCACHE)) {
740 return client->st_blocks * 512;
741 }
742
Paolo Bonzini3fe64ab2023-04-12 13:26:06 +0200743 nfs_co_init_task(bs, &task);
Peter Lieven6542aa92014-02-03 10:26:13 +0100744 task.st = &st;
Paolo Bonzini3fe64ab2023-04-12 13:26:06 +0200745 WITH_QEMU_LOCK_GUARD(&client->mutex) {
746 if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_file_size_cb,
747 &task) != 0) {
748 return -ENOMEM;
749 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100750
Paolo Bonzini3fe64ab2023-04-12 13:26:06 +0200751 nfs_set_events(client);
752 }
753 while (!task.complete) {
754 qemu_coroutine_yield();
755 }
Peter Lieven6542aa92014-02-03 10:26:13 +0100756
Peter Lieven055c6f92015-08-20 12:46:47 +0200757 return (task.ret < 0 ? task.ret : st.st_blocks * 512);
Peter Lieven6542aa92014-02-03 10:26:13 +0100758}
Yonggang Luoc63b0202020-11-05 20:31:15 +0800759#endif
Peter Lieven6542aa92014-02-03 10:26:13 +0100760
Kevin Wolf061ca8a2018-06-21 17:54:35 +0200761static int coroutine_fn
Max Reitzc80d8b02019-09-18 11:51:40 +0200762nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
Kevin Wolf92b92792020-04-24 14:54:39 +0200763 PreallocMode prealloc, BdrvRequestFlags flags,
764 Error **errp)
Peter Lieven6542aa92014-02-03 10:26:13 +0100765{
766 NFSClient *client = bs->opaque;
Max Reitzf59adb32017-03-28 22:51:29 +0200767 int ret;
768
Max Reitz8243ccb2017-06-13 22:20:52 +0200769 if (prealloc != PREALLOC_MODE_OFF) {
770 error_setg(errp, "Unsupported preallocation mode '%s'",
Markus Armbruster977c7362017-08-24 10:46:08 +0200771 PreallocMode_str(prealloc));
Max Reitz8243ccb2017-06-13 22:20:52 +0200772 return -ENOTSUP;
773 }
774
Max Reitzf59adb32017-03-28 22:51:29 +0200775 ret = nfs_ftruncate(client->context, client->fh, offset);
776 if (ret < 0) {
777 error_setg_errno(errp, -ret, "Failed to truncate file");
778 return ret;
779 }
780
781 return 0;
Peter Lieven6542aa92014-02-03 10:26:13 +0100782}
783
Peter Lieven18a80562015-08-27 12:30:41 +0200784/* Note that this will not re-establish a connection with the NFS server
785 * - it is effectively a NOP. */
786static int nfs_reopen_prepare(BDRVReopenState *state,
787 BlockReopenQueue *queue, Error **errp)
788{
789 NFSClient *client = state->bs->opaque;
Bin Mengebdebe42022-09-08 21:28:15 +0800790#ifdef _WIN32
791 struct __stat64 st;
792#else
Peter Lieven18a80562015-08-27 12:30:41 +0200793 struct stat st;
Bin Mengebdebe42022-09-08 21:28:15 +0800794#endif
Peter Lieven18a80562015-08-27 12:30:41 +0200795 int ret = 0;
796
797 if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) {
798 error_setg(errp, "Cannot open a read-only mount as read-write");
799 return -EACCES;
800 }
801
Peter Lieven38f8d5e2016-05-19 14:48:02 +0200802 if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) {
Peter Lievend99b26c2016-05-19 14:48:03 +0200803 error_setg(errp, "Cannot disable cache if libnfs readahead or"
804 " pagecache is enabled");
Peter Lieven38f8d5e2016-05-19 14:48:02 +0200805 return -EINVAL;
806 }
807
Peter Lieven18a80562015-08-27 12:30:41 +0200808 /* Update cache for read-only reopens */
809 if (!(state->flags & BDRV_O_RDWR)) {
810 ret = nfs_fstat(client->context, client->fh, &st);
811 if (ret < 0) {
812 error_setg(errp, "Failed to fstat file: %s",
813 nfs_get_error(client->context));
814 return ret;
815 }
Yonggang Luoc63b0202020-11-05 20:31:15 +0800816#if !defined(_WIN32)
Peter Lieven18a80562015-08-27 12:30:41 +0200817 client->st_blocks = st.st_blocks;
Yonggang Luoc63b0202020-11-05 20:31:15 +0800818#endif
Peter Lieven18a80562015-08-27 12:30:41 +0200819 }
820
821 return 0;
822}
823
Max Reitz998b3a12019-02-01 20:29:28 +0100824static void nfs_refresh_filename(BlockDriverState *bs)
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530825{
826 NFSClient *client = bs->opaque;
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530827
828 if (client->uid && !client->gid) {
829 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
830 "nfs://%s%s?uid=%" PRId64, client->server->host, client->path,
831 client->uid);
832 } else if (!client->uid && client->gid) {
833 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
834 "nfs://%s%s?gid=%" PRId64, client->server->host, client->path,
835 client->gid);
836 } else if (client->uid && client->gid) {
837 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
838 "nfs://%s%s?uid=%" PRId64 "&gid=%" PRId64,
839 client->server->host, client->path, client->uid, client->gid);
840 } else {
841 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
842 "nfs://%s%s", client->server->host, client->path);
843 }
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530844}
845
Max Reitz0dcbc542019-02-01 20:29:22 +0100846static char *nfs_dirname(BlockDriverState *bs, Error **errp)
847{
848 NFSClient *client = bs->opaque;
849
850 if (client->uid || client->gid) {
851 bdrv_refresh_filename(bs);
852 error_setg(errp, "Cannot generate a base directory for NFS node '%s'",
853 bs->filename);
854 return NULL;
855 }
856
857 return g_strdup_printf("nfs://%s%s/", client->server->host, client->path);
858}
859
Peter Lievend99b26c2016-05-19 14:48:03 +0200860#ifdef LIBNFS_FEATURE_PAGECACHE
Paolo Bonzini2b148f32018-03-01 17:36:18 +0100861static void coroutine_fn nfs_co_invalidate_cache(BlockDriverState *bs,
862 Error **errp)
Peter Lievend99b26c2016-05-19 14:48:03 +0200863{
864 NFSClient *client = bs->opaque;
865 nfs_pagecache_invalidate(client->context, client->fh);
866}
867#endif
868
Max Reitz26542672019-02-01 20:29:25 +0100869static const char *nfs_strong_runtime_opts[] = {
870 "path",
871 "user",
872 "group",
873 "server.",
874
875 NULL
876};
877
Peter Lieven6542aa92014-02-03 10:26:13 +0100878static BlockDriver bdrv_nfs = {
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200879 .format_name = "nfs",
880 .protocol_name = "nfs",
Peter Lieven6542aa92014-02-03 10:26:13 +0100881
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200882 .instance_size = sizeof(NFSClient),
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530883 .bdrv_parse_filename = nfs_parse_filename,
Max Reitzfd752802014-12-02 18:32:44 +0100884 .create_opts = &nfs_create_opts,
885
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200886 .bdrv_has_zero_init = nfs_has_zero_init,
Yonggang Luoc63b0202020-11-05 20:31:15 +0800887/* libnfs does not provide the allocated filesize of a file on win32. */
888#if !defined(_WIN32)
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +0100889 .bdrv_co_get_allocated_file_size = nfs_co_get_allocated_file_size,
Yonggang Luoc63b0202020-11-05 20:31:15 +0800890#endif
Kevin Wolf061ca8a2018-06-21 17:54:35 +0200891 .bdrv_co_truncate = nfs_file_co_truncate,
Peter Lieven6542aa92014-02-03 10:26:13 +0100892
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200893 .bdrv_file_open = nfs_file_open,
894 .bdrv_close = nfs_file_close,
Kevin Wolfa1a42af2018-01-31 16:27:38 +0100895 .bdrv_co_create = nfs_file_co_create,
Stefan Hajnocziefc75e22018-01-18 13:43:45 +0100896 .bdrv_co_create_opts = nfs_file_co_create_opts,
Peter Lieven18a80562015-08-27 12:30:41 +0200897 .bdrv_reopen_prepare = nfs_reopen_prepare,
Peter Lieven6542aa92014-02-03 10:26:13 +0100898
Peter Lieven69785a22017-02-17 17:39:00 +0100899 .bdrv_co_preadv = nfs_co_preadv,
900 .bdrv_co_pwritev = nfs_co_pwritev,
Stefan Hajnoczi471799d2014-05-08 16:34:44 +0200901 .bdrv_co_flush_to_disk = nfs_co_flush,
902
903 .bdrv_detach_aio_context = nfs_detach_aio_context,
904 .bdrv_attach_aio_context = nfs_attach_aio_context,
Ashijeet Acharya94d6a7a2016-10-31 20:35:49 +0530905 .bdrv_refresh_filename = nfs_refresh_filename,
Max Reitz0dcbc542019-02-01 20:29:22 +0100906 .bdrv_dirname = nfs_dirname,
Peter Lievend99b26c2016-05-19 14:48:03 +0200907
Max Reitz26542672019-02-01 20:29:25 +0100908 .strong_runtime_opts = nfs_strong_runtime_opts,
909
Peter Lievend99b26c2016-05-19 14:48:03 +0200910#ifdef LIBNFS_FEATURE_PAGECACHE
Paolo Bonzini2b148f32018-03-01 17:36:18 +0100911 .bdrv_co_invalidate_cache = nfs_co_invalidate_cache,
Peter Lievend99b26c2016-05-19 14:48:03 +0200912#endif
Peter Lieven6542aa92014-02-03 10:26:13 +0100913};
914
915static void nfs_block_init(void)
916{
917 bdrv_register(&bdrv_nfs);
918}
919
920block_init(nfs_block_init);