xref: /openbmc/qemu/block/nfs.c (revision 1141159c)
1 /*
2  * QEMU Block driver for native access to files on NFS shares
3  *
4  * Copyright (c) 2014-2017 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 #if !defined(_WIN32)
28 #include <poll.h>
29 #endif
30 #include "qemu/config-file.h"
31 #include "qemu/error-report.h"
32 #include "qapi/error.h"
33 #include "block/block-io.h"
34 #include "block/block_int.h"
35 #include "block/qdict.h"
36 #include "trace.h"
37 #include "qemu/iov.h"
38 #include "qemu/main-loop.h"
39 #include "qemu/module.h"
40 #include "qemu/option.h"
41 #include "qemu/uri.h"
42 #include "qemu/cutils.h"
43 #include "sysemu/replay.h"
44 #include "qapi/qapi-visit-block-core.h"
45 #include "qapi/qmp/qdict.h"
46 #include "qapi/qmp/qstring.h"
47 #include "qapi/qobject-input-visitor.h"
48 #include "qapi/qobject-output-visitor.h"
49 #include <nfsc/libnfs.h>
50 
51 
52 #define QEMU_NFS_MAX_READAHEAD_SIZE 1048576
53 #define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE)
54 #define QEMU_NFS_MAX_DEBUG_LEVEL 2
55 
56 typedef struct NFSClient {
57     struct nfs_context *context;
58     struct nfsfh *fh;
59     int events;
60     bool has_zero_init;
61     AioContext *aio_context;
62     QemuMutex mutex;
63     uint64_t st_blocks;
64     bool cache_used;
65     NFSServer *server;
66     char *path;
67     int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug;
68 } NFSClient;
69 
70 typedef struct NFSRPC {
71     BlockDriverState *bs;
72     int ret;
73     int complete;
74     QEMUIOVector *iov;
75     struct stat *st;
76     Coroutine *co;
77     NFSClient *client;
78 } NFSRPC;
79 
80 static 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     }
91     if (g_strcmp0(uri->scheme, "nfs") != 0) {
92         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 
112     qdict_put_str(options, "server.host", uri->server);
113     qdict_put_str(options, "server.type", "inet");
114     qdict_put_str(options, "path", uri->path);
115 
116     for (i = 0; i < qp->n; i++) {
117         unsigned long long val;
118         if (!qp->p[i].value) {
119             error_setg(errp, "Value for NFS parameter expected: %s",
120                        qp->p[i].name);
121             goto out;
122         }
123         if (parse_uint_full(qp->p[i].value, &val, 0)) {
124             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")) {
129             qdict_put_str(options, "user", qp->p[i].value);
130         } else if (!strcmp(qp->p[i].name, "gid")) {
131             qdict_put_str(options, "group", qp->p[i].value);
132         } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) {
133             qdict_put_str(options, "tcp-syn-count", qp->p[i].value);
134         } else if (!strcmp(qp->p[i].name, "readahead")) {
135             qdict_put_str(options, "readahead-size", qp->p[i].value);
136         } else if (!strcmp(qp->p[i].name, "pagecache")) {
137             qdict_put_str(options, "page-cache-size", qp->p[i].value);
138         } else if (!strcmp(qp->p[i].name, "debug")) {
139             qdict_put_str(options, "debug", qp->p[i].value);
140         } else {
141             error_setg(errp, "Unknown NFS parameter name: %s",
142                        qp->p[i].name);
143             goto out;
144         }
145     }
146     ret = 0;
147 out:
148     if (qp) {
149         query_params_free(qp);
150     }
151     uri_free(uri);
152     return ret;
153 }
154 
155 static 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") ||
167             !strcmp(qe->key, "debug") ||
168             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 
179 static 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 
189 static void nfs_process_read(void *arg);
190 static void nfs_process_write(void *arg);
191 
192 /* Called with QemuMutex held.  */
193 static void nfs_set_events(NFSClient *client)
194 {
195     int ev = nfs_which_events(client->context);
196     if (ev != client->events) {
197         aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
198                            false,
199                            (ev & POLLIN) ? nfs_process_read : NULL,
200                            (ev & POLLOUT) ? nfs_process_write : NULL,
201                            NULL, NULL, client);
202 
203     }
204     client->events = ev;
205 }
206 
207 static void nfs_process_read(void *arg)
208 {
209     NFSClient *client = arg;
210 
211     qemu_mutex_lock(&client->mutex);
212     nfs_service(client->context, POLLIN);
213     nfs_set_events(client);
214     qemu_mutex_unlock(&client->mutex);
215 }
216 
217 static void nfs_process_write(void *arg)
218 {
219     NFSClient *client = arg;
220 
221     qemu_mutex_lock(&client->mutex);
222     nfs_service(client->context, POLLOUT);
223     nfs_set_events(client);
224     qemu_mutex_unlock(&client->mutex);
225 }
226 
227 static void coroutine_fn nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)
228 {
229     *task = (NFSRPC) {
230         .co             = qemu_coroutine_self(),
231         .bs             = bs,
232         .client         = bs->opaque,
233     };
234 }
235 
236 static void nfs_co_generic_bh_cb(void *opaque)
237 {
238     NFSRPC *task = opaque;
239 
240     task->complete = 1;
241     aio_co_wake(task->co);
242 }
243 
244 /* Called (via nfs_service) with QemuMutex held.  */
245 static void
246 nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data,
247                   void *private_data)
248 {
249     NFSRPC *task = private_data;
250     task->ret = ret;
251     assert(!task->st);
252     if (task->ret > 0 && task->iov) {
253         if (task->ret <= task->iov->size) {
254             qemu_iovec_from_buf(task->iov, 0, data, task->ret);
255         } else {
256             task->ret = -EIO;
257         }
258     }
259     if (task->ret < 0) {
260         error_report("NFS Error: %s", nfs_get_error(nfs));
261     }
262     replay_bh_schedule_oneshot_event(task->client->aio_context,
263                                      nfs_co_generic_bh_cb, task);
264 }
265 
266 static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, int64_t offset,
267                                       int64_t bytes, QEMUIOVector *iov,
268                                       BdrvRequestFlags flags)
269 {
270     NFSClient *client = bs->opaque;
271     NFSRPC task;
272 
273     nfs_co_init_task(bs, &task);
274     task.iov = iov;
275 
276     WITH_QEMU_LOCK_GUARD(&client->mutex) {
277         if (nfs_pread_async(client->context, client->fh,
278                             offset, bytes, nfs_co_generic_cb, &task) != 0) {
279             return -ENOMEM;
280         }
281 
282         nfs_set_events(client);
283     }
284     while (!task.complete) {
285         qemu_coroutine_yield();
286     }
287 
288     if (task.ret < 0) {
289         return task.ret;
290     }
291 
292     /* zero pad short reads */
293     if (task.ret < iov->size) {
294         qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret);
295     }
296 
297     return 0;
298 }
299 
300 static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, int64_t offset,
301                                        int64_t bytes, QEMUIOVector *iov,
302                                        BdrvRequestFlags flags)
303 {
304     NFSClient *client = bs->opaque;
305     NFSRPC task;
306     char *buf = NULL;
307     bool my_buffer = false;
308 
309     nfs_co_init_task(bs, &task);
310 
311     if (iov->niov != 1) {
312         buf = g_try_malloc(bytes);
313         if (bytes && buf == NULL) {
314             return -ENOMEM;
315         }
316         qemu_iovec_to_buf(iov, 0, buf, bytes);
317         my_buffer = true;
318     } else {
319         buf = iov->iov[0].iov_base;
320     }
321 
322     WITH_QEMU_LOCK_GUARD(&client->mutex) {
323         if (nfs_pwrite_async(client->context, client->fh,
324                              offset, bytes, buf,
325                              nfs_co_generic_cb, &task) != 0) {
326             if (my_buffer) {
327                 g_free(buf);
328             }
329             return -ENOMEM;
330         }
331 
332         nfs_set_events(client);
333     }
334     while (!task.complete) {
335         qemu_coroutine_yield();
336     }
337 
338     if (my_buffer) {
339         g_free(buf);
340     }
341 
342     if (task.ret != bytes) {
343         return task.ret < 0 ? task.ret : -EIO;
344     }
345 
346     return 0;
347 }
348 
349 static int coroutine_fn nfs_co_flush(BlockDriverState *bs)
350 {
351     NFSClient *client = bs->opaque;
352     NFSRPC task;
353 
354     nfs_co_init_task(bs, &task);
355 
356     WITH_QEMU_LOCK_GUARD(&client->mutex) {
357         if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb,
358                             &task) != 0) {
359             return -ENOMEM;
360         }
361 
362         nfs_set_events(client);
363     }
364     while (!task.complete) {
365         qemu_coroutine_yield();
366     }
367 
368     return task.ret;
369 }
370 
371 static void nfs_detach_aio_context(BlockDriverState *bs)
372 {
373     NFSClient *client = bs->opaque;
374 
375     aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
376                        false, NULL, NULL, NULL, NULL, NULL);
377     client->events = 0;
378 }
379 
380 static void nfs_attach_aio_context(BlockDriverState *bs,
381                                    AioContext *new_context)
382 {
383     NFSClient *client = bs->opaque;
384 
385     client->aio_context = new_context;
386     nfs_set_events(client);
387 }
388 
389 static void nfs_client_close(NFSClient *client)
390 {
391     if (client->context) {
392         qemu_mutex_lock(&client->mutex);
393         aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
394                            false, NULL, NULL, NULL, NULL, NULL);
395         qemu_mutex_unlock(&client->mutex);
396         if (client->fh) {
397             nfs_close(client->context, client->fh);
398             client->fh = NULL;
399         }
400 #ifdef LIBNFS_FEATURE_UMOUNT
401         nfs_umount(client->context);
402 #endif
403         nfs_destroy_context(client->context);
404         client->context = NULL;
405     }
406     g_free(client->path);
407     qemu_mutex_destroy(&client->mutex);
408     qapi_free_NFSServer(client->server);
409     client->server = NULL;
410 }
411 
412 static void nfs_file_close(BlockDriverState *bs)
413 {
414     NFSClient *client = bs->opaque;
415     nfs_client_close(client);
416 }
417 
418 static int64_t nfs_client_open(NFSClient *client, BlockdevOptionsNfs *opts,
419                                int flags, int open_flags, Error **errp)
420 {
421     int64_t ret = -EINVAL;
422 #ifdef _WIN32
423     struct __stat64 st;
424 #else
425     struct stat st;
426 #endif
427     char *file = NULL, *strp = NULL;
428 
429     qemu_mutex_init(&client->mutex);
430 
431     client->path = g_strdup(opts->path);
432 
433     strp = strrchr(client->path, '/');
434     if (strp == NULL) {
435         error_setg(errp, "Invalid URL specified");
436         goto fail;
437     }
438     file = g_strdup(strp);
439     *strp = 0;
440 
441     /* Steal the NFSServer object from opts; set the original pointer to NULL
442      * to avoid use after free and double free. */
443     client->server = opts->server;
444     opts->server = NULL;
445 
446     client->context = nfs_init_context();
447     if (client->context == NULL) {
448         error_setg(errp, "Failed to init NFS context");
449         goto fail;
450     }
451 
452     if (opts->has_user) {
453         client->uid = opts->user;
454         nfs_set_uid(client->context, client->uid);
455     }
456 
457     if (opts->has_group) {
458         client->gid = opts->group;
459         nfs_set_gid(client->context, client->gid);
460     }
461 
462     if (opts->has_tcp_syn_count) {
463         client->tcp_syncnt = opts->tcp_syn_count;
464         nfs_set_tcp_syncnt(client->context, client->tcp_syncnt);
465     }
466 
467 #ifdef LIBNFS_FEATURE_READAHEAD
468     if (opts->has_readahead_size) {
469         if (open_flags & BDRV_O_NOCACHE) {
470             error_setg(errp, "Cannot enable NFS readahead "
471                              "if cache.direct = on");
472             goto fail;
473         }
474         client->readahead = opts->readahead_size;
475         if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) {
476             warn_report("Truncating NFS readahead size to %d",
477                         QEMU_NFS_MAX_READAHEAD_SIZE);
478             client->readahead = QEMU_NFS_MAX_READAHEAD_SIZE;
479         }
480         nfs_set_readahead(client->context, client->readahead);
481 #ifdef LIBNFS_FEATURE_PAGECACHE
482         nfs_set_pagecache_ttl(client->context, 0);
483 #endif
484         client->cache_used = true;
485     }
486 #endif
487 
488 #ifdef LIBNFS_FEATURE_PAGECACHE
489     if (opts->has_page_cache_size) {
490         if (open_flags & BDRV_O_NOCACHE) {
491             error_setg(errp, "Cannot enable NFS pagecache "
492                              "if cache.direct = on");
493             goto fail;
494         }
495         client->pagecache = opts->page_cache_size;
496         if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) {
497             warn_report("Truncating NFS pagecache size to %d pages",
498                         QEMU_NFS_MAX_PAGECACHE_SIZE);
499             client->pagecache = QEMU_NFS_MAX_PAGECACHE_SIZE;
500         }
501         nfs_set_pagecache(client->context, client->pagecache);
502         nfs_set_pagecache_ttl(client->context, 0);
503         client->cache_used = true;
504     }
505 #endif
506 
507 #ifdef LIBNFS_FEATURE_DEBUG
508     if (opts->has_debug) {
509         client->debug = opts->debug;
510         /* limit the maximum debug level to avoid potential flooding
511          * of our log files. */
512         if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) {
513             warn_report("Limiting NFS debug level to %d",
514                         QEMU_NFS_MAX_DEBUG_LEVEL);
515             client->debug = QEMU_NFS_MAX_DEBUG_LEVEL;
516         }
517         nfs_set_debug(client->context, client->debug);
518     }
519 #endif
520 
521     ret = nfs_mount(client->context, client->server->host, client->path);
522     if (ret < 0) {
523         error_setg(errp, "Failed to mount nfs share: %s",
524                    nfs_get_error(client->context));
525         goto fail;
526     }
527 
528     if (flags & O_CREAT) {
529         ret = nfs_creat(client->context, file, 0600, &client->fh);
530         if (ret < 0) {
531             error_setg(errp, "Failed to create file: %s",
532                        nfs_get_error(client->context));
533             goto fail;
534         }
535     } else {
536         ret = nfs_open(client->context, file, flags, &client->fh);
537         if (ret < 0) {
538             error_setg(errp, "Failed to open file : %s",
539                        nfs_get_error(client->context));
540             goto fail;
541         }
542     }
543 
544     ret = nfs_fstat(client->context, client->fh, &st);
545     if (ret < 0) {
546         error_setg(errp, "Failed to fstat file: %s",
547                    nfs_get_error(client->context));
548         goto fail;
549     }
550 
551     ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE);
552 #if !defined(_WIN32)
553     client->st_blocks = st.st_blocks;
554 #endif
555     client->has_zero_init = S_ISREG(st.st_mode);
556     *strp = '/';
557     goto out;
558 
559 fail:
560     nfs_client_close(client);
561 out:
562     g_free(file);
563     return ret;
564 }
565 
566 static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
567                                                      Error **errp)
568 {
569     BlockdevOptionsNfs *opts = NULL;
570     Visitor *v;
571     const QDictEntry *e;
572 
573     v = qobject_input_visitor_new_flat_confused(options, errp);
574     if (!v) {
575         return NULL;
576     }
577 
578     visit_type_BlockdevOptionsNfs(v, NULL, &opts, errp);
579     visit_free(v);
580     if (!opts) {
581         return NULL;
582     }
583 
584     /* Remove the processed options from the QDict (the visitor processes
585      * _all_ options in the QDict) */
586     while ((e = qdict_first(options))) {
587         qdict_del(options, e->key);
588     }
589 
590     return opts;
591 }
592 
593 static int64_t nfs_client_open_qdict(NFSClient *client, QDict *options,
594                                      int flags, int open_flags, Error **errp)
595 {
596     BlockdevOptionsNfs *opts;
597     int64_t ret;
598 
599     opts = nfs_options_qdict_to_qapi(options, errp);
600     if (opts == NULL) {
601         ret = -EINVAL;
602         goto fail;
603     }
604 
605     ret = nfs_client_open(client, opts, flags, open_flags, errp);
606 fail:
607     qapi_free_BlockdevOptionsNfs(opts);
608     return ret;
609 }
610 
611 static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
612                          Error **errp) {
613     NFSClient *client = bs->opaque;
614     int64_t ret;
615 
616     client->aio_context = bdrv_get_aio_context(bs);
617 
618     ret = nfs_client_open_qdict(client, options,
619                                 (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY,
620                                 bs->open_flags, errp);
621     if (ret < 0) {
622         return ret;
623     }
624 
625     bs->total_sectors = ret;
626     if (client->has_zero_init) {
627         bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
628     }
629     return 0;
630 }
631 
632 static QemuOptsList nfs_create_opts = {
633     .name = "nfs-create-opts",
634     .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head),
635     .desc = {
636         {
637             .name = BLOCK_OPT_SIZE,
638             .type = QEMU_OPT_SIZE,
639             .help = "Virtual disk size"
640         },
641         { /* end of list */ }
642     }
643 };
644 
645 static int nfs_file_co_create(BlockdevCreateOptions *options, Error **errp)
646 {
647     BlockdevCreateOptionsNfs *opts = &options->u.nfs;
648     NFSClient *client = g_new0(NFSClient, 1);
649     int ret;
650 
651     assert(options->driver == BLOCKDEV_DRIVER_NFS);
652 
653     client->aio_context = qemu_get_aio_context();
654 
655     ret = nfs_client_open(client, opts->location, O_CREAT, 0, errp);
656     if (ret < 0) {
657         goto out;
658     }
659     ret = nfs_ftruncate(client->context, client->fh, opts->size);
660     nfs_client_close(client);
661 
662 out:
663     g_free(client);
664     return ret;
665 }
666 
667 static int coroutine_fn nfs_file_co_create_opts(BlockDriver *drv,
668                                                 const char *url,
669                                                 QemuOpts *opts,
670                                                 Error **errp)
671 {
672     BlockdevCreateOptions *create_options;
673     BlockdevCreateOptionsNfs *nfs_opts;
674     QDict *options;
675     int ret;
676 
677     create_options = g_new0(BlockdevCreateOptions, 1);
678     create_options->driver = BLOCKDEV_DRIVER_NFS;
679     nfs_opts = &create_options->u.nfs;
680 
681     /* Read out options */
682     nfs_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
683                               BDRV_SECTOR_SIZE);
684 
685     options = qdict_new();
686     ret = nfs_parse_uri(url, options, errp);
687     if (ret < 0) {
688         goto out;
689     }
690 
691     nfs_opts->location = nfs_options_qdict_to_qapi(options, errp);
692     if (nfs_opts->location == NULL) {
693         ret = -EINVAL;
694         goto out;
695     }
696 
697     ret = nfs_file_co_create(create_options, errp);
698     if (ret < 0) {
699         goto out;
700     }
701 
702     ret = 0;
703 out:
704     qobject_unref(options);
705     qapi_free_BlockdevCreateOptions(create_options);
706     return ret;
707 }
708 
709 static int nfs_has_zero_init(BlockDriverState *bs)
710 {
711     NFSClient *client = bs->opaque;
712     return client->has_zero_init;
713 }
714 
715 #if !defined(_WIN32)
716 /* Called (via nfs_service) with QemuMutex held.  */
717 static void
718 nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data,
719                                void *private_data)
720 {
721     NFSRPC *task = private_data;
722     task->ret = ret;
723     if (task->ret == 0) {
724         memcpy(task->st, data, sizeof(struct stat));
725     }
726     if (task->ret < 0) {
727         error_report("NFS Error: %s", nfs_get_error(nfs));
728     }
729     replay_bh_schedule_oneshot_event(task->client->aio_context,
730                                      nfs_co_generic_bh_cb, task);
731 }
732 
733 static int64_t coroutine_fn nfs_co_get_allocated_file_size(BlockDriverState *bs)
734 {
735     NFSClient *client = bs->opaque;
736     NFSRPC task = {0};
737     struct stat st;
738 
739     if (bdrv_is_read_only(bs) &&
740         !(bs->open_flags & BDRV_O_NOCACHE)) {
741         return client->st_blocks * 512;
742     }
743 
744     nfs_co_init_task(bs, &task);
745     task.st = &st;
746     WITH_QEMU_LOCK_GUARD(&client->mutex) {
747         if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_file_size_cb,
748                             &task) != 0) {
749             return -ENOMEM;
750         }
751 
752         nfs_set_events(client);
753     }
754     while (!task.complete) {
755         qemu_coroutine_yield();
756     }
757 
758     return (task.ret < 0 ? task.ret : st.st_blocks * 512);
759 }
760 #endif
761 
762 static int coroutine_fn
763 nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
764                      PreallocMode prealloc, BdrvRequestFlags flags,
765                      Error **errp)
766 {
767     NFSClient *client = bs->opaque;
768     int ret;
769 
770     if (prealloc != PREALLOC_MODE_OFF) {
771         error_setg(errp, "Unsupported preallocation mode '%s'",
772                    PreallocMode_str(prealloc));
773         return -ENOTSUP;
774     }
775 
776     ret = nfs_ftruncate(client->context, client->fh, offset);
777     if (ret < 0) {
778         error_setg_errno(errp, -ret, "Failed to truncate file");
779         return ret;
780     }
781 
782     return 0;
783 }
784 
785 /* Note that this will not re-establish a connection with the NFS server
786  * - it is effectively a NOP.  */
787 static int nfs_reopen_prepare(BDRVReopenState *state,
788                               BlockReopenQueue *queue, Error **errp)
789 {
790     NFSClient *client = state->bs->opaque;
791 #ifdef _WIN32
792     struct __stat64 st;
793 #else
794     struct stat st;
795 #endif
796     int ret = 0;
797 
798     if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) {
799         error_setg(errp, "Cannot open a read-only mount as read-write");
800         return -EACCES;
801     }
802 
803     if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) {
804         error_setg(errp, "Cannot disable cache if libnfs readahead or"
805                          " pagecache is enabled");
806         return -EINVAL;
807     }
808 
809     /* Update cache for read-only reopens */
810     if (!(state->flags & BDRV_O_RDWR)) {
811         ret = nfs_fstat(client->context, client->fh, &st);
812         if (ret < 0) {
813             error_setg(errp, "Failed to fstat file: %s",
814                        nfs_get_error(client->context));
815             return ret;
816         }
817 #if !defined(_WIN32)
818         client->st_blocks = st.st_blocks;
819 #endif
820     }
821 
822     return 0;
823 }
824 
825 static void nfs_refresh_filename(BlockDriverState *bs)
826 {
827     NFSClient *client = bs->opaque;
828 
829     if (client->uid && !client->gid) {
830         snprintf(bs->exact_filename, sizeof(bs->exact_filename),
831                  "nfs://%s%s?uid=%" PRId64, client->server->host, client->path,
832                  client->uid);
833     } else if (!client->uid && client->gid) {
834         snprintf(bs->exact_filename, sizeof(bs->exact_filename),
835                  "nfs://%s%s?gid=%" PRId64, client->server->host, client->path,
836                  client->gid);
837     } else if (client->uid && client->gid) {
838         snprintf(bs->exact_filename, sizeof(bs->exact_filename),
839                  "nfs://%s%s?uid=%" PRId64 "&gid=%" PRId64,
840                  client->server->host, client->path, client->uid, client->gid);
841     } else {
842         snprintf(bs->exact_filename, sizeof(bs->exact_filename),
843                  "nfs://%s%s", client->server->host, client->path);
844     }
845 }
846 
847 static char *nfs_dirname(BlockDriverState *bs, Error **errp)
848 {
849     NFSClient *client = bs->opaque;
850 
851     if (client->uid || client->gid) {
852         bdrv_refresh_filename(bs);
853         error_setg(errp, "Cannot generate a base directory for NFS node '%s'",
854                    bs->filename);
855         return NULL;
856     }
857 
858     return g_strdup_printf("nfs://%s%s/", client->server->host, client->path);
859 }
860 
861 #ifdef LIBNFS_FEATURE_PAGECACHE
862 static void coroutine_fn nfs_co_invalidate_cache(BlockDriverState *bs,
863                                                  Error **errp)
864 {
865     NFSClient *client = bs->opaque;
866     nfs_pagecache_invalidate(client->context, client->fh);
867 }
868 #endif
869 
870 static const char *nfs_strong_runtime_opts[] = {
871     "path",
872     "user",
873     "group",
874     "server.",
875 
876     NULL
877 };
878 
879 static BlockDriver bdrv_nfs = {
880     .format_name                    = "nfs",
881     .protocol_name                  = "nfs",
882 
883     .instance_size                  = sizeof(NFSClient),
884     .bdrv_parse_filename            = nfs_parse_filename,
885     .create_opts                    = &nfs_create_opts,
886 
887     .bdrv_has_zero_init             = nfs_has_zero_init,
888 /* libnfs does not provide the allocated filesize of a file on win32. */
889 #if !defined(_WIN32)
890     .bdrv_co_get_allocated_file_size = nfs_co_get_allocated_file_size,
891 #endif
892     .bdrv_co_truncate               = nfs_file_co_truncate,
893 
894     .bdrv_file_open                 = nfs_file_open,
895     .bdrv_close                     = nfs_file_close,
896     .bdrv_co_create                 = nfs_file_co_create,
897     .bdrv_co_create_opts            = nfs_file_co_create_opts,
898     .bdrv_reopen_prepare            = nfs_reopen_prepare,
899 
900     .bdrv_co_preadv                 = nfs_co_preadv,
901     .bdrv_co_pwritev                = nfs_co_pwritev,
902     .bdrv_co_flush_to_disk          = nfs_co_flush,
903 
904     .bdrv_detach_aio_context        = nfs_detach_aio_context,
905     .bdrv_attach_aio_context        = nfs_attach_aio_context,
906     .bdrv_refresh_filename          = nfs_refresh_filename,
907     .bdrv_dirname                   = nfs_dirname,
908 
909     .strong_runtime_opts            = nfs_strong_runtime_opts,
910 
911 #ifdef LIBNFS_FEATURE_PAGECACHE
912     .bdrv_co_invalidate_cache       = nfs_co_invalidate_cache,
913 #endif
914 };
915 
916 static void nfs_block_init(void)
917 {
918     bdrv_register(&bdrv_nfs);
919 }
920 
921 block_init(nfs_block_init);
922