meson: convert qapi-specific to meson
[qemu.git] / hw / 9pfs / 9p-proxy.c
1 /*
2 * 9p Proxy callback
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * M. Mohan Kumar <mohan@in.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 */
12
13 #include "qemu/osdep.h"
14 #include <sys/socket.h>
15 #include <sys/un.h>
16 #include "qemu-common.h"
17 #include "9p.h"
18 #include "qapi/error.h"
19 #include "qemu/cutils.h"
20 #include "qemu/error-report.h"
21 #include "qemu/option.h"
22 #include "fsdev/qemu-fsdev.h"
23 #include "9p-proxy.h"
24
25 typedef struct V9fsProxy {
26 int sockfd;
27 QemuMutex mutex;
28 struct iovec in_iovec;
29 struct iovec out_iovec;
30 } V9fsProxy;
31
32 /*
33 * Return received file descriptor on success in *status.
34 * errno is also returned on *status (which will be < 0)
35 * return < 0 on transport error.
36 */
37 static int v9fs_receivefd(int sockfd, int *status)
38 {
39 struct iovec iov;
40 struct msghdr msg;
41 struct cmsghdr *cmsg;
42 int retval, data, fd;
43 union MsgControl msg_control;
44
45 iov.iov_base = &data;
46 iov.iov_len = sizeof(data);
47
48 memset(&msg, 0, sizeof(msg));
49 msg.msg_iov = &iov;
50 msg.msg_iovlen = 1;
51 msg.msg_control = &msg_control;
52 msg.msg_controllen = sizeof(msg_control);
53
54 do {
55 retval = recvmsg(sockfd, &msg, 0);
56 } while (retval < 0 && errno == EINTR);
57 if (retval <= 0) {
58 return retval;
59 }
60 /*
61 * data is set to V9FS_FD_VALID, if ancillary data is sent. If this
62 * request doesn't need ancillary data (fd) or an error occurred,
63 * data is set to negative errno value.
64 */
65 if (data != V9FS_FD_VALID) {
66 *status = data;
67 return 0;
68 }
69 /*
70 * File descriptor (fd) is sent in the ancillary data. Check if we
71 * indeed received it. One of the reasons to fail to receive it is if
72 * we exceeded the maximum number of file descriptors!
73 */
74 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
75 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
76 cmsg->cmsg_level != SOL_SOCKET ||
77 cmsg->cmsg_type != SCM_RIGHTS) {
78 continue;
79 }
80 fd = *((int *)CMSG_DATA(cmsg));
81 *status = fd;
82 return 0;
83 }
84 *status = -ENFILE; /* Ancillary data sent but not received */
85 return 0;
86 }
87
88 static ssize_t socket_read(int sockfd, void *buff, size_t size)
89 {
90 ssize_t retval, total = 0;
91
92 while (size) {
93 retval = read(sockfd, buff, size);
94 if (retval == 0) {
95 return -EIO;
96 }
97 if (retval < 0) {
98 if (errno == EINTR) {
99 continue;
100 }
101 return -errno;
102 }
103 size -= retval;
104 buff += retval;
105 total += retval;
106 }
107 return total;
108 }
109
110 /* Converts proxy_statfs to VFS statfs structure */
111 static void prstatfs_to_statfs(struct statfs *stfs, ProxyStatFS *prstfs)
112 {
113 memset(stfs, 0, sizeof(*stfs));
114 stfs->f_type = prstfs->f_type;
115 stfs->f_bsize = prstfs->f_bsize;
116 stfs->f_blocks = prstfs->f_blocks;
117 stfs->f_bfree = prstfs->f_bfree;
118 stfs->f_bavail = prstfs->f_bavail;
119 stfs->f_files = prstfs->f_files;
120 stfs->f_ffree = prstfs->f_ffree;
121 stfs->f_fsid.__val[0] = prstfs->f_fsid[0] & 0xFFFFFFFFU;
122 stfs->f_fsid.__val[1] = prstfs->f_fsid[1] >> 32 & 0xFFFFFFFFU;
123 stfs->f_namelen = prstfs->f_namelen;
124 stfs->f_frsize = prstfs->f_frsize;
125 }
126
127 /* Converts proxy_stat structure to VFS stat structure */
128 static void prstat_to_stat(struct stat *stbuf, ProxyStat *prstat)
129 {
130 memset(stbuf, 0, sizeof(*stbuf));
131 stbuf->st_dev = prstat->st_dev;
132 stbuf->st_ino = prstat->st_ino;
133 stbuf->st_nlink = prstat->st_nlink;
134 stbuf->st_mode = prstat->st_mode;
135 stbuf->st_uid = prstat->st_uid;
136 stbuf->st_gid = prstat->st_gid;
137 stbuf->st_rdev = prstat->st_rdev;
138 stbuf->st_size = prstat->st_size;
139 stbuf->st_blksize = prstat->st_blksize;
140 stbuf->st_blocks = prstat->st_blocks;
141 stbuf->st_atim.tv_sec = prstat->st_atim_sec;
142 stbuf->st_atim.tv_nsec = prstat->st_atim_nsec;
143 stbuf->st_mtime = prstat->st_mtim_sec;
144 stbuf->st_mtim.tv_nsec = prstat->st_mtim_nsec;
145 stbuf->st_ctime = prstat->st_ctim_sec;
146 stbuf->st_ctim.tv_nsec = prstat->st_ctim_nsec;
147 }
148
149 /*
150 * Response contains two parts
151 * {header, data}
152 * header.type == T_ERROR, data -> -errno
153 * header.type == T_SUCCESS, data -> response
154 * size of errno/response is given by header.size
155 * returns < 0, on transport error. response is
156 * valid only if status >= 0.
157 */
158 static int v9fs_receive_response(V9fsProxy *proxy, int type,
159 int *status, void *response)
160 {
161 int retval;
162 ProxyHeader header;
163 struct iovec *reply = &proxy->in_iovec;
164
165 *status = 0;
166 reply->iov_len = 0;
167 retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ);
168 if (retval < 0) {
169 return retval;
170 }
171 reply->iov_len = PROXY_HDR_SZ;
172 retval = proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
173 assert(retval == 4 * 2);
174 /*
175 * if response size > PROXY_MAX_IO_SZ, read the response but ignore it and
176 * return -ENOBUFS
177 */
178 if (header.size > PROXY_MAX_IO_SZ) {
179 int count;
180 while (header.size > 0) {
181 count = MIN(PROXY_MAX_IO_SZ, header.size);
182 count = socket_read(proxy->sockfd, reply->iov_base, count);
183 if (count < 0) {
184 return count;
185 }
186 header.size -= count;
187 }
188 *status = -ENOBUFS;
189 return 0;
190 }
191
192 retval = socket_read(proxy->sockfd,
193 reply->iov_base + PROXY_HDR_SZ, header.size);
194 if (retval < 0) {
195 return retval;
196 }
197 reply->iov_len += header.size;
198 /* there was an error during processing request */
199 if (header.type == T_ERROR) {
200 int ret;
201 ret = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
202 assert(ret == 4);
203 return 0;
204 }
205
206 switch (type) {
207 case T_LSTAT: {
208 ProxyStat prstat;
209 retval = proxy_unmarshal(reply, PROXY_HDR_SZ,
210 "qqqdddqqqqqqqqqq", &prstat.st_dev,
211 &prstat.st_ino, &prstat.st_nlink,
212 &prstat.st_mode, &prstat.st_uid,
213 &prstat.st_gid, &prstat.st_rdev,
214 &prstat.st_size, &prstat.st_blksize,
215 &prstat.st_blocks,
216 &prstat.st_atim_sec, &prstat.st_atim_nsec,
217 &prstat.st_mtim_sec, &prstat.st_mtim_nsec,
218 &prstat.st_ctim_sec, &prstat.st_ctim_nsec);
219 assert(retval == 8 * 3 + 4 * 3 + 8 * 10);
220 prstat_to_stat(response, &prstat);
221 break;
222 }
223 case T_STATFS: {
224 ProxyStatFS prstfs;
225 retval = proxy_unmarshal(reply, PROXY_HDR_SZ,
226 "qqqqqqqqqqq", &prstfs.f_type,
227 &prstfs.f_bsize, &prstfs.f_blocks,
228 &prstfs.f_bfree, &prstfs.f_bavail,
229 &prstfs.f_files, &prstfs.f_ffree,
230 &prstfs.f_fsid[0], &prstfs.f_fsid[1],
231 &prstfs.f_namelen, &prstfs.f_frsize);
232 assert(retval == 8 * 11);
233 prstatfs_to_statfs(response, &prstfs);
234 break;
235 }
236 case T_READLINK: {
237 V9fsString target;
238 v9fs_string_init(&target);
239 retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "s", &target);
240 strcpy(response, target.data);
241 v9fs_string_free(&target);
242 break;
243 }
244 case T_LGETXATTR:
245 case T_LLISTXATTR: {
246 V9fsString xattr;
247 v9fs_string_init(&xattr);
248 retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "s", &xattr);
249 memcpy(response, xattr.data, xattr.size);
250 v9fs_string_free(&xattr);
251 break;
252 }
253 case T_GETVERSION:
254 retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "q", response);
255 assert(retval == 8);
256 break;
257 default:
258 return -1;
259 }
260 if (retval < 0) {
261 *status = retval;
262 }
263 return 0;
264 }
265
266 /*
267 * return < 0 on transport error.
268 * *status is valid only if return >= 0
269 */
270 static int v9fs_receive_status(V9fsProxy *proxy,
271 struct iovec *reply, int *status)
272 {
273 int retval;
274 ProxyHeader header;
275
276 *status = 0;
277 reply->iov_len = 0;
278 retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ);
279 if (retval < 0) {
280 return retval;
281 }
282 reply->iov_len = PROXY_HDR_SZ;
283 retval = proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
284 assert(retval == 4 * 2);
285 retval = socket_read(proxy->sockfd,
286 reply->iov_base + PROXY_HDR_SZ, header.size);
287 if (retval < 0) {
288 return retval;
289 }
290 reply->iov_len += header.size;
291 retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
292 assert(retval == 4);
293 return 0;
294 }
295
296 /*
297 * Proxy->header and proxy->request written to socket by QEMU process.
298 * This request read by proxy helper process
299 * returns 0 on success and -errno on error
300 */
301 static int v9fs_request(V9fsProxy *proxy, int type, void *response, ...)
302 {
303 dev_t rdev;
304 va_list ap;
305 int size = 0;
306 int retval = 0;
307 uint64_t offset;
308 ProxyHeader header = { 0, 0};
309 struct timespec spec[2];
310 int flags, mode, uid, gid;
311 V9fsString *name, *value;
312 V9fsString *path, *oldpath;
313 struct iovec *iovec = NULL, *reply = NULL;
314
315 qemu_mutex_lock(&proxy->mutex);
316
317 if (proxy->sockfd == -1) {
318 retval = -EIO;
319 goto err_out;
320 }
321 iovec = &proxy->out_iovec;
322 reply = &proxy->in_iovec;
323 va_start(ap, response);
324 switch (type) {
325 case T_OPEN:
326 path = va_arg(ap, V9fsString *);
327 flags = va_arg(ap, int);
328 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, flags);
329 if (retval > 0) {
330 header.size = retval;
331 header.type = T_OPEN;
332 }
333 break;
334 case T_CREATE:
335 path = va_arg(ap, V9fsString *);
336 flags = va_arg(ap, int);
337 mode = va_arg(ap, int);
338 uid = va_arg(ap, int);
339 gid = va_arg(ap, int);
340 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sdddd", path,
341 flags, mode, uid, gid);
342 if (retval > 0) {
343 header.size = retval;
344 header.type = T_CREATE;
345 }
346 break;
347 case T_MKNOD:
348 path = va_arg(ap, V9fsString *);
349 mode = va_arg(ap, int);
350 rdev = va_arg(ap, long int);
351 uid = va_arg(ap, int);
352 gid = va_arg(ap, int);
353 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddsdq",
354 uid, gid, path, mode, rdev);
355 if (retval > 0) {
356 header.size = retval;
357 header.type = T_MKNOD;
358 }
359 break;
360 case T_MKDIR:
361 path = va_arg(ap, V9fsString *);
362 mode = va_arg(ap, int);
363 uid = va_arg(ap, int);
364 gid = va_arg(ap, int);
365 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddsd",
366 uid, gid, path, mode);
367 if (retval > 0) {
368 header.size = retval;
369 header.type = T_MKDIR;
370 }
371 break;
372 case T_SYMLINK:
373 oldpath = va_arg(ap, V9fsString *);
374 path = va_arg(ap, V9fsString *);
375 uid = va_arg(ap, int);
376 gid = va_arg(ap, int);
377 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddss",
378 uid, gid, oldpath, path);
379 if (retval > 0) {
380 header.size = retval;
381 header.type = T_SYMLINK;
382 }
383 break;
384 case T_LINK:
385 oldpath = va_arg(ap, V9fsString *);
386 path = va_arg(ap, V9fsString *);
387 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss",
388 oldpath, path);
389 if (retval > 0) {
390 header.size = retval;
391 header.type = T_LINK;
392 }
393 break;
394 case T_LSTAT:
395 path = va_arg(ap, V9fsString *);
396 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
397 if (retval > 0) {
398 header.size = retval;
399 header.type = T_LSTAT;
400 }
401 break;
402 case T_READLINK:
403 path = va_arg(ap, V9fsString *);
404 size = va_arg(ap, int);
405 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, size);
406 if (retval > 0) {
407 header.size = retval;
408 header.type = T_READLINK;
409 }
410 break;
411 case T_STATFS:
412 path = va_arg(ap, V9fsString *);
413 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
414 if (retval > 0) {
415 header.size = retval;
416 header.type = T_STATFS;
417 }
418 break;
419 case T_CHMOD:
420 path = va_arg(ap, V9fsString *);
421 mode = va_arg(ap, int);
422 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, mode);
423 if (retval > 0) {
424 header.size = retval;
425 header.type = T_CHMOD;
426 }
427 break;
428 case T_CHOWN:
429 path = va_arg(ap, V9fsString *);
430 uid = va_arg(ap, int);
431 gid = va_arg(ap, int);
432 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sdd", path, uid, gid);
433 if (retval > 0) {
434 header.size = retval;
435 header.type = T_CHOWN;
436 }
437 break;
438 case T_TRUNCATE:
439 path = va_arg(ap, V9fsString *);
440 offset = va_arg(ap, uint64_t);
441 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sq", path, offset);
442 if (retval > 0) {
443 header.size = retval;
444 header.type = T_TRUNCATE;
445 }
446 break;
447 case T_UTIME:
448 path = va_arg(ap, V9fsString *);
449 spec[0].tv_sec = va_arg(ap, long);
450 spec[0].tv_nsec = va_arg(ap, long);
451 spec[1].tv_sec = va_arg(ap, long);
452 spec[1].tv_nsec = va_arg(ap, long);
453 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sqqqq", path,
454 spec[0].tv_sec, spec[1].tv_nsec,
455 spec[1].tv_sec, spec[1].tv_nsec);
456 if (retval > 0) {
457 header.size = retval;
458 header.type = T_UTIME;
459 }
460 break;
461 case T_RENAME:
462 oldpath = va_arg(ap, V9fsString *);
463 path = va_arg(ap, V9fsString *);
464 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", oldpath, path);
465 if (retval > 0) {
466 header.size = retval;
467 header.type = T_RENAME;
468 }
469 break;
470 case T_REMOVE:
471 path = va_arg(ap, V9fsString *);
472 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
473 if (retval > 0) {
474 header.size = retval;
475 header.type = T_REMOVE;
476 }
477 break;
478 case T_LGETXATTR:
479 size = va_arg(ap, int);
480 path = va_arg(ap, V9fsString *);
481 name = va_arg(ap, V9fsString *);
482 retval = proxy_marshal(iovec, PROXY_HDR_SZ,
483 "dss", size, path, name);
484 if (retval > 0) {
485 header.size = retval;
486 header.type = T_LGETXATTR;
487 }
488 break;
489 case T_LLISTXATTR:
490 size = va_arg(ap, int);
491 path = va_arg(ap, V9fsString *);
492 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ds", size, path);
493 if (retval > 0) {
494 header.size = retval;
495 header.type = T_LLISTXATTR;
496 }
497 break;
498 case T_LSETXATTR:
499 path = va_arg(ap, V9fsString *);
500 name = va_arg(ap, V9fsString *);
501 value = va_arg(ap, V9fsString *);
502 size = va_arg(ap, int);
503 flags = va_arg(ap, int);
504 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sssdd",
505 path, name, value, size, flags);
506 if (retval > 0) {
507 header.size = retval;
508 header.type = T_LSETXATTR;
509 }
510 break;
511 case T_LREMOVEXATTR:
512 path = va_arg(ap, V9fsString *);
513 name = va_arg(ap, V9fsString *);
514 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", path, name);
515 if (retval > 0) {
516 header.size = retval;
517 header.type = T_LREMOVEXATTR;
518 }
519 break;
520 case T_GETVERSION:
521 path = va_arg(ap, V9fsString *);
522 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
523 if (retval > 0) {
524 header.size = retval;
525 header.type = T_GETVERSION;
526 }
527 break;
528 default:
529 error_report("Invalid type %d", type);
530 retval = -EINVAL;
531 break;
532 }
533 va_end(ap);
534
535 if (retval < 0) {
536 goto err_out;
537 }
538
539 /* marshal the header details */
540 proxy_marshal(iovec, 0, "dd", header.type, header.size);
541 header.size += PROXY_HDR_SZ;
542
543 retval = qemu_write_full(proxy->sockfd, iovec->iov_base, header.size);
544 if (retval != header.size) {
545 goto close_error;
546 }
547
548 switch (type) {
549 case T_OPEN:
550 case T_CREATE:
551 /*
552 * A file descriptor is returned as response for
553 * T_OPEN,T_CREATE on success
554 */
555 if (v9fs_receivefd(proxy->sockfd, &retval) < 0) {
556 goto close_error;
557 }
558 break;
559 case T_MKNOD:
560 case T_MKDIR:
561 case T_SYMLINK:
562 case T_LINK:
563 case T_CHMOD:
564 case T_CHOWN:
565 case T_RENAME:
566 case T_TRUNCATE:
567 case T_UTIME:
568 case T_REMOVE:
569 case T_LSETXATTR:
570 case T_LREMOVEXATTR:
571 if (v9fs_receive_status(proxy, reply, &retval) < 0) {
572 goto close_error;
573 }
574 break;
575 case T_LSTAT:
576 case T_READLINK:
577 case T_STATFS:
578 case T_GETVERSION:
579 if (v9fs_receive_response(proxy, type, &retval, response) < 0) {
580 goto close_error;
581 }
582 break;
583 case T_LGETXATTR:
584 case T_LLISTXATTR:
585 if (!size) {
586 if (v9fs_receive_status(proxy, reply, &retval) < 0) {
587 goto close_error;
588 }
589 } else {
590 if (v9fs_receive_response(proxy, type, &retval, response) < 0) {
591 goto close_error;
592 }
593 }
594 break;
595 }
596
597 err_out:
598 qemu_mutex_unlock(&proxy->mutex);
599 return retval;
600
601 close_error:
602 close(proxy->sockfd);
603 proxy->sockfd = -1;
604 qemu_mutex_unlock(&proxy->mutex);
605 return -EIO;
606 }
607
608 static int proxy_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
609 {
610 int retval;
611 retval = v9fs_request(fs_ctx->private, T_LSTAT, stbuf, fs_path);
612 if (retval < 0) {
613 errno = -retval;
614 return -1;
615 }
616 return retval;
617 }
618
619 static ssize_t proxy_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
620 char *buf, size_t bufsz)
621 {
622 int retval;
623 retval = v9fs_request(fs_ctx->private, T_READLINK, buf, fs_path, bufsz);
624 if (retval < 0) {
625 errno = -retval;
626 return -1;
627 }
628 return strlen(buf);
629 }
630
631 static int proxy_close(FsContext *ctx, V9fsFidOpenState *fs)
632 {
633 return close(fs->fd);
634 }
635
636 static int proxy_closedir(FsContext *ctx, V9fsFidOpenState *fs)
637 {
638 return closedir(fs->dir.stream);
639 }
640
641 static int proxy_open(FsContext *ctx, V9fsPath *fs_path,
642 int flags, V9fsFidOpenState *fs)
643 {
644 fs->fd = v9fs_request(ctx->private, T_OPEN, NULL, fs_path, flags);
645 if (fs->fd < 0) {
646 errno = -fs->fd;
647 fs->fd = -1;
648 }
649 return fs->fd;
650 }
651
652 static int proxy_opendir(FsContext *ctx,
653 V9fsPath *fs_path, V9fsFidOpenState *fs)
654 {
655 int serrno, fd;
656
657 fs->dir.stream = NULL;
658 fd = v9fs_request(ctx->private, T_OPEN, NULL, fs_path, O_DIRECTORY);
659 if (fd < 0) {
660 errno = -fd;
661 return -1;
662 }
663 fs->dir.stream = fdopendir(fd);
664 if (!fs->dir.stream) {
665 serrno = errno;
666 close(fd);
667 errno = serrno;
668 return -1;
669 }
670 return 0;
671 }
672
673 static void proxy_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
674 {
675 rewinddir(fs->dir.stream);
676 }
677
678 static off_t proxy_telldir(FsContext *ctx, V9fsFidOpenState *fs)
679 {
680 return telldir(fs->dir.stream);
681 }
682
683 static struct dirent *proxy_readdir(FsContext *ctx, V9fsFidOpenState *fs)
684 {
685 return readdir(fs->dir.stream);
686 }
687
688 static void proxy_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
689 {
690 seekdir(fs->dir.stream, off);
691 }
692
693 static ssize_t proxy_preadv(FsContext *ctx, V9fsFidOpenState *fs,
694 const struct iovec *iov,
695 int iovcnt, off_t offset)
696 {
697 ssize_t ret;
698 #ifdef CONFIG_PREADV
699 ret = preadv(fs->fd, iov, iovcnt, offset);
700 #else
701 ret = lseek(fs->fd, offset, SEEK_SET);
702 if (ret >= 0) {
703 ret = readv(fs->fd, iov, iovcnt);
704 }
705 #endif
706 return ret;
707 }
708
709 static ssize_t proxy_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
710 const struct iovec *iov,
711 int iovcnt, off_t offset)
712 {
713 ssize_t ret;
714
715 #ifdef CONFIG_PREADV
716 ret = pwritev(fs->fd, iov, iovcnt, offset);
717 #else
718 ret = lseek(fs->fd, offset, SEEK_SET);
719 if (ret >= 0) {
720 ret = writev(fs->fd, iov, iovcnt);
721 }
722 #endif
723 #ifdef CONFIG_SYNC_FILE_RANGE
724 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
725 /*
726 * Initiate a writeback. This is not a data integrity sync.
727 * We want to ensure that we don't leave dirty pages in the cache
728 * after write when writeout=immediate is sepcified.
729 */
730 sync_file_range(fs->fd, offset, ret,
731 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
732 }
733 #endif
734 return ret;
735 }
736
737 static int proxy_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
738 {
739 int retval;
740 retval = v9fs_request(fs_ctx->private, T_CHMOD, NULL, fs_path,
741 credp->fc_mode);
742 if (retval < 0) {
743 errno = -retval;
744 }
745 return retval;
746 }
747
748 static int proxy_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
749 const char *name, FsCred *credp)
750 {
751 int retval;
752 V9fsString fullname;
753
754 v9fs_string_init(&fullname);
755 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
756
757 retval = v9fs_request(fs_ctx->private, T_MKNOD, NULL, &fullname,
758 credp->fc_mode, credp->fc_rdev,
759 credp->fc_uid, credp->fc_gid);
760 v9fs_string_free(&fullname);
761 if (retval < 0) {
762 errno = -retval;
763 retval = -1;
764 }
765 return retval;
766 }
767
768 static int proxy_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
769 const char *name, FsCred *credp)
770 {
771 int retval;
772 V9fsString fullname;
773
774 v9fs_string_init(&fullname);
775 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
776
777 retval = v9fs_request(fs_ctx->private, T_MKDIR, NULL, &fullname,
778 credp->fc_mode, credp->fc_uid, credp->fc_gid);
779 v9fs_string_free(&fullname);
780 if (retval < 0) {
781 errno = -retval;
782 retval = -1;
783 }
784 return retval;
785 }
786
787 static int proxy_fstat(FsContext *fs_ctx, int fid_type,
788 V9fsFidOpenState *fs, struct stat *stbuf)
789 {
790 int fd;
791
792 if (fid_type == P9_FID_DIR) {
793 fd = dirfd(fs->dir.stream);
794 } else {
795 fd = fs->fd;
796 }
797 return fstat(fd, stbuf);
798 }
799
800 static int proxy_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
801 int flags, FsCred *credp, V9fsFidOpenState *fs)
802 {
803 V9fsString fullname;
804
805 v9fs_string_init(&fullname);
806 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
807
808 fs->fd = v9fs_request(fs_ctx->private, T_CREATE, NULL, &fullname, flags,
809 credp->fc_mode, credp->fc_uid, credp->fc_gid);
810 v9fs_string_free(&fullname);
811 if (fs->fd < 0) {
812 errno = -fs->fd;
813 fs->fd = -1;
814 }
815 return fs->fd;
816 }
817
818 static int proxy_symlink(FsContext *fs_ctx, const char *oldpath,
819 V9fsPath *dir_path, const char *name, FsCred *credp)
820 {
821 int retval;
822 V9fsString fullname, target;
823
824 v9fs_string_init(&fullname);
825 v9fs_string_init(&target);
826
827 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
828 v9fs_string_sprintf(&target, "%s", oldpath);
829
830 retval = v9fs_request(fs_ctx->private, T_SYMLINK, NULL, &target, &fullname,
831 credp->fc_uid, credp->fc_gid);
832 v9fs_string_free(&fullname);
833 v9fs_string_free(&target);
834 if (retval < 0) {
835 errno = -retval;
836 retval = -1;
837 }
838 return retval;
839 }
840
841 static int proxy_link(FsContext *ctx, V9fsPath *oldpath,
842 V9fsPath *dirpath, const char *name)
843 {
844 int retval;
845 V9fsString newpath;
846
847 v9fs_string_init(&newpath);
848 v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name);
849
850 retval = v9fs_request(ctx->private, T_LINK, NULL, oldpath, &newpath);
851 v9fs_string_free(&newpath);
852 if (retval < 0) {
853 errno = -retval;
854 retval = -1;
855 }
856 return retval;
857 }
858
859 static int proxy_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
860 {
861 int retval;
862
863 retval = v9fs_request(ctx->private, T_TRUNCATE, NULL, fs_path, size);
864 if (retval < 0) {
865 errno = -retval;
866 return -1;
867 }
868 return 0;
869 }
870
871 static int proxy_rename(FsContext *ctx, const char *oldpath,
872 const char *newpath)
873 {
874 int retval;
875 V9fsString oldname, newname;
876
877 v9fs_string_init(&oldname);
878 v9fs_string_init(&newname);
879
880 v9fs_string_sprintf(&oldname, "%s", oldpath);
881 v9fs_string_sprintf(&newname, "%s", newpath);
882 retval = v9fs_request(ctx->private, T_RENAME, NULL, &oldname, &newname);
883 v9fs_string_free(&oldname);
884 v9fs_string_free(&newname);
885 if (retval < 0) {
886 errno = -retval;
887 }
888 return retval;
889 }
890
891 static int proxy_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
892 {
893 int retval;
894 retval = v9fs_request(fs_ctx->private, T_CHOWN, NULL, fs_path,
895 credp->fc_uid, credp->fc_gid);
896 if (retval < 0) {
897 errno = -retval;
898 }
899 return retval;
900 }
901
902 static int proxy_utimensat(FsContext *s, V9fsPath *fs_path,
903 const struct timespec *buf)
904 {
905 int retval;
906 retval = v9fs_request(s->private, T_UTIME, NULL, fs_path,
907 buf[0].tv_sec, buf[0].tv_nsec,
908 buf[1].tv_sec, buf[1].tv_nsec);
909 if (retval < 0) {
910 errno = -retval;
911 }
912 return retval;
913 }
914
915 static int proxy_remove(FsContext *ctx, const char *path)
916 {
917 int retval;
918 V9fsString name;
919 v9fs_string_init(&name);
920 v9fs_string_sprintf(&name, "%s", path);
921 retval = v9fs_request(ctx->private, T_REMOVE, NULL, &name);
922 v9fs_string_free(&name);
923 if (retval < 0) {
924 errno = -retval;
925 }
926 return retval;
927 }
928
929 static int proxy_fsync(FsContext *ctx, int fid_type,
930 V9fsFidOpenState *fs, int datasync)
931 {
932 int fd;
933
934 if (fid_type == P9_FID_DIR) {
935 fd = dirfd(fs->dir.stream);
936 } else {
937 fd = fs->fd;
938 }
939
940 if (datasync) {
941 return qemu_fdatasync(fd);
942 } else {
943 return fsync(fd);
944 }
945 }
946
947 static int proxy_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
948 {
949 int retval;
950 retval = v9fs_request(s->private, T_STATFS, stbuf, fs_path);
951 if (retval < 0) {
952 errno = -retval;
953 return -1;
954 }
955 return retval;
956 }
957
958 static ssize_t proxy_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
959 const char *name, void *value, size_t size)
960 {
961 int retval;
962 V9fsString xname;
963
964 v9fs_string_init(&xname);
965 v9fs_string_sprintf(&xname, "%s", name);
966 retval = v9fs_request(ctx->private, T_LGETXATTR, value, size, fs_path,
967 &xname);
968 v9fs_string_free(&xname);
969 if (retval < 0) {
970 errno = -retval;
971 }
972 return retval;
973 }
974
975 static ssize_t proxy_llistxattr(FsContext *ctx, V9fsPath *fs_path,
976 void *value, size_t size)
977 {
978 int retval;
979 retval = v9fs_request(ctx->private, T_LLISTXATTR, value, size, fs_path);
980 if (retval < 0) {
981 errno = -retval;
982 }
983 return retval;
984 }
985
986 static int proxy_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
987 void *value, size_t size, int flags)
988 {
989 int retval;
990 V9fsString xname, xvalue;
991
992 v9fs_string_init(&xname);
993 v9fs_string_sprintf(&xname, "%s", name);
994
995 v9fs_string_init(&xvalue);
996 xvalue.size = size;
997 xvalue.data = g_malloc(size);
998 memcpy(xvalue.data, value, size);
999
1000 retval = v9fs_request(ctx->private, T_LSETXATTR, value, fs_path, &xname,
1001 &xvalue, size, flags);
1002 v9fs_string_free(&xname);
1003 v9fs_string_free(&xvalue);
1004 if (retval < 0) {
1005 errno = -retval;
1006 }
1007 return retval;
1008 }
1009
1010 static int proxy_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1011 const char *name)
1012 {
1013 int retval;
1014 V9fsString xname;
1015
1016 v9fs_string_init(&xname);
1017 v9fs_string_sprintf(&xname, "%s", name);
1018 retval = v9fs_request(ctx->private, T_LREMOVEXATTR, NULL, fs_path, &xname);
1019 v9fs_string_free(&xname);
1020 if (retval < 0) {
1021 errno = -retval;
1022 }
1023 return retval;
1024 }
1025
1026 static int proxy_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1027 const char *name, V9fsPath *target)
1028 {
1029 if (dir_path) {
1030 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name);
1031 } else {
1032 v9fs_path_sprintf(target, "%s", name);
1033 }
1034 return 0;
1035 }
1036
1037 static int proxy_renameat(FsContext *ctx, V9fsPath *olddir,
1038 const char *old_name, V9fsPath *newdir,
1039 const char *new_name)
1040 {
1041 int ret;
1042 V9fsString old_full_name, new_full_name;
1043
1044 v9fs_string_init(&old_full_name);
1045 v9fs_string_init(&new_full_name);
1046
1047 v9fs_string_sprintf(&old_full_name, "%s/%s", olddir->data, old_name);
1048 v9fs_string_sprintf(&new_full_name, "%s/%s", newdir->data, new_name);
1049
1050 ret = proxy_rename(ctx, old_full_name.data, new_full_name.data);
1051 v9fs_string_free(&old_full_name);
1052 v9fs_string_free(&new_full_name);
1053 return ret;
1054 }
1055
1056 static int proxy_unlinkat(FsContext *ctx, V9fsPath *dir,
1057 const char *name, int flags)
1058 {
1059 int ret;
1060 V9fsString fullname;
1061 v9fs_string_init(&fullname);
1062
1063 v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);
1064 ret = proxy_remove(ctx, fullname.data);
1065 v9fs_string_free(&fullname);
1066
1067 return ret;
1068 }
1069
1070 static int proxy_ioc_getversion(FsContext *fs_ctx, V9fsPath *path,
1071 mode_t st_mode, uint64_t *st_gen)
1072 {
1073 int err;
1074
1075 /* Do not try to open special files like device nodes, fifos etc
1076 * we can get fd for regular files and directories only
1077 */
1078 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1079 errno = ENOTTY;
1080 return -1;
1081 }
1082 err = v9fs_request(fs_ctx->private, T_GETVERSION, st_gen, path);
1083 if (err < 0) {
1084 errno = -err;
1085 err = -1;
1086 }
1087 return err;
1088 }
1089
1090 static int connect_namedsocket(const char *path, Error **errp)
1091 {
1092 int sockfd;
1093 struct sockaddr_un helper;
1094
1095 if (strlen(path) >= sizeof(helper.sun_path)) {
1096 error_setg(errp, "socket name too long");
1097 return -1;
1098 }
1099 sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
1100 if (sockfd < 0) {
1101 error_setg_errno(errp, errno, "failed to create client socket");
1102 return -1;
1103 }
1104 strcpy(helper.sun_path, path);
1105 helper.sun_family = AF_UNIX;
1106 if (connect(sockfd, (struct sockaddr *)&helper, sizeof(helper)) < 0) {
1107 error_setg_errno(errp, errno, "failed to connect to '%s'", path);
1108 close(sockfd);
1109 return -1;
1110 }
1111
1112 /* remove the socket for security reasons */
1113 unlink(path);
1114 return sockfd;
1115 }
1116
1117 static void error_append_socket_sockfd_hint(Error *const *errp)
1118 {
1119 error_append_hint(errp, "Either specify socket=/some/path where /some/path"
1120 " points to a listening AF_UNIX socket or sock_fd=fd"
1121 " where fd is a file descriptor to a connected AF_UNIX"
1122 " socket\n");
1123 }
1124
1125 static int proxy_parse_opts(QemuOpts *opts, FsDriverEntry *fs, Error **errp)
1126 {
1127 const char *socket = qemu_opt_get(opts, "socket");
1128 const char *sock_fd = qemu_opt_get(opts, "sock_fd");
1129
1130 if (!socket && !sock_fd) {
1131 error_setg(errp, "both socket and sock_fd properties are missing");
1132 error_append_socket_sockfd_hint(errp);
1133 return -1;
1134 }
1135 if (socket && sock_fd) {
1136 error_setg(errp, "both socket and sock_fd properties are set");
1137 error_append_socket_sockfd_hint(errp);
1138 return -1;
1139 }
1140 if (socket) {
1141 fs->path = g_strdup(socket);
1142 fs->export_flags |= V9FS_PROXY_SOCK_NAME;
1143 } else {
1144 fs->path = g_strdup(sock_fd);
1145 fs->export_flags |= V9FS_PROXY_SOCK_FD;
1146 }
1147 return 0;
1148 }
1149
1150 static int proxy_init(FsContext *ctx, Error **errp)
1151 {
1152 V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy));
1153 int sock_id;
1154
1155 if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {
1156 sock_id = connect_namedsocket(ctx->fs_root, errp);
1157 } else {
1158 sock_id = atoi(ctx->fs_root);
1159 if (sock_id < 0) {
1160 error_setg(errp, "socket descriptor not initialized");
1161 }
1162 }
1163 if (sock_id < 0) {
1164 g_free(proxy);
1165 return -1;
1166 }
1167 g_free(ctx->fs_root);
1168 ctx->fs_root = NULL;
1169
1170 proxy->in_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ);
1171 proxy->in_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ;
1172 proxy->out_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ);
1173 proxy->out_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ;
1174
1175 ctx->private = proxy;
1176 proxy->sockfd = sock_id;
1177 qemu_mutex_init(&proxy->mutex);
1178
1179 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1180 ctx->exops.get_st_gen = proxy_ioc_getversion;
1181 return 0;
1182 }
1183
1184 static void proxy_cleanup(FsContext *ctx)
1185 {
1186 V9fsProxy *proxy = ctx->private;
1187
1188 if (!proxy) {
1189 return;
1190 }
1191
1192 g_free(proxy->out_iovec.iov_base);
1193 g_free(proxy->in_iovec.iov_base);
1194 if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {
1195 close(proxy->sockfd);
1196 }
1197 g_free(proxy);
1198 }
1199
1200 FileOperations proxy_ops = {
1201 .parse_opts = proxy_parse_opts,
1202 .init = proxy_init,
1203 .cleanup = proxy_cleanup,
1204 .lstat = proxy_lstat,
1205 .readlink = proxy_readlink,
1206 .close = proxy_close,
1207 .closedir = proxy_closedir,
1208 .open = proxy_open,
1209 .opendir = proxy_opendir,
1210 .rewinddir = proxy_rewinddir,
1211 .telldir = proxy_telldir,
1212 .readdir = proxy_readdir,
1213 .seekdir = proxy_seekdir,
1214 .preadv = proxy_preadv,
1215 .pwritev = proxy_pwritev,
1216 .chmod = proxy_chmod,
1217 .mknod = proxy_mknod,
1218 .mkdir = proxy_mkdir,
1219 .fstat = proxy_fstat,
1220 .open2 = proxy_open2,
1221 .symlink = proxy_symlink,
1222 .link = proxy_link,
1223 .truncate = proxy_truncate,
1224 .rename = proxy_rename,
1225 .chown = proxy_chown,
1226 .utimensat = proxy_utimensat,
1227 .remove = proxy_remove,
1228 .fsync = proxy_fsync,
1229 .statfs = proxy_statfs,
1230 .lgetxattr = proxy_lgetxattr,
1231 .llistxattr = proxy_llistxattr,
1232 .lsetxattr = proxy_lsetxattr,
1233 .lremovexattr = proxy_lremovexattr,
1234 .name_to_path = proxy_name_to_path,
1235 .renameat = proxy_renameat,
1236 .unlinkat = proxy_unlinkat,
1237 };