]>
Commit | Line | Data |
---|---|---|
6542aa9c PL |
1 | /* |
2 | * QEMU Block driver for native access to files on NFS shares | |
3 | * | |
4 | * Copyright (c) 2014 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 "config-host.h" | |
26 | ||
27 | #include <poll.h> | |
28 | #include "qemu-common.h" | |
29 | #include "qemu/config-file.h" | |
30 | #include "qemu/error-report.h" | |
31 | #include "block/block_int.h" | |
32 | #include "trace.h" | |
33 | #include "qemu/iov.h" | |
34 | #include "qemu/uri.h" | |
35 | #include "sysemu/sysemu.h" | |
36 | #include <nfsc/libnfs.h> | |
37 | ||
38 | typedef struct NFSClient { | |
39 | struct nfs_context *context; | |
40 | struct nfsfh *fh; | |
41 | int events; | |
42 | bool has_zero_init; | |
43 | } NFSClient; | |
44 | ||
45 | typedef struct NFSRPC { | |
46 | int ret; | |
47 | int complete; | |
48 | QEMUIOVector *iov; | |
49 | struct stat *st; | |
50 | Coroutine *co; | |
51 | QEMUBH *bh; | |
52 | } NFSRPC; | |
53 | ||
54 | static void nfs_process_read(void *arg); | |
55 | static void nfs_process_write(void *arg); | |
56 | ||
57 | static void nfs_set_events(NFSClient *client) | |
58 | { | |
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, | |
64 | client); | |
65 | ||
66 | } | |
67 | client->events = ev; | |
68 | } | |
69 | ||
70 | static void nfs_process_read(void *arg) | |
71 | { | |
72 | NFSClient *client = arg; | |
73 | nfs_service(client->context, POLLIN); | |
74 | nfs_set_events(client); | |
75 | } | |
76 | ||
77 | static void nfs_process_write(void *arg) | |
78 | { | |
79 | NFSClient *client = arg; | |
80 | nfs_service(client->context, POLLOUT); | |
81 | nfs_set_events(client); | |
82 | } | |
83 | ||
84 | static void nfs_co_init_task(NFSClient *client, NFSRPC *task) | |
85 | { | |
86 | *task = (NFSRPC) { | |
87 | .co = qemu_coroutine_self(), | |
88 | }; | |
89 | } | |
90 | ||
91 | static void nfs_co_generic_bh_cb(void *opaque) | |
92 | { | |
93 | NFSRPC *task = opaque; | |
94 | qemu_bh_delete(task->bh); | |
95 | qemu_coroutine_enter(task->co, NULL); | |
96 | } | |
97 | ||
98 | static void | |
99 | nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, | |
100 | void *private_data) | |
101 | { | |
102 | NFSRPC *task = private_data; | |
103 | task->complete = 1; | |
104 | task->ret = ret; | |
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); | |
108 | } else { | |
109 | task->ret = -EIO; | |
110 | } | |
111 | } | |
112 | if (task->ret == 0 && task->st) { | |
113 | memcpy(task->st, data, sizeof(struct stat)); | |
114 | } | |
20fccb18 PL |
115 | if (task->ret < 0) { |
116 | error_report("NFS Error: %s", nfs_get_error(nfs)); | |
117 | } | |
6542aa9c PL |
118 | if (task->co) { |
119 | task->bh = qemu_bh_new(nfs_co_generic_bh_cb, task); | |
120 | qemu_bh_schedule(task->bh); | |
121 | } | |
122 | } | |
123 | ||
124 | static int coroutine_fn nfs_co_readv(BlockDriverState *bs, | |
125 | int64_t sector_num, int nb_sectors, | |
126 | QEMUIOVector *iov) | |
127 | { | |
128 | NFSClient *client = bs->opaque; | |
129 | NFSRPC task; | |
130 | ||
131 | nfs_co_init_task(client, &task); | |
132 | task.iov = iov; | |
133 | ||
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) { | |
138 | return -ENOMEM; | |
139 | } | |
140 | ||
141 | while (!task.complete) { | |
142 | nfs_set_events(client); | |
143 | qemu_coroutine_yield(); | |
144 | } | |
145 | ||
146 | if (task.ret < 0) { | |
147 | return task.ret; | |
148 | } | |
149 | ||
150 | /* zero pad short reads */ | |
151 | if (task.ret < iov->size) { | |
152 | qemu_iovec_memset(iov, task.ret, 0, iov->size - task.ret); | |
153 | } | |
154 | ||
155 | return 0; | |
156 | } | |
157 | ||
158 | static int coroutine_fn nfs_co_writev(BlockDriverState *bs, | |
159 | int64_t sector_num, int nb_sectors, | |
160 | QEMUIOVector *iov) | |
161 | { | |
162 | NFSClient *client = bs->opaque; | |
163 | NFSRPC task; | |
164 | char *buf = NULL; | |
165 | ||
166 | nfs_co_init_task(client, &task); | |
167 | ||
168 | buf = g_malloc(nb_sectors * BDRV_SECTOR_SIZE); | |
169 | qemu_iovec_to_buf(iov, 0, buf, nb_sectors * BDRV_SECTOR_SIZE); | |
170 | ||
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) { | |
175 | g_free(buf); | |
176 | return -ENOMEM; | |
177 | } | |
178 | ||
179 | while (!task.complete) { | |
180 | nfs_set_events(client); | |
181 | qemu_coroutine_yield(); | |
182 | } | |
183 | ||
184 | g_free(buf); | |
185 | ||
186 | if (task.ret != nb_sectors * BDRV_SECTOR_SIZE) { | |
187 | return task.ret < 0 ? task.ret : -EIO; | |
188 | } | |
189 | ||
190 | return 0; | |
191 | } | |
192 | ||
193 | static int coroutine_fn nfs_co_flush(BlockDriverState *bs) | |
194 | { | |
195 | NFSClient *client = bs->opaque; | |
196 | NFSRPC task; | |
197 | ||
198 | nfs_co_init_task(client, &task); | |
199 | ||
200 | if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, | |
201 | &task) != 0) { | |
202 | return -ENOMEM; | |
203 | } | |
204 | ||
205 | while (!task.complete) { | |
206 | nfs_set_events(client); | |
207 | qemu_coroutine_yield(); | |
208 | } | |
209 | ||
210 | return task.ret; | |
211 | } | |
212 | ||
213 | /* TODO Convert to fine grained options */ | |
214 | static QemuOptsList runtime_opts = { | |
215 | .name = "nfs", | |
216 | .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), | |
217 | .desc = { | |
218 | { | |
219 | .name = "filename", | |
220 | .type = QEMU_OPT_STRING, | |
221 | .help = "URL to the NFS file", | |
222 | }, | |
223 | { /* end of list */ } | |
224 | }, | |
225 | }; | |
226 | ||
227 | static void nfs_client_close(NFSClient *client) | |
228 | { | |
229 | if (client->context) { | |
230 | if (client->fh) { | |
231 | nfs_close(client->context, client->fh); | |
232 | } | |
233 | qemu_aio_set_fd_handler(nfs_get_fd(client->context), NULL, NULL, NULL); | |
234 | nfs_destroy_context(client->context); | |
235 | } | |
236 | memset(client, 0, sizeof(NFSClient)); | |
237 | } | |
238 | ||
239 | static void nfs_file_close(BlockDriverState *bs) | |
240 | { | |
241 | NFSClient *client = bs->opaque; | |
242 | nfs_client_close(client); | |
243 | } | |
244 | ||
245 | static int64_t nfs_client_open(NFSClient *client, const char *filename, | |
246 | int flags, Error **errp) | |
247 | { | |
248 | int ret = -EINVAL, i; | |
249 | struct stat st; | |
250 | URI *uri; | |
251 | QueryParams *qp = NULL; | |
252 | char *file = NULL, *strp = NULL; | |
253 | ||
254 | uri = uri_parse(filename); | |
255 | if (!uri) { | |
256 | error_setg(errp, "Invalid URL specified"); | |
257 | goto fail; | |
258 | } | |
259 | strp = strrchr(uri->path, '/'); | |
260 | if (strp == NULL) { | |
261 | error_setg(errp, "Invalid URL specified"); | |
262 | goto fail; | |
263 | } | |
264 | file = g_strdup(strp); | |
265 | *strp = 0; | |
266 | ||
267 | client->context = nfs_init_context(); | |
268 | if (client->context == NULL) { | |
269 | error_setg(errp, "Failed to init NFS context"); | |
270 | goto fail; | |
271 | } | |
272 | ||
273 | qp = query_params_parse(uri->query); | |
274 | for (i = 0; i < qp->n; i++) { | |
275 | if (!qp->p[i].value) { | |
276 | error_setg(errp, "Value for NFS parameter expected: %s", | |
277 | qp->p[i].name); | |
278 | goto fail; | |
279 | } | |
280 | if (!strncmp(qp->p[i].name, "uid", 3)) { | |
281 | nfs_set_uid(client->context, atoi(qp->p[i].value)); | |
282 | } else if (!strncmp(qp->p[i].name, "gid", 3)) { | |
283 | nfs_set_gid(client->context, atoi(qp->p[i].value)); | |
284 | } else if (!strncmp(qp->p[i].name, "tcp-syncnt", 10)) { | |
285 | nfs_set_tcp_syncnt(client->context, atoi(qp->p[i].value)); | |
286 | } else { | |
287 | error_setg(errp, "Unknown NFS parameter name: %s", | |
288 | qp->p[i].name); | |
289 | goto fail; | |
290 | } | |
291 | } | |
292 | ||
293 | ret = nfs_mount(client->context, uri->server, uri->path); | |
294 | if (ret < 0) { | |
295 | error_setg(errp, "Failed to mount nfs share: %s", | |
296 | nfs_get_error(client->context)); | |
297 | goto fail; | |
298 | } | |
299 | ||
300 | if (flags & O_CREAT) { | |
301 | ret = nfs_creat(client->context, file, 0600, &client->fh); | |
302 | if (ret < 0) { | |
303 | error_setg(errp, "Failed to create file: %s", | |
304 | nfs_get_error(client->context)); | |
305 | goto fail; | |
306 | } | |
307 | } else { | |
308 | ret = nfs_open(client->context, file, flags, &client->fh); | |
309 | if (ret < 0) { | |
310 | error_setg(errp, "Failed to open file : %s", | |
311 | nfs_get_error(client->context)); | |
312 | goto fail; | |
313 | } | |
314 | } | |
315 | ||
316 | ret = nfs_fstat(client->context, client->fh, &st); | |
317 | if (ret < 0) { | |
318 | error_setg(errp, "Failed to fstat file: %s", | |
319 | nfs_get_error(client->context)); | |
320 | goto fail; | |
321 | } | |
322 | ||
323 | ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE); | |
324 | client->has_zero_init = S_ISREG(st.st_mode); | |
325 | goto out; | |
326 | fail: | |
327 | nfs_client_close(client); | |
328 | out: | |
329 | if (qp) { | |
330 | query_params_free(qp); | |
331 | } | |
332 | uri_free(uri); | |
333 | g_free(file); | |
334 | return ret; | |
335 | } | |
336 | ||
337 | static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, | |
338 | Error **errp) { | |
339 | NFSClient *client = bs->opaque; | |
340 | int64_t ret; | |
341 | QemuOpts *opts; | |
342 | Error *local_err = NULL; | |
343 | ||
344 | opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); | |
345 | qemu_opts_absorb_qdict(opts, options, &local_err); | |
0fb6395c | 346 | if (local_err) { |
6542aa9c PL |
347 | error_propagate(errp, local_err); |
348 | return -EINVAL; | |
349 | } | |
350 | ret = nfs_client_open(client, qemu_opt_get(opts, "filename"), | |
351 | (flags & BDRV_O_RDWR) ? O_RDWR : O_RDONLY, | |
352 | errp); | |
353 | if (ret < 0) { | |
354 | return ret; | |
355 | } | |
356 | bs->total_sectors = ret; | |
357 | return 0; | |
358 | } | |
359 | ||
360 | static int nfs_file_create(const char *url, QEMUOptionParameter *options, | |
361 | Error **errp) | |
362 | { | |
363 | int ret = 0; | |
364 | int64_t total_size = 0; | |
365 | NFSClient *client = g_malloc0(sizeof(NFSClient)); | |
366 | ||
367 | /* Read out options */ | |
368 | while (options && options->name) { | |
369 | if (!strcmp(options->name, "size")) { | |
370 | total_size = options->value.n; | |
371 | } | |
372 | options++; | |
373 | } | |
374 | ||
375 | ret = nfs_client_open(client, url, O_CREAT, errp); | |
376 | if (ret < 0) { | |
377 | goto out; | |
378 | } | |
379 | ret = nfs_ftruncate(client->context, client->fh, total_size); | |
380 | nfs_client_close(client); | |
381 | out: | |
382 | g_free(client); | |
383 | return ret; | |
384 | } | |
385 | ||
386 | static int nfs_has_zero_init(BlockDriverState *bs) | |
387 | { | |
388 | NFSClient *client = bs->opaque; | |
389 | return client->has_zero_init; | |
390 | } | |
391 | ||
392 | static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) | |
393 | { | |
394 | NFSClient *client = bs->opaque; | |
395 | NFSRPC task = {0}; | |
396 | struct stat st; | |
397 | ||
398 | task.st = &st; | |
399 | if (nfs_fstat_async(client->context, client->fh, nfs_co_generic_cb, | |
400 | &task) != 0) { | |
401 | return -ENOMEM; | |
402 | } | |
403 | ||
404 | while (!task.complete) { | |
405 | nfs_set_events(client); | |
406 | qemu_aio_wait(); | |
407 | } | |
408 | ||
409 | return (task.ret < 0 ? task.ret : st.st_blocks * st.st_blksize); | |
410 | } | |
411 | ||
412 | static int nfs_file_truncate(BlockDriverState *bs, int64_t offset) | |
413 | { | |
414 | NFSClient *client = bs->opaque; | |
415 | return nfs_ftruncate(client->context, client->fh, offset); | |
416 | } | |
417 | ||
418 | static BlockDriver bdrv_nfs = { | |
419 | .format_name = "nfs", | |
420 | .protocol_name = "nfs", | |
421 | ||
422 | .instance_size = sizeof(NFSClient), | |
423 | .bdrv_needs_filename = true, | |
424 | .bdrv_has_zero_init = nfs_has_zero_init, | |
425 | .bdrv_get_allocated_file_size = nfs_get_allocated_file_size, | |
426 | .bdrv_truncate = nfs_file_truncate, | |
427 | ||
428 | .bdrv_file_open = nfs_file_open, | |
429 | .bdrv_close = nfs_file_close, | |
430 | .bdrv_create = nfs_file_create, | |
431 | ||
432 | .bdrv_co_readv = nfs_co_readv, | |
433 | .bdrv_co_writev = nfs_co_writev, | |
434 | .bdrv_co_flush_to_disk = nfs_co_flush, | |
435 | }; | |
436 | ||
437 | static void nfs_block_init(void) | |
438 | { | |
439 | bdrv_register(&bdrv_nfs); | |
440 | } | |
441 | ||
442 | block_init(nfs_block_init); |