xref: /qemu/block/nfs.c (revision c888f7e0)
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 #include <poll.h>
28 #include "qemu/config-file.h"
29 #include "qemu/error-report.h"
30 #include "qapi/error.h"
31 #include "block/block_int.h"
32 #include "block/qdict.h"
33 #include "trace.h"
34 #include "qemu/iov.h"
35 #include "qemu/main-loop.h"
36 #include "qemu/module.h"
37 #include "qemu/option.h"
38 #include "qemu/uri.h"
39 #include "qemu/cutils.h"
40 #include "sysemu/sysemu.h"
41 #include "sysemu/replay.h"
42 #include "qapi/qapi-visit-block-core.h"
43 #include "qapi/qmp/qdict.h"
44 #include "qapi/qmp/qstring.h"
45 #include "qapi/qobject-input-visitor.h"
46 #include "qapi/qobject-output-visitor.h"
47 #include <nfsc/libnfs.h>
48 
49 
50 #define QEMU_NFS_MAX_READAHEAD_SIZE 1048576
51 #define QEMU_NFS_MAX_PAGECACHE_SIZE (8388608 / NFS_BLKSIZE)
52 #define QEMU_NFS_MAX_DEBUG_LEVEL 2
53 
54 typedef struct NFSClient {
55     struct nfs_context *context;
56     struct nfsfh *fh;
57     int events;
58     bool has_zero_init;
59     AioContext *aio_context;
60     QemuMutex mutex;
61     blkcnt_t st_blocks;
62     bool cache_used;
63     NFSServer *server;
64     char *path;
65     int64_t uid, gid, tcp_syncnt, readahead, pagecache, debug;
66 } NFSClient;
67 
68 typedef struct NFSRPC {
69     BlockDriverState *bs;
70     int ret;
71     int complete;
72     QEMUIOVector *iov;
73     struct stat *st;
74     Coroutine *co;
75     NFSClient *client;
76 } NFSRPC;
77 
78 static int nfs_parse_uri(const char *filename, QDict *options, Error **errp)
79 {
80     URI *uri = NULL;
81     QueryParams *qp = NULL;
82     int ret = -EINVAL, i;
83 
84     uri = uri_parse(filename);
85     if (!uri) {
86         error_setg(errp, "Invalid URI specified");
87         goto out;
88     }
89     if (g_strcmp0(uri->scheme, "nfs") != 0) {
90         error_setg(errp, "URI scheme must be 'nfs'");
91         goto out;
92     }
93 
94     if (!uri->server) {
95         error_setg(errp, "missing hostname in URI");
96         goto out;
97     }
98 
99     if (!uri->path) {
100         error_setg(errp, "missing file path in URI");
101         goto out;
102     }
103 
104     qp = query_params_parse(uri->query);
105     if (!qp) {
106         error_setg(errp, "could not parse query parameters");
107         goto out;
108     }
109 
110     qdict_put_str(options, "server.host", uri->server);
111     qdict_put_str(options, "server.type", "inet");
112     qdict_put_str(options, "path", uri->path);
113 
114     for (i = 0; i < qp->n; i++) {
115         unsigned long long val;
116         if (!qp->p[i].value) {
117             error_setg(errp, "Value for NFS parameter expected: %s",
118                        qp->p[i].name);
119             goto out;
120         }
121         if (parse_uint_full(qp->p[i].value, &val, 0)) {
122             error_setg(errp, "Illegal value for NFS parameter: %s",
123                        qp->p[i].name);
124             goto out;
125         }
126         if (!strcmp(qp->p[i].name, "uid")) {
127             qdict_put_str(options, "user", qp->p[i].value);
128         } else if (!strcmp(qp->p[i].name, "gid")) {
129             qdict_put_str(options, "group", qp->p[i].value);
130         } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) {
131             qdict_put_str(options, "tcp-syn-count", qp->p[i].value);
132         } else if (!strcmp(qp->p[i].name, "readahead")) {
133             qdict_put_str(options, "readahead-size", qp->p[i].value);
134         } else if (!strcmp(qp->p[i].name, "pagecache")) {
135             qdict_put_str(options, "page-cache-size", qp->p[i].value);
136         } else if (!strcmp(qp->p[i].name, "debug")) {
137             qdict_put_str(options, "debug", qp->p[i].value);
138         } else {
139             error_setg(errp, "Unknown NFS parameter name: %s",
140                        qp->p[i].name);
141             goto out;
142         }
143     }
144     ret = 0;
145 out:
146     if (qp) {
147         query_params_free(qp);
148     }
149     if (uri) {
150         uri_free(uri);
151     }
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, 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 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, uint64_t offset,
267                                       uint64_t bytes, QEMUIOVector *iov,
268                                       int 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, uint64_t offset,
301                                        uint64_t bytes, QEMUIOVector *iov,
302                                        int 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);
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);
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     struct stat st;
423     char *file = NULL, *strp = NULL;
424 
425     qemu_mutex_init(&client->mutex);
426 
427     client->path = g_strdup(opts->path);
428 
429     strp = strrchr(client->path, '/');
430     if (strp == NULL) {
431         error_setg(errp, "Invalid URL specified");
432         goto fail;
433     }
434     file = g_strdup(strp);
435     *strp = 0;
436 
437     /* Steal the NFSServer object from opts; set the original pointer to NULL
438      * to avoid use after free and double free. */
439     client->server = opts->server;
440     opts->server = NULL;
441 
442     client->context = nfs_init_context();
443     if (client->context == NULL) {
444         error_setg(errp, "Failed to init NFS context");
445         goto fail;
446     }
447 
448     if (opts->has_user) {
449         client->uid = opts->user;
450         nfs_set_uid(client->context, client->uid);
451     }
452 
453     if (opts->has_group) {
454         client->gid = opts->group;
455         nfs_set_gid(client->context, client->gid);
456     }
457 
458     if (opts->has_tcp_syn_count) {
459         client->tcp_syncnt = opts->tcp_syn_count;
460         nfs_set_tcp_syncnt(client->context, client->tcp_syncnt);
461     }
462 
463 #ifdef LIBNFS_FEATURE_READAHEAD
464     if (opts->has_readahead_size) {
465         if (open_flags & BDRV_O_NOCACHE) {
466             error_setg(errp, "Cannot enable NFS readahead "
467                              "if cache.direct = on");
468             goto fail;
469         }
470         client->readahead = opts->readahead_size;
471         if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) {
472             warn_report("Truncating NFS readahead size to %d",
473                         QEMU_NFS_MAX_READAHEAD_SIZE);
474             client->readahead = QEMU_NFS_MAX_READAHEAD_SIZE;
475         }
476         nfs_set_readahead(client->context, client->readahead);
477 #ifdef LIBNFS_FEATURE_PAGECACHE
478         nfs_set_pagecache_ttl(client->context, 0);
479 #endif
480         client->cache_used = true;
481     }
482 #endif
483 
484 #ifdef LIBNFS_FEATURE_PAGECACHE
485     if (opts->has_page_cache_size) {
486         if (open_flags & BDRV_O_NOCACHE) {
487             error_setg(errp, "Cannot enable NFS pagecache "
488                              "if cache.direct = on");
489             goto fail;
490         }
491         client->pagecache = opts->page_cache_size;
492         if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) {
493             warn_report("Truncating NFS pagecache size to %d pages",
494                         QEMU_NFS_MAX_PAGECACHE_SIZE);
495             client->pagecache = QEMU_NFS_MAX_PAGECACHE_SIZE;
496         }
497         nfs_set_pagecache(client->context, client->pagecache);
498         nfs_set_pagecache_ttl(client->context, 0);
499         client->cache_used = true;
500     }
501 #endif
502 
503 #ifdef LIBNFS_FEATURE_DEBUG
504     if (opts->has_debug) {
505         client->debug = opts->debug;
506         /* limit the maximum debug level to avoid potential flooding
507          * of our log files. */
508         if (client->debug > QEMU_NFS_MAX_DEBUG_LEVEL) {
509             warn_report("Limiting NFS debug level to %d",
510                         QEMU_NFS_MAX_DEBUG_LEVEL);
511             client->debug = QEMU_NFS_MAX_DEBUG_LEVEL;
512         }
513         nfs_set_debug(client->context, client->debug);
514     }
515 #endif
516 
517     ret = nfs_mount(client->context, client->server->host, client->path);
518     if (ret < 0) {
519         error_setg(errp, "Failed to mount nfs share: %s",
520                    nfs_get_error(client->context));
521         goto fail;
522     }
523 
524     if (flags & O_CREAT) {
525         ret = nfs_creat(client->context, file, 0600, &client->fh);
526         if (ret < 0) {
527             error_setg(errp, "Failed to create file: %s",
528                        nfs_get_error(client->context));
529             goto fail;
530         }
531     } else {
532         ret = nfs_open(client->context, file, flags, &client->fh);
533         if (ret < 0) {
534             error_setg(errp, "Failed to open file : %s",
535                        nfs_get_error(client->context));
536             goto fail;
537         }
538     }
539 
540     ret = nfs_fstat(client->context, client->fh, &st);
541     if (ret < 0) {
542         error_setg(errp, "Failed to fstat file: %s",
543                    nfs_get_error(client->context));
544         goto fail;
545     }
546 
547     ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE);
548     client->st_blocks = st.st_blocks;
549     client->has_zero_init = S_ISREG(st.st_mode);
550     *strp = '/';
551     goto out;
552 
553 fail:
554     nfs_client_close(client);
555 out:
556     g_free(file);
557     return ret;
558 }
559 
560 static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
561                                                      Error **errp)
562 {
563     BlockdevOptionsNfs *opts = NULL;
564     Visitor *v;
565     const QDictEntry *e;
566     Error *local_err = NULL;
567 
568     v = qobject_input_visitor_new_flat_confused(options, errp);
569     if (!v) {
570         return NULL;
571     }
572 
573     visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err);
574     visit_free(v);
575 
576     if (local_err) {
577         error_propagate(errp, local_err);
578         return NULL;
579     }
580 
581     /* Remove the processed options from the QDict (the visitor processes
582      * _all_ options in the QDict) */
583     while ((e = qdict_first(options))) {
584         qdict_del(options, e->key);
585     }
586 
587     return opts;
588 }
589 
590 static int64_t nfs_client_open_qdict(NFSClient *client, QDict *options,
591                                      int flags, int open_flags, Error **errp)
592 {
593     BlockdevOptionsNfs *opts;
594     int ret;
595 
596     opts = nfs_options_qdict_to_qapi(options, errp);
597     if (opts == NULL) {
598         ret = -EINVAL;
599         goto fail;
600     }
601 
602     ret = nfs_client_open(client, opts, flags, open_flags, errp);
603 fail:
604     qapi_free_BlockdevOptionsNfs(opts);
605     return ret;
606 }
607 
608 static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
609                          Error **errp) {
610     NFSClient *client = bs->opaque;
611     int64_t ret;
612 
613     client->aio_context = bdrv_get_aio_context(bs);
614 
615     ret = nfs_client_open_qdict(client, options,
616                                 (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY,
617                                 bs->open_flags, errp);
618     if (ret < 0) {
619         return ret;
620     }
621 
622     bs->total_sectors = ret;
623     if (client->has_zero_init) {
624         bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
625     }
626     return 0;
627 }
628 
629 static QemuOptsList nfs_create_opts = {
630     .name = "nfs-create-opts",
631     .head = QTAILQ_HEAD_INITIALIZER(nfs_create_opts.head),
632     .desc = {
633         {
634             .name = BLOCK_OPT_SIZE,
635             .type = QEMU_OPT_SIZE,
636             .help = "Virtual disk size"
637         },
638         { /* end of list */ }
639     }
640 };
641 
642 static int nfs_file_co_create(BlockdevCreateOptions *options, Error **errp)
643 {
644     BlockdevCreateOptionsNfs *opts = &options->u.nfs;
645     NFSClient *client = g_new0(NFSClient, 1);
646     int ret;
647 
648     assert(options->driver == BLOCKDEV_DRIVER_NFS);
649 
650     client->aio_context = qemu_get_aio_context();
651 
652     ret = nfs_client_open(client, opts->location, O_CREAT, 0, errp);
653     if (ret < 0) {
654         goto out;
655     }
656     ret = nfs_ftruncate(client->context, client->fh, opts->size);
657     nfs_client_close(client);
658 
659 out:
660     g_free(client);
661     return ret;
662 }
663 
664 static int coroutine_fn nfs_file_co_create_opts(BlockDriver *drv,
665                                                 const char *url,
666                                                 QemuOpts *opts,
667                                                 Error **errp)
668 {
669     BlockdevCreateOptions *create_options;
670     BlockdevCreateOptionsNfs *nfs_opts;
671     QDict *options;
672     int ret;
673 
674     create_options = g_new0(BlockdevCreateOptions, 1);
675     create_options->driver = BLOCKDEV_DRIVER_NFS;
676     nfs_opts = &create_options->u.nfs;
677 
678     /* Read out options */
679     nfs_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
680                               BDRV_SECTOR_SIZE);
681 
682     options = qdict_new();
683     ret = nfs_parse_uri(url, options, errp);
684     if (ret < 0) {
685         goto out;
686     }
687 
688     nfs_opts->location = nfs_options_qdict_to_qapi(options, errp);
689     if (nfs_opts->location == NULL) {
690         ret = -EINVAL;
691         goto out;
692     }
693 
694     ret = nfs_file_co_create(create_options, errp);
695     if (ret < 0) {
696         goto out;
697     }
698 
699     ret = 0;
700 out:
701     qobject_unref(options);
702     qapi_free_BlockdevCreateOptions(create_options);
703     return ret;
704 }
705 
706 static int nfs_has_zero_init(BlockDriverState *bs)
707 {
708     NFSClient *client = bs->opaque;
709     return client->has_zero_init;
710 }
711 
712 /* Called (via nfs_service) with QemuMutex held.  */
713 static void
714 nfs_get_allocated_file_size_cb(int ret, struct nfs_context *nfs, void *data,
715                                void *private_data)
716 {
717     NFSRPC *task = private_data;
718     task->ret = ret;
719     if (task->ret == 0) {
720         memcpy(task->st, data, sizeof(struct stat));
721     }
722     if (task->ret < 0) {
723         error_report("NFS Error: %s", nfs_get_error(nfs));
724     }
725 
726     /* Set task->complete before reading bs->wakeup.  */
727     atomic_mb_set(&task->complete, 1);
728     bdrv_wakeup(task->bs);
729 }
730 
731 static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
732 {
733     NFSClient *client = bs->opaque;
734     NFSRPC task = {0};
735     struct stat st;
736 
737     if (bdrv_is_read_only(bs) &&
738         !(bs->open_flags & BDRV_O_NOCACHE)) {
739         return client->st_blocks * 512;
740     }
741 
742     task.bs = bs;
743     task.st = &st;
744     if (nfs_fstat_async(client->context, client->fh, nfs_get_allocated_file_size_cb,
745                         &task) != 0) {
746         return -ENOMEM;
747     }
748 
749     nfs_set_events(client);
750     BDRV_POLL_WHILE(bs, !task.complete);
751 
752     return (task.ret < 0 ? task.ret : st.st_blocks * 512);
753 }
754 
755 static int coroutine_fn
756 nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
757                      PreallocMode prealloc, BdrvRequestFlags flags,
758                      Error **errp)
759 {
760     NFSClient *client = bs->opaque;
761     int ret;
762 
763     if (prealloc != PREALLOC_MODE_OFF) {
764         error_setg(errp, "Unsupported preallocation mode '%s'",
765                    PreallocMode_str(prealloc));
766         return -ENOTSUP;
767     }
768 
769     ret = nfs_ftruncate(client->context, client->fh, offset);
770     if (ret < 0) {
771         error_setg_errno(errp, -ret, "Failed to truncate file");
772         return ret;
773     }
774 
775     return 0;
776 }
777 
778 /* Note that this will not re-establish a connection with the NFS server
779  * - it is effectively a NOP.  */
780 static int nfs_reopen_prepare(BDRVReopenState *state,
781                               BlockReopenQueue *queue, Error **errp)
782 {
783     NFSClient *client = state->bs->opaque;
784     struct stat st;
785     int ret = 0;
786 
787     if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) {
788         error_setg(errp, "Cannot open a read-only mount as read-write");
789         return -EACCES;
790     }
791 
792     if ((state->flags & BDRV_O_NOCACHE) && client->cache_used) {
793         error_setg(errp, "Cannot disable cache if libnfs readahead or"
794                          " pagecache is enabled");
795         return -EINVAL;
796     }
797 
798     /* Update cache for read-only reopens */
799     if (!(state->flags & BDRV_O_RDWR)) {
800         ret = nfs_fstat(client->context, client->fh, &st);
801         if (ret < 0) {
802             error_setg(errp, "Failed to fstat file: %s",
803                        nfs_get_error(client->context));
804             return ret;
805         }
806         client->st_blocks = st.st_blocks;
807     }
808 
809     return 0;
810 }
811 
812 static void nfs_refresh_filename(BlockDriverState *bs)
813 {
814     NFSClient *client = bs->opaque;
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 
834 static char *nfs_dirname(BlockDriverState *bs, Error **errp)
835 {
836     NFSClient *client = bs->opaque;
837 
838     if (client->uid || client->gid) {
839         bdrv_refresh_filename(bs);
840         error_setg(errp, "Cannot generate a base directory for NFS node '%s'",
841                    bs->filename);
842         return NULL;
843     }
844 
845     return g_strdup_printf("nfs://%s%s/", client->server->host, client->path);
846 }
847 
848 #ifdef LIBNFS_FEATURE_PAGECACHE
849 static void coroutine_fn nfs_co_invalidate_cache(BlockDriverState *bs,
850                                                  Error **errp)
851 {
852     NFSClient *client = bs->opaque;
853     nfs_pagecache_invalidate(client->context, client->fh);
854 }
855 #endif
856 
857 static const char *nfs_strong_runtime_opts[] = {
858     "path",
859     "user",
860     "group",
861     "server.",
862 
863     NULL
864 };
865 
866 static BlockDriver bdrv_nfs = {
867     .format_name                    = "nfs",
868     .protocol_name                  = "nfs",
869 
870     .instance_size                  = sizeof(NFSClient),
871     .bdrv_parse_filename            = nfs_parse_filename,
872     .create_opts                    = &nfs_create_opts,
873 
874     .bdrv_has_zero_init             = nfs_has_zero_init,
875     .bdrv_get_allocated_file_size   = nfs_get_allocated_file_size,
876     .bdrv_co_truncate               = nfs_file_co_truncate,
877 
878     .bdrv_file_open                 = nfs_file_open,
879     .bdrv_close                     = nfs_file_close,
880     .bdrv_co_create                 = nfs_file_co_create,
881     .bdrv_co_create_opts            = nfs_file_co_create_opts,
882     .bdrv_reopen_prepare            = nfs_reopen_prepare,
883 
884     .bdrv_co_preadv                 = nfs_co_preadv,
885     .bdrv_co_pwritev                = nfs_co_pwritev,
886     .bdrv_co_flush_to_disk          = nfs_co_flush,
887 
888     .bdrv_detach_aio_context        = nfs_detach_aio_context,
889     .bdrv_attach_aio_context        = nfs_attach_aio_context,
890     .bdrv_refresh_filename          = nfs_refresh_filename,
891     .bdrv_dirname                   = nfs_dirname,
892 
893     .strong_runtime_opts            = nfs_strong_runtime_opts,
894 
895 #ifdef LIBNFS_FEATURE_PAGECACHE
896     .bdrv_co_invalidate_cache       = nfs_co_invalidate_cache,
897 #endif
898 };
899 
900 static void nfs_block_init(void)
901 {
902     bdrv_register(&bdrv_nfs);
903 }
904 
905 block_init(nfs_block_init);
906