2 * QEMU Block driver for native access to files on NFS shares
4 * Copyright (c) 2014 Peter Lieven <pl@kamp.de>
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "config-host.h"
28 #include "qemu-common.h"
29 #include "qemu/config-file.h"
30 #include "qemu/error-report.h"
31 #include "block/block_int.h"
35 #include "sysemu/sysemu.h"
36 #include <nfsc/libnfs.h>
38 typedef struct NFSClient
{
39 struct nfs_context
*context
;
45 typedef struct NFSRPC
{
54 static void nfs_process_read(void *arg
);
55 static void nfs_process_write(void *arg
);
57 static void nfs_set_events(NFSClient
*client
)
59 int ev
= nfs_which_events(client
->context
);
60 if (ev
!= client
->events
) {
61 qemu_aio_set_fd_handler(nfs_get_fd(client
->context
),
62 (ev
& POLLIN
) ? nfs_process_read
: NULL
,
63 (ev
& POLLOUT
) ? nfs_process_write
: NULL
,
70 static void nfs_process_read(void *arg
)
72 NFSClient
*client
= arg
;
73 nfs_service(client
->context
, POLLIN
);
74 nfs_set_events(client
);
77 static void nfs_process_write(void *arg
)
79 NFSClient
*client
= arg
;
80 nfs_service(client
->context
, POLLOUT
);
81 nfs_set_events(client
);
84 static void nfs_co_init_task(NFSClient
*client
, NFSRPC
*task
)
87 .co
= qemu_coroutine_self(),
91 static void nfs_co_generic_bh_cb(void *opaque
)
93 NFSRPC
*task
= opaque
;
94 qemu_bh_delete(task
->bh
);
95 qemu_coroutine_enter(task
->co
, NULL
);
99 nfs_co_generic_cb(int ret
, struct nfs_context
*nfs
, void *data
,
102 NFSRPC
*task
= private_data
;
105 if (task
->ret
> 0 && task
->iov
) {
106 if (task
->ret
<= task
->iov
->size
) {
107 qemu_iovec_from_buf(task
->iov
, 0, data
, task
->ret
);
112 if (task
->ret
== 0 && task
->st
) {
113 memcpy(task
->st
, data
, sizeof(struct stat
));
116 error_report("NFS Error: %s", nfs_get_error(nfs
));
119 task
->bh
= qemu_bh_new(nfs_co_generic_bh_cb
, task
);
120 qemu_bh_schedule(task
->bh
);
124 static int coroutine_fn
nfs_co_readv(BlockDriverState
*bs
,
125 int64_t sector_num
, int nb_sectors
,
128 NFSClient
*client
= bs
->opaque
;
131 nfs_co_init_task(client
, &task
);
134 if (nfs_pread_async(client
->context
, client
->fh
,
135 sector_num
* BDRV_SECTOR_SIZE
,
136 nb_sectors
* BDRV_SECTOR_SIZE
,
137 nfs_co_generic_cb
, &task
) != 0) {
141 while (!task
.complete
) {
142 nfs_set_events(client
);
143 qemu_coroutine_yield();
150 /* zero pad short reads */
151 if (task
.ret
< iov
->size
) {
152 qemu_iovec_memset(iov
, task
.ret
, 0, iov
->size
- task
.ret
);
158 static int coroutine_fn
nfs_co_writev(BlockDriverState
*bs
,
159 int64_t sector_num
, int nb_sectors
,
162 NFSClient
*client
= bs
->opaque
;
166 nfs_co_init_task(client
, &task
);
168 buf
= g_malloc(nb_sectors
* BDRV_SECTOR_SIZE
);
169 qemu_iovec_to_buf(iov
, 0, buf
, nb_sectors
* BDRV_SECTOR_SIZE
);
171 if (nfs_pwrite_async(client
->context
, client
->fh
,
172 sector_num
* BDRV_SECTOR_SIZE
,
173 nb_sectors
* BDRV_SECTOR_SIZE
,
174 buf
, nfs_co_generic_cb
, &task
) != 0) {
179 while (!task
.complete
) {
180 nfs_set_events(client
);
181 qemu_coroutine_yield();
186 if (task
.ret
!= nb_sectors
* BDRV_SECTOR_SIZE
) {
187 return task
.ret
< 0 ? task
.ret
: -EIO
;
193 static int coroutine_fn
nfs_co_flush(BlockDriverState
*bs
)
195 NFSClient
*client
= bs
->opaque
;
198 nfs_co_init_task(client
, &task
);
200 if (nfs_fsync_async(client
->context
, client
->fh
, nfs_co_generic_cb
,
205 while (!task
.complete
) {
206 nfs_set_events(client
);
207 qemu_coroutine_yield();
213 /* TODO Convert to fine grained options */
214 static QemuOptsList runtime_opts
= {
216 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
220 .type
= QEMU_OPT_STRING
,
221 .help
= "URL to the NFS file",
223 { /* end of list */ }
227 static void nfs_client_close(NFSClient
*client
)
229 if (client
->context
) {
231 nfs_close(client
->context
, client
->fh
);
233 qemu_aio_set_fd_handler(nfs_get_fd(client
->context
), NULL
, NULL
, NULL
);
234 nfs_destroy_context(client
->context
);
236 memset(client
, 0, sizeof(NFSClient
));
239 static void nfs_file_close(BlockDriverState
*bs
)
241 NFSClient
*client
= bs
->opaque
;
242 nfs_client_close(client
);
245 static int64_t nfs_client_open(NFSClient
*client
, const char *filename
,
246 int flags
, Error
**errp
)
248 int ret
= -EINVAL
, i
;
251 QueryParams
*qp
= NULL
;
252 char *file
= NULL
, *strp
= NULL
;
254 uri
= uri_parse(filename
);
256 error_setg(errp
, "Invalid URL specified");
260 error_setg(errp
, "Invalid URL specified");
263 strp
= strrchr(uri
->path
, '/');
265 error_setg(errp
, "Invalid URL specified");
268 file
= g_strdup(strp
);
271 client
->context
= nfs_init_context();
272 if (client
->context
== NULL
) {
273 error_setg(errp
, "Failed to init NFS context");
277 qp
= query_params_parse(uri
->query
);
278 for (i
= 0; i
< qp
->n
; i
++) {
279 if (!qp
->p
[i
].value
) {
280 error_setg(errp
, "Value for NFS parameter expected: %s",
284 if (!strncmp(qp
->p
[i
].name
, "uid", 3)) {
285 nfs_set_uid(client
->context
, atoi(qp
->p
[i
].value
));
286 } else if (!strncmp(qp
->p
[i
].name
, "gid", 3)) {
287 nfs_set_gid(client
->context
, atoi(qp
->p
[i
].value
));
288 } else if (!strncmp(qp
->p
[i
].name
, "tcp-syncnt", 10)) {
289 nfs_set_tcp_syncnt(client
->context
, atoi(qp
->p
[i
].value
));
291 error_setg(errp
, "Unknown NFS parameter name: %s",
297 ret
= nfs_mount(client
->context
, uri
->server
, uri
->path
);
299 error_setg(errp
, "Failed to mount nfs share: %s",
300 nfs_get_error(client
->context
));
304 if (flags
& O_CREAT
) {
305 ret
= nfs_creat(client
->context
, file
, 0600, &client
->fh
);
307 error_setg(errp
, "Failed to create file: %s",
308 nfs_get_error(client
->context
));
312 ret
= nfs_open(client
->context
, file
, flags
, &client
->fh
);
314 error_setg(errp
, "Failed to open file : %s",
315 nfs_get_error(client
->context
));
320 ret
= nfs_fstat(client
->context
, client
->fh
, &st
);
322 error_setg(errp
, "Failed to fstat file: %s",
323 nfs_get_error(client
->context
));
327 ret
= DIV_ROUND_UP(st
.st_size
, BDRV_SECTOR_SIZE
);
328 client
->has_zero_init
= S_ISREG(st
.st_mode
);
331 nfs_client_close(client
);
334 query_params_free(qp
);
341 static int nfs_file_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
343 NFSClient
*client
= bs
->opaque
;
346 Error
*local_err
= NULL
;
348 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
349 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
351 error_propagate(errp
, local_err
);
354 ret
= nfs_client_open(client
, qemu_opt_get(opts
, "filename"),
355 (flags
& BDRV_O_RDWR
) ? O_RDWR
: O_RDONLY
,
360 bs
->total_sectors
= ret
;
364 static int nfs_file_create(const char *url
, QEMUOptionParameter
*options
,
368 int64_t total_size
= 0;
369 NFSClient
*client
= g_malloc0(sizeof(NFSClient
));
371 /* Read out options */
372 while (options
&& options
->name
) {
373 if (!strcmp(options
->name
, "size")) {
374 total_size
= options
->value
.n
;
379 ret
= nfs_client_open(client
, url
, O_CREAT
, errp
);
383 ret
= nfs_ftruncate(client
->context
, client
->fh
, total_size
);
384 nfs_client_close(client
);
390 static int nfs_has_zero_init(BlockDriverState
*bs
)
392 NFSClient
*client
= bs
->opaque
;
393 return client
->has_zero_init
;
396 static int64_t nfs_get_allocated_file_size(BlockDriverState
*bs
)
398 NFSClient
*client
= bs
->opaque
;
403 if (nfs_fstat_async(client
->context
, client
->fh
, nfs_co_generic_cb
,
408 while (!task
.complete
) {
409 nfs_set_events(client
);
413 return (task
.ret
< 0 ? task
.ret
: st
.st_blocks
* st
.st_blksize
);
416 static int nfs_file_truncate(BlockDriverState
*bs
, int64_t offset
)
418 NFSClient
*client
= bs
->opaque
;
419 return nfs_ftruncate(client
->context
, client
->fh
, offset
);
422 static BlockDriver bdrv_nfs
= {
423 .format_name
= "nfs",
424 .protocol_name
= "nfs",
426 .instance_size
= sizeof(NFSClient
),
427 .bdrv_needs_filename
= true,
428 .bdrv_has_zero_init
= nfs_has_zero_init
,
429 .bdrv_get_allocated_file_size
= nfs_get_allocated_file_size
,
430 .bdrv_truncate
= nfs_file_truncate
,
432 .bdrv_file_open
= nfs_file_open
,
433 .bdrv_close
= nfs_file_close
,
434 .bdrv_create
= nfs_file_create
,
436 .bdrv_co_readv
= nfs_co_readv
,
437 .bdrv_co_writev
= nfs_co_writev
,
438 .bdrv_co_flush_to_disk
= nfs_co_flush
,
441 static void nfs_block_init(void)
443 bdrv_register(&bdrv_nfs
);
446 block_init(nfs_block_init
);