spapr: Workaround for broken radix guests
[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 /*
478 * Caution: this works only because all scalar members of
479 * NFSServer are QString in @crumpled_addr. The visitor expects
480 * @crumpled_addr to be typed according to the QAPI schema. It
481 * is when @options come from -blockdev or blockdev_add. But when
482 * they come from -drive, they're all QString.
483 */
484 iv = qobject_input_visitor_new(crumpled_addr);
485 visit_type_NFSServer(iv, NULL, &server, &local_error);
486 if (local_error) {
487 error_propagate(errp, local_error);
488 goto out;
489 }
490
491 out:
492 QDECREF(addr);
493 qobject_decref(crumpled_addr);
494 visit_free(iv);
495 return server;
496 }
497
498
499 static int64_t nfs_client_open(NFSClient *client, QDict *options,
500 int flags, int open_flags, Error **errp)
501 {
502 int ret = -EINVAL;
503 QemuOpts *opts = NULL;
504 Error *local_err = NULL;
505 struct stat st;
506 char *file = NULL, *strp = NULL;
507
508 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
509 qemu_opts_absorb_qdict(opts, options, &local_err);
510 if (local_err) {
511 error_propagate(errp, local_err);
512 ret = -EINVAL;
513 goto fail;
514 }
515
516 client->path = g_strdup(qemu_opt_get(opts, "path"));
517 if (!client->path) {
518 ret = -EINVAL;
519 error_setg(errp, "No path was specified");
520 goto fail;
521 }
522
523 strp = strrchr(client->path, '/');
524 if (strp == NULL) {
525 error_setg(errp, "Invalid URL specified");
526 goto fail;
527 }
528 file = g_strdup(strp);
529 *strp = 0;
530
531 /* Pop the config into our state object, Exit if invalid */
532 client->server = nfs_config(options, errp);
533 if (!client->server) {
534 ret = -EINVAL;
535 goto fail;
536 }
537
538 client->context = nfs_init_context();
539 if (client->context == NULL) {
540 error_setg(errp, "Failed to init NFS context");
541 goto fail;
542 }
543
544 if (qemu_opt_get(opts, "user")) {
545 client->uid = qemu_opt_get_number(opts, "user", 0);
546 nfs_set_uid(client->context, client->uid);
547 }
548
549 if (qemu_opt_get(opts, "group")) {
550 client->gid = qemu_opt_get_number(opts, "group", 0);
551 nfs_set_gid(client->context, client->gid);
552 }
553
554 if (qemu_opt_get(opts, "tcp-syn-count")) {
555 client->tcp_syncnt = qemu_opt_get_number(opts, "tcp-syn-count", 0);
556 nfs_set_tcp_syncnt(client->context, client->tcp_syncnt);
557 }
558
559 #ifdef LIBNFS_FEATURE_READAHEAD
560 if (qemu_opt_get(opts, "readahead-size")) {
561 if (open_flags & BDRV_O_NOCACHE) {
562 error_setg(errp, "Cannot enable NFS readahead "
563 "if cache.direct = on");
564 goto fail;
565 }
566 client->readahead = qemu_opt_get_number(opts, "readahead-size", 0);
567 if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) {
568 error_report("NFS Warning: Truncating NFS readahead "
569 "size to %d", QEMU_NFS_MAX_READAHEAD_SIZE);
570 client->readahead = QEMU_NFS_MAX_READAHEAD_SIZE;
571 }
572 nfs_set_readahead(client->context, client->readahead);
573 #ifdef LIBNFS_FEATURE_PAGECACHE
574 nfs_set_pagecache_ttl(client->context, 0);
575 #endif
576 client->cache_used = true;
577 }
578 #endif
579
580 #ifdef LIBNFS_FEATURE_PAGECACHE
581 if (qemu_opt_get(opts, "page-cache-size")) {
582 if (open_flags & BDRV_O_NOCACHE) {
583 error_setg(errp, "Cannot enable NFS pagecache "
584 "if cache.direct = on");
585 goto fail;
586 }
587 client->pagecache = qemu_opt_get_number(opts, "page-cache-size", 0);
588 if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) {
589 error_report("NFS Warning: Truncating NFS pagecache "
590 "size to %d pages", QEMU_NFS_MAX_PAGECACHE_SIZE);
591 client->pagecache = QEMU_NFS_MAX_PAGECACHE_SIZE;
592 }
593 nfs_set_pagecache(client->context, client->pagecache);
594 nfs_set_pagecache_ttl(client->context, 0);
595 client->cache_used = true;
596 }
597 #endif
598
599 #ifdef LIBNFS_FEATURE_DEBUG
600 if (qemu_opt_get(opts, "debug")) {
601 client->debug = qemu_opt_get_number(opts, "debug", 0);
602 /* limit the maximum debug level to avoid potential flooding
603 * of our log files. */
604 if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) {
605 error_report("NFS Warning: Limiting NFS debug level "
606 "to %d", QEMU_NFS_MAX_DEBUG_LEVEL);
607 client->debug = QEMU_NFS_MAX_DEBUG_LEVEL;
608 }
609 nfs_set_debug(client->context, client->debug);
610 }
611 #endif
612
613 ret = nfs_mount(client->context, client->server->host, client->path);
614 if (ret < 0) {
615 error_setg(errp, "Failed to mount nfs share: %s",
616 nfs_get_error(client->context));
617 goto fail;
618 }
619
620 if (flags & O_CREAT) {
621 ret = nfs_creat(client->context, file, 0600, &client->fh);
622 if (ret < 0) {
623 error_setg(errp, "Failed to create file: %s",
624 nfs_get_error(client->context));
625 goto fail;
626 }
627 } else {
628 ret = nfs_open(client->context, file, flags, &client->fh);
629 if (ret < 0) {
630 error_setg(errp, "Failed to open file : %s",
631 nfs_get_error(client->context));
632 goto fail;
633 }
634 }
635
636 ret = nfs_fstat(client->context, client->fh, &st);
637 if (ret < 0) {
638 error_setg(errp, "Failed to fstat file: %s",
639 nfs_get_error(client->context));
640 goto fail;
641 }
642
643 ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE);
644 client->st_blocks = st.st_blocks;
645 client->has_zero_init = S_ISREG(st.st_mode);
646 *strp = '/';
647 goto out;
648
649 fail:
650 nfs_client_close(client);
651 out:
652 qemu_opts_del(opts);
653 g_free(file);
654 return ret;
655 }
656
657 static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
658 Error **errp) {
659 NFSClient *client = bs->opaque;
660 int64_t ret;
661
662 client->aio_context = bdrv_get_aio_context(bs);
663
664 ret = nfs_client_open(client, options,
665 (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY,
666 bs->open_flags, errp);
667 if (ret < 0) {
668 return ret;
669 }
670 qemu_mutex_init(&client->mutex);
671 bs->total_sectors = ret;
672 ret = 0;
673 return ret;
674 }
675
676 static QemuOptsList nfs_create_opts = {
677 .name = "nfs-create-opts",
678 .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head),
679 .desc = {
680 {
681 .name = BLOCK_OPT_SIZE,
682 .type = QEMU_OPT_SIZE,
683 .help = "Virtual disk size"
684 },
685 { /* end of list */ }
686 }
687 };
688
689 static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp)
690 {
691 int ret = 0;
692 int64_t total_size = 0;
693 NFSClient *client = g_new0(NFSClient, 1);
694 QDict *options = NULL;
695
696 client->aio_context = qemu_get_aio_context();
697
698 /* Read out options */
699 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
700 BDRV_SECTOR_SIZE);
701
702 options = qdict_new();
703 ret = nfs_parse_uri(url, options, errp);
704 if (ret < 0) {
705 goto out;
706 }
707
708 ret = nfs_client_open(client, options, O_CREAT, 0, errp);
709 if (ret < 0) {
710 goto out;
711 }
712 ret = nfs_ftruncate(client->context, client->fh, total_size);
713 nfs_client_close(client);
714 out:
715 QDECREF(options);
716 g_free(client);
717 return ret;
718 }
719
720 static int nfs_has_zero_init(BlockDriverState *bs)
721 {
722 NFSClient *client = bs->opaque;
723 return client->has_zero_init;
724 }
725
726 /* Called (via nfs_service) with QemuMutex held. */
727 static void
728 nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data,
729 void *private_data)
730 {
731 NFSRPC *task = private_data;
732 task->ret = ret;
733 if (task->ret == 0) {
734 memcpy(task->st, data, sizeof(struct stat));
735 }
736 if (task->ret < 0) {
737 error_report("NFS Error: %s", nfs_get_error(nfs));
738 }
739 task->complete = 1;
740 bdrv_wakeup(task->bs);
741 }
742
743 static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
744 {
745 NFSClient *client = bs->opaque;
746 NFSRPC task = {0};
747 struct stat st;
748
749 if (bdrv_is_read_only(bs) &&
750 !(bs->open_flags & BDRV_O_NOCACHE)) {
751 return client->st_blocks * 512;
752 }
753
754 task.bs = bs;
755 task.st = &st;
756 if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_file_size_cb,
757 &task) != 0) {
758 return -ENOMEM;
759 }
760
761 nfs_set_events(client);
762 BDRV_POLL_WHILE(bs, !task.complete);
763
764 return (task.ret < 0 ? task.ret : st.st_blocks * 512);
765 }
766
767 static int nfs_file_truncate(BlockDriverState *bs, int64_t offset)
768 {
769 NFSClient *client = bs->opaque;
770 return nfs_ftruncate(client->context, client->fh, offset);
771 }
772
773 /* Note that this will not re-establish a connection with the NFS server
774 * - it is effectively a NOP. */
775 static int nfs_reopen_prepare(BDRVReopenState *state,
776 BlockReopenQueue *queue, Error **errp)
777 {
778 NFSClient *client = state->bs->opaque;
779 struct stat st;
780 int ret = 0;
781
782 if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) {
783 error_setg(errp, "Cannot open a read-only mount as read-write");
784 return -EACCES;
785 }
786
787 if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) {
788 error_setg(errp, "Cannot disable cache if libnfs readahead or"
789 " pagecache is enabled");
790 return -EINVAL;
791 }
792
793 /* Update cache for read-only reopens */
794 if (!(state->flags & BDRV_O_RDWR)) {
795 ret = nfs_fstat(client->context, client->fh, &st);
796 if (ret < 0) {
797 error_setg(errp, "Failed to fstat file: %s",
798 nfs_get_error(client->context));
799 return ret;
800 }
801 client->st_blocks = st.st_blocks;
802 }
803
804 return 0;
805 }
806
807 static void nfs_refresh_filename(BlockDriverState *bs, QDict *options)
808 {
809 NFSClient *client = bs->opaque;
810 QDict *opts = qdict_new();
811 QObject *server_qdict;
812 Visitor *ov;
813
814 qdict_put(opts, "driver", qstring_from_str("nfs"));
815
816 if (client->uid && !client->gid) {
817 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
818 "nfs://%s%s?uid=%" PRId64, client->server->host, client->path,
819 client->uid);
820 } else if (!client->uid && client->gid) {
821 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
822 "nfs://%s%s?gid=%" PRId64, client->server->host, client->path,
823 client->gid);
824 } else if (client->uid && client->gid) {
825 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
826 "nfs://%s%s?uid=%" PRId64 "&gid=%" PRId64,
827 client->server->host, client->path, client->uid, client->gid);
828 } else {
829 snprintf(bs->exact_filename, sizeof(bs->exact_filename),
830 "nfs://%s%s", client->server->host, client->path);
831 }
832
833 ov = qobject_output_visitor_new(&server_qdict);
834 visit_type_NFSServer(ov, NULL, &client->server, &error_abort);
835 visit_complete(ov, &server_qdict);
836 qdict_put_obj(opts, "server", server_qdict);
837 qdict_put(opts, "path", qstring_from_str(client->path));
838
839 if (client->uid) {
840 qdict_put(opts, "user", qint_from_int(client->uid));
841 }
842 if (client->gid) {
843 qdict_put(opts, "group", qint_from_int(client->gid));
844 }
845 if (client->tcp_syncnt) {
846 qdict_put(opts, "tcp-syn-cnt",
847 qint_from_int(client->tcp_syncnt));
848 }
849 if (client->readahead) {
850 qdict_put(opts, "readahead-size",
851 qint_from_int(client->readahead));
852 }
853 if (client->pagecache) {
854 qdict_put(opts, "page-cache-size",
855 qint_from_int(client->pagecache));
856 }
857 if (client->debug) {
858 qdict_put(opts, "debug", qint_from_int(client->debug));
859 }
860
861 visit_free(ov);
862 qdict_flatten(opts);
863 bs->full_open_options = opts;
864 }
865
866 #ifdef LIBNFS_FEATURE_PAGECACHE
867 static void nfs_invalidate_cache(BlockDriverState *bs,
868 Error **errp)
869 {
870 NFSClient *client = bs->opaque;
871 nfs_pagecache_invalidate(client->context, client->fh);
872 }
873 #endif
874
875 static BlockDriver bdrv_nfs = {
876 .format_name = "nfs",
877 .protocol_name = "nfs",
878
879 .instance_size = sizeof(NFSClient),
880 .bdrv_parse_filename = nfs_parse_filename,
881 .create_opts = &nfs_create_opts,
882
883 .bdrv_has_zero_init = nfs_has_zero_init,
884 .bdrv_get_allocated_file_size = nfs_get_allocated_file_size,
885 .bdrv_truncate = nfs_file_truncate,
886
887 .bdrv_file_open = nfs_file_open,
888 .bdrv_close = nfs_file_close,
889 .bdrv_create = nfs_file_create,
890 .bdrv_reopen_prepare = nfs_reopen_prepare,
891
892 .bdrv_co_preadv = nfs_co_preadv,
893 .bdrv_co_pwritev = nfs_co_pwritev,
894 .bdrv_co_flush_to_disk = nfs_co_flush,
895
896 .bdrv_detach_aio_context = nfs_detach_aio_context,
897 .bdrv_attach_aio_context = nfs_attach_aio_context,
898 .bdrv_refresh_filename = nfs_refresh_filename,
899
900 #ifdef LIBNFS_FEATURE_PAGECACHE
901 .bdrv_invalidate_cache = nfs_invalidate_cache,
902 #endif
903 };
904
905 static void nfs_block_init(void)
906 {
907 bdrv_register(&bdrv_nfs);
908 }
909
910 block_init(nfs_block_init);