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