Update version for v6.2.0-rc3 release
[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 retval = proxy_marshal(iovec, 0, "dd", header.type, header.size);
541 assert(retval == 4 * 2);
542 header.size += PROXY_HDR_SZ;
543
544 retval = qemu_write_full(proxy->sockfd, iovec->iov_base, header.size);
545 if (retval != header.size) {
546 goto close_error;
547 }
548
549 switch (type) {
550 case T_OPEN:
551 case T_CREATE:
552 /*
553 * A file descriptor is returned as response for
554 * T_OPEN,T_CREATE on success
555 */
556 if (v9fs_receivefd(proxy->sockfd, &retval) < 0) {
557 goto close_error;
558 }
559 break;
560 case T_MKNOD:
561 case T_MKDIR:
562 case T_SYMLINK:
563 case T_LINK:
564 case T_CHMOD:
565 case T_CHOWN:
566 case T_RENAME:
567 case T_TRUNCATE:
568 case T_UTIME:
569 case T_REMOVE:
570 case T_LSETXATTR:
571 case T_LREMOVEXATTR:
572 if (v9fs_receive_status(proxy, reply, &retval) < 0) {
573 goto close_error;
574 }
575 break;
576 case T_LSTAT:
577 case T_READLINK:
578 case T_STATFS:
579 case T_GETVERSION:
580 if (v9fs_receive_response(proxy, type, &retval, response) < 0) {
581 goto close_error;
582 }
583 break;
584 case T_LGETXATTR:
585 case T_LLISTXATTR:
586 if (!size) {
587 if (v9fs_receive_status(proxy, reply, &retval) < 0) {
588 goto close_error;
589 }
590 } else {
591 if (v9fs_receive_response(proxy, type, &retval, response) < 0) {
592 goto close_error;
593 }
594 }
595 break;
596 }
597
598 err_out:
599 qemu_mutex_unlock(&proxy->mutex);
600 return retval;
601
602 close_error:
603 close(proxy->sockfd);
604 proxy->sockfd = -1;
605 qemu_mutex_unlock(&proxy->mutex);
606 return -EIO;
607 }
608
609 static int proxy_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
610 {
611 int retval;
612 retval = v9fs_request(fs_ctx->private, T_LSTAT, stbuf, fs_path);
613 if (retval < 0) {
614 errno = -retval;
615 return -1;
616 }
617 return retval;
618 }
619
620 static ssize_t proxy_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
621 char *buf, size_t bufsz)
622 {
623 int retval;
624 retval = v9fs_request(fs_ctx->private, T_READLINK, buf, fs_path, bufsz);
625 if (retval < 0) {
626 errno = -retval;
627 return -1;
628 }
629 return strlen(buf);
630 }
631
632 static int proxy_close(FsContext *ctx, V9fsFidOpenState *fs)
633 {
634 return close(fs->fd);
635 }
636
637 static int proxy_closedir(FsContext *ctx, V9fsFidOpenState *fs)
638 {
639 return closedir(fs->dir.stream);
640 }
641
642 static int proxy_open(FsContext *ctx, V9fsPath *fs_path,
643 int flags, V9fsFidOpenState *fs)
644 {
645 fs->fd = v9fs_request(ctx->private, T_OPEN, NULL, fs_path, flags);
646 if (fs->fd < 0) {
647 errno = -fs->fd;
648 fs->fd = -1;
649 }
650 return fs->fd;
651 }
652
653 static int proxy_opendir(FsContext *ctx,
654 V9fsPath *fs_path, V9fsFidOpenState *fs)
655 {
656 int serrno, fd;
657
658 fs->dir.stream = NULL;
659 fd = v9fs_request(ctx->private, T_OPEN, NULL, fs_path, O_DIRECTORY);
660 if (fd < 0) {
661 errno = -fd;
662 return -1;
663 }
664 fs->dir.stream = fdopendir(fd);
665 if (!fs->dir.stream) {
666 serrno = errno;
667 close(fd);
668 errno = serrno;
669 return -1;
670 }
671 return 0;
672 }
673
674 static void proxy_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
675 {
676 rewinddir(fs->dir.stream);
677 }
678
679 static off_t proxy_telldir(FsContext *ctx, V9fsFidOpenState *fs)
680 {
681 return telldir(fs->dir.stream);
682 }
683
684 static struct dirent *proxy_readdir(FsContext *ctx, V9fsFidOpenState *fs)
685 {
686 return readdir(fs->dir.stream);
687 }
688
689 static void proxy_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
690 {
691 seekdir(fs->dir.stream, off);
692 }
693
694 static ssize_t proxy_preadv(FsContext *ctx, V9fsFidOpenState *fs,
695 const struct iovec *iov,
696 int iovcnt, off_t offset)
697 {
698 ssize_t ret;
699 #ifdef CONFIG_PREADV
700 ret = preadv(fs->fd, iov, iovcnt, offset);
701 #else
702 ret = lseek(fs->fd, offset, SEEK_SET);
703 if (ret >= 0) {
704 ret = readv(fs->fd, iov, iovcnt);
705 }
706 #endif
707 return ret;
708 }
709
710 static ssize_t proxy_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
711 const struct iovec *iov,
712 int iovcnt, off_t offset)
713 {
714 ssize_t ret;
715
716 #ifdef CONFIG_PREADV
717 ret = pwritev(fs->fd, iov, iovcnt, offset);
718 #else
719 ret = lseek(fs->fd, offset, SEEK_SET);
720 if (ret >= 0) {
721 ret = writev(fs->fd, iov, iovcnt);
722 }
723 #endif
724 #ifdef CONFIG_SYNC_FILE_RANGE
725 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
726 /*
727 * Initiate a writeback. This is not a data integrity sync.
728 * We want to ensure that we don't leave dirty pages in the cache
729 * after write when writeout=immediate is sepcified.
730 */
731 sync_file_range(fs->fd, offset, ret,
732 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
733 }
734 #endif
735 return ret;
736 }
737
738 static int proxy_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
739 {
740 int retval;
741 retval = v9fs_request(fs_ctx->private, T_CHMOD, NULL, fs_path,
742 credp->fc_mode);
743 if (retval < 0) {
744 errno = -retval;
745 }
746 return retval;
747 }
748
749 static int proxy_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
750 const char *name, FsCred *credp)
751 {
752 int retval;
753 V9fsString fullname;
754
755 v9fs_string_init(&fullname);
756 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
757
758 retval = v9fs_request(fs_ctx->private, T_MKNOD, NULL, &fullname,
759 credp->fc_mode, credp->fc_rdev,
760 credp->fc_uid, credp->fc_gid);
761 v9fs_string_free(&fullname);
762 if (retval < 0) {
763 errno = -retval;
764 retval = -1;
765 }
766 return retval;
767 }
768
769 static int proxy_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
770 const char *name, FsCred *credp)
771 {
772 int retval;
773 V9fsString fullname;
774
775 v9fs_string_init(&fullname);
776 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
777
778 retval = v9fs_request(fs_ctx->private, T_MKDIR, NULL, &fullname,
779 credp->fc_mode, credp->fc_uid, credp->fc_gid);
780 v9fs_string_free(&fullname);
781 if (retval < 0) {
782 errno = -retval;
783 retval = -1;
784 }
785 return retval;
786 }
787
788 static int proxy_fstat(FsContext *fs_ctx, int fid_type,
789 V9fsFidOpenState *fs, struct stat *stbuf)
790 {
791 int fd;
792
793 if (fid_type == P9_FID_DIR) {
794 fd = dirfd(fs->dir.stream);
795 } else {
796 fd = fs->fd;
797 }
798 return fstat(fd, stbuf);
799 }
800
801 static int proxy_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
802 int flags, FsCred *credp, V9fsFidOpenState *fs)
803 {
804 V9fsString fullname;
805
806 v9fs_string_init(&fullname);
807 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
808
809 fs->fd = v9fs_request(fs_ctx->private, T_CREATE, NULL, &fullname, flags,
810 credp->fc_mode, credp->fc_uid, credp->fc_gid);
811 v9fs_string_free(&fullname);
812 if (fs->fd < 0) {
813 errno = -fs->fd;
814 fs->fd = -1;
815 }
816 return fs->fd;
817 }
818
819 static int proxy_symlink(FsContext *fs_ctx, const char *oldpath,
820 V9fsPath *dir_path, const char *name, FsCred *credp)
821 {
822 int retval;
823 V9fsString fullname, target;
824
825 v9fs_string_init(&fullname);
826 v9fs_string_init(&target);
827
828 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
829 v9fs_string_sprintf(&target, "%s", oldpath);
830
831 retval = v9fs_request(fs_ctx->private, T_SYMLINK, NULL, &target, &fullname,
832 credp->fc_uid, credp->fc_gid);
833 v9fs_string_free(&fullname);
834 v9fs_string_free(&target);
835 if (retval < 0) {
836 errno = -retval;
837 retval = -1;
838 }
839 return retval;
840 }
841
842 static int proxy_link(FsContext *ctx, V9fsPath *oldpath,
843 V9fsPath *dirpath, const char *name)
844 {
845 int retval;
846 V9fsString newpath;
847
848 v9fs_string_init(&newpath);
849 v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name);
850
851 retval = v9fs_request(ctx->private, T_LINK, NULL, oldpath, &newpath);
852 v9fs_string_free(&newpath);
853 if (retval < 0) {
854 errno = -retval;
855 retval = -1;
856 }
857 return retval;
858 }
859
860 static int proxy_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
861 {
862 int retval;
863
864 retval = v9fs_request(ctx->private, T_TRUNCATE, NULL, fs_path, size);
865 if (retval < 0) {
866 errno = -retval;
867 return -1;
868 }
869 return 0;
870 }
871
872 static int proxy_rename(FsContext *ctx, const char *oldpath,
873 const char *newpath)
874 {
875 int retval;
876 V9fsString oldname, newname;
877
878 v9fs_string_init(&oldname);
879 v9fs_string_init(&newname);
880
881 v9fs_string_sprintf(&oldname, "%s", oldpath);
882 v9fs_string_sprintf(&newname, "%s", newpath);
883 retval = v9fs_request(ctx->private, T_RENAME, NULL, &oldname, &newname);
884 v9fs_string_free(&oldname);
885 v9fs_string_free(&newname);
886 if (retval < 0) {
887 errno = -retval;
888 }
889 return retval;
890 }
891
892 static int proxy_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
893 {
894 int retval;
895 retval = v9fs_request(fs_ctx->private, T_CHOWN, NULL, fs_path,
896 credp->fc_uid, credp->fc_gid);
897 if (retval < 0) {
898 errno = -retval;
899 }
900 return retval;
901 }
902
903 static int proxy_utimensat(FsContext *s, V9fsPath *fs_path,
904 const struct timespec *buf)
905 {
906 int retval;
907 retval = v9fs_request(s->private, T_UTIME, NULL, fs_path,
908 buf[0].tv_sec, buf[0].tv_nsec,
909 buf[1].tv_sec, buf[1].tv_nsec);
910 if (retval < 0) {
911 errno = -retval;
912 }
913 return retval;
914 }
915
916 static int proxy_remove(FsContext *ctx, const char *path)
917 {
918 int retval;
919 V9fsString name;
920 v9fs_string_init(&name);
921 v9fs_string_sprintf(&name, "%s", path);
922 retval = v9fs_request(ctx->private, T_REMOVE, NULL, &name);
923 v9fs_string_free(&name);
924 if (retval < 0) {
925 errno = -retval;
926 }
927 return retval;
928 }
929
930 static int proxy_fsync(FsContext *ctx, int fid_type,
931 V9fsFidOpenState *fs, int datasync)
932 {
933 int fd;
934
935 if (fid_type == P9_FID_DIR) {
936 fd = dirfd(fs->dir.stream);
937 } else {
938 fd = fs->fd;
939 }
940
941 if (datasync) {
942 return qemu_fdatasync(fd);
943 } else {
944 return fsync(fd);
945 }
946 }
947
948 static int proxy_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
949 {
950 int retval;
951 retval = v9fs_request(s->private, T_STATFS, stbuf, fs_path);
952 if (retval < 0) {
953 errno = -retval;
954 return -1;
955 }
956 return retval;
957 }
958
959 static ssize_t proxy_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
960 const char *name, void *value, size_t size)
961 {
962 int retval;
963 V9fsString xname;
964
965 v9fs_string_init(&xname);
966 v9fs_string_sprintf(&xname, "%s", name);
967 retval = v9fs_request(ctx->private, T_LGETXATTR, value, size, fs_path,
968 &xname);
969 v9fs_string_free(&xname);
970 if (retval < 0) {
971 errno = -retval;
972 }
973 return retval;
974 }
975
976 static ssize_t proxy_llistxattr(FsContext *ctx, V9fsPath *fs_path,
977 void *value, size_t size)
978 {
979 int retval;
980 retval = v9fs_request(ctx->private, T_LLISTXATTR, value, size, fs_path);
981 if (retval < 0) {
982 errno = -retval;
983 }
984 return retval;
985 }
986
987 static int proxy_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
988 void *value, size_t size, int flags)
989 {
990 int retval;
991 V9fsString xname, xvalue;
992
993 v9fs_string_init(&xname);
994 v9fs_string_sprintf(&xname, "%s", name);
995
996 v9fs_string_init(&xvalue);
997 xvalue.size = size;
998 xvalue.data = g_malloc(size);
999 memcpy(xvalue.data, value, size);
1000
1001 retval = v9fs_request(ctx->private, T_LSETXATTR, value, fs_path, &xname,
1002 &xvalue, size, flags);
1003 v9fs_string_free(&xname);
1004 v9fs_string_free(&xvalue);
1005 if (retval < 0) {
1006 errno = -retval;
1007 }
1008 return retval;
1009 }
1010
1011 static int proxy_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1012 const char *name)
1013 {
1014 int retval;
1015 V9fsString xname;
1016
1017 v9fs_string_init(&xname);
1018 v9fs_string_sprintf(&xname, "%s", name);
1019 retval = v9fs_request(ctx->private, T_LREMOVEXATTR, NULL, fs_path, &xname);
1020 v9fs_string_free(&xname);
1021 if (retval < 0) {
1022 errno = -retval;
1023 }
1024 return retval;
1025 }
1026
1027 static int proxy_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1028 const char *name, V9fsPath *target)
1029 {
1030 if (dir_path) {
1031 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name);
1032 } else {
1033 v9fs_path_sprintf(target, "%s", name);
1034 }
1035 return 0;
1036 }
1037
1038 static int proxy_renameat(FsContext *ctx, V9fsPath *olddir,
1039 const char *old_name, V9fsPath *newdir,
1040 const char *new_name)
1041 {
1042 int ret;
1043 V9fsString old_full_name, new_full_name;
1044
1045 v9fs_string_init(&old_full_name);
1046 v9fs_string_init(&new_full_name);
1047
1048 v9fs_string_sprintf(&old_full_name, "%s/%s", olddir->data, old_name);
1049 v9fs_string_sprintf(&new_full_name, "%s/%s", newdir->data, new_name);
1050
1051 ret = proxy_rename(ctx, old_full_name.data, new_full_name.data);
1052 v9fs_string_free(&old_full_name);
1053 v9fs_string_free(&new_full_name);
1054 return ret;
1055 }
1056
1057 static int proxy_unlinkat(FsContext *ctx, V9fsPath *dir,
1058 const char *name, int flags)
1059 {
1060 int ret;
1061 V9fsString fullname;
1062 v9fs_string_init(&fullname);
1063
1064 v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);
1065 ret = proxy_remove(ctx, fullname.data);
1066 v9fs_string_free(&fullname);
1067
1068 return ret;
1069 }
1070
1071 static int proxy_ioc_getversion(FsContext *fs_ctx, V9fsPath *path,
1072 mode_t st_mode, uint64_t *st_gen)
1073 {
1074 int err;
1075
1076 /* Do not try to open special files like device nodes, fifos etc
1077 * we can get fd for regular files and directories only
1078 */
1079 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1080 errno = ENOTTY;
1081 return -1;
1082 }
1083 err = v9fs_request(fs_ctx->private, T_GETVERSION, st_gen, path);
1084 if (err < 0) {
1085 errno = -err;
1086 err = -1;
1087 }
1088 return err;
1089 }
1090
1091 static int connect_namedsocket(const char *path, Error **errp)
1092 {
1093 int sockfd;
1094 struct sockaddr_un helper;
1095
1096 if (strlen(path) >= sizeof(helper.sun_path)) {
1097 error_setg(errp, "socket name too long");
1098 return -1;
1099 }
1100 sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
1101 if (sockfd < 0) {
1102 error_setg_errno(errp, errno, "failed to create client socket");
1103 return -1;
1104 }
1105 strcpy(helper.sun_path, path);
1106 helper.sun_family = AF_UNIX;
1107 if (connect(sockfd, (struct sockaddr *)&helper, sizeof(helper)) < 0) {
1108 error_setg_errno(errp, errno, "failed to connect to '%s'", path);
1109 close(sockfd);
1110 return -1;
1111 }
1112
1113 /* remove the socket for security reasons */
1114 unlink(path);
1115 return sockfd;
1116 }
1117
1118 static void error_append_socket_sockfd_hint(Error *const *errp)
1119 {
1120 error_append_hint(errp, "Either specify socket=/some/path where /some/path"
1121 " points to a listening AF_UNIX socket or sock_fd=fd"
1122 " where fd is a file descriptor to a connected AF_UNIX"
1123 " socket\n");
1124 }
1125
1126 static int proxy_parse_opts(QemuOpts *opts, FsDriverEntry *fs, Error **errp)
1127 {
1128 const char *socket = qemu_opt_get(opts, "socket");
1129 const char *sock_fd = qemu_opt_get(opts, "sock_fd");
1130
1131 if (!socket && !sock_fd) {
1132 error_setg(errp, "both socket and sock_fd properties are missing");
1133 error_append_socket_sockfd_hint(errp);
1134 return -1;
1135 }
1136 if (socket && sock_fd) {
1137 error_setg(errp, "both socket and sock_fd properties are set");
1138 error_append_socket_sockfd_hint(errp);
1139 return -1;
1140 }
1141 if (socket) {
1142 fs->path = g_strdup(socket);
1143 fs->export_flags |= V9FS_PROXY_SOCK_NAME;
1144 } else {
1145 fs->path = g_strdup(sock_fd);
1146 fs->export_flags |= V9FS_PROXY_SOCK_FD;
1147 }
1148 return 0;
1149 }
1150
1151 static int proxy_init(FsContext *ctx, Error **errp)
1152 {
1153 V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy));
1154 int sock_id;
1155
1156 if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {
1157 sock_id = connect_namedsocket(ctx->fs_root, errp);
1158 } else {
1159 sock_id = atoi(ctx->fs_root);
1160 if (sock_id < 0) {
1161 error_setg(errp, "socket descriptor not initialized");
1162 }
1163 }
1164 if (sock_id < 0) {
1165 g_free(proxy);
1166 return -1;
1167 }
1168 g_free(ctx->fs_root);
1169 ctx->fs_root = NULL;
1170
1171 proxy->in_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ);
1172 proxy->in_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ;
1173 proxy->out_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ);
1174 proxy->out_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ;
1175
1176 ctx->private = proxy;
1177 proxy->sockfd = sock_id;
1178 qemu_mutex_init(&proxy->mutex);
1179
1180 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1181 ctx->exops.get_st_gen = proxy_ioc_getversion;
1182 return 0;
1183 }
1184
1185 static void proxy_cleanup(FsContext *ctx)
1186 {
1187 V9fsProxy *proxy = ctx->private;
1188
1189 if (!proxy) {
1190 return;
1191 }
1192
1193 g_free(proxy->out_iovec.iov_base);
1194 g_free(proxy->in_iovec.iov_base);
1195 if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {
1196 close(proxy->sockfd);
1197 }
1198 g_free(proxy);
1199 }
1200
1201 FileOperations proxy_ops = {
1202 .parse_opts = proxy_parse_opts,
1203 .init = proxy_init,
1204 .cleanup = proxy_cleanup,
1205 .lstat = proxy_lstat,
1206 .readlink = proxy_readlink,
1207 .close = proxy_close,
1208 .closedir = proxy_closedir,
1209 .open = proxy_open,
1210 .opendir = proxy_opendir,
1211 .rewinddir = proxy_rewinddir,
1212 .telldir = proxy_telldir,
1213 .readdir = proxy_readdir,
1214 .seekdir = proxy_seekdir,
1215 .preadv = proxy_preadv,
1216 .pwritev = proxy_pwritev,
1217 .chmod = proxy_chmod,
1218 .mknod = proxy_mknod,
1219 .mkdir = proxy_mkdir,
1220 .fstat = proxy_fstat,
1221 .open2 = proxy_open2,
1222 .symlink = proxy_symlink,
1223 .link = proxy_link,
1224 .truncate = proxy_truncate,
1225 .rename = proxy_rename,
1226 .chown = proxy_chown,
1227 .utimensat = proxy_utimensat,
1228 .remove = proxy_remove,
1229 .fsync = proxy_fsync,
1230 .statfs = proxy_statfs,
1231 .lgetxattr = proxy_lgetxattr,
1232 .llistxattr = proxy_llistxattr,
1233 .lsetxattr = proxy_lsetxattr,
1234 .lremovexattr = proxy_lremovexattr,
1235 .name_to_path = proxy_name_to_path,
1236 .renameat = proxy_renameat,
1237 .unlinkat = proxy_unlinkat,
1238 };