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