4 * Copyright IBM, Corp. 2011
7 * M. Mohan Kumar <mohan@in.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
12 #include "qemu/osdep.h"
13 #include <sys/socket.h>
16 #include "qemu/cutils.h"
17 #include "qemu/error-report.h"
18 #include "fsdev/qemu-fsdev.h"
21 typedef struct V9fsProxy {
24 struct iovec in_iovec;
25 struct iovec out_iovec;
29 * Return received file descriptor on success in *status.
30 * errno is also returned on *status (which will be < 0)
31 * return < 0 on transport error.
33 static int v9fs_receivefd(int sockfd, int *status)
39 union MsgControl msg_control;
42 iov.iov_len = sizeof(data);
44 memset(&msg, 0, sizeof(msg));
47 msg.msg_control = &msg_control;
48 msg.msg_controllen = sizeof(msg_control);
51 retval = recvmsg(sockfd, &msg, 0);
52 } while (retval < 0 && errno == EINTR);
57 * data is set to V9FS_FD_VALID, if ancillary data is sent. If this
58 * request doesn't need ancillary data (fd) or an error occurred,
59 * data is set to negative errno value.
61 if (data != V9FS_FD_VALID) {
66 * File descriptor (fd) is sent in the ancillary data. Check if we
67 * indeed received it. One of the reasons to fail to receive it is if
68 * we exceeded the maximum number of file descriptors!
70 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
71 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
72 cmsg->cmsg_level != SOL_SOCKET ||
73 cmsg->cmsg_type != SCM_RIGHTS) {
76 fd = *((int *)CMSG_DATA(cmsg));
80 *status = -ENFILE; /* Ancillary data sent but not received */
84 static ssize_t socket_read(int sockfd, void *buff, size_t size)
86 ssize_t retval, total = 0;
89 retval = read(sockfd, buff, size);
106 /* Converts proxy_statfs to VFS statfs structure */
107 static void prstatfs_to_statfs(struct statfs *stfs, ProxyStatFS *prstfs)
109 memset(stfs, 0, sizeof(*stfs));
110 stfs->f_type = prstfs->f_type;
111 stfs->f_bsize = prstfs->f_bsize;
112 stfs->f_blocks = prstfs->f_blocks;
113 stfs->f_bfree = prstfs->f_bfree;
114 stfs->f_bavail = prstfs->f_bavail;
115 stfs->f_files = prstfs->f_files;
116 stfs->f_ffree = prstfs->f_ffree;
117 stfs->f_fsid.__val[0] = prstfs->f_fsid[0] & 0xFFFFFFFFU;
118 stfs->f_fsid.__val[1] = prstfs->f_fsid[1] >> 32 & 0xFFFFFFFFU;
119 stfs->f_namelen = prstfs->f_namelen;
120 stfs->f_frsize = prstfs->f_frsize;
123 /* Converts proxy_stat structure to VFS stat structure */
124 static void prstat_to_stat(struct stat *stbuf, ProxyStat *prstat)
126 memset(stbuf, 0, sizeof(*stbuf));
127 stbuf->st_dev = prstat->st_dev;
128 stbuf->st_ino = prstat->st_ino;
129 stbuf->st_nlink = prstat->st_nlink;
130 stbuf->st_mode = prstat->st_mode;
131 stbuf->st_uid = prstat->st_uid;
132 stbuf->st_gid = prstat->st_gid;
133 stbuf->st_rdev = prstat->st_rdev;
134 stbuf->st_size = prstat->st_size;
135 stbuf->st_blksize = prstat->st_blksize;
136 stbuf->st_blocks = prstat->st_blocks;
137 stbuf->st_atim.tv_sec = prstat->st_atim_sec;
138 stbuf->st_atim.tv_nsec = prstat->st_atim_nsec;
139 stbuf->st_mtime = prstat->st_mtim_sec;
140 stbuf->st_mtim.tv_nsec = prstat->st_mtim_nsec;
141 stbuf->st_ctime = prstat->st_ctim_sec;
142 stbuf->st_ctim.tv_nsec = prstat->st_ctim_nsec;
146 * Response contains two parts
148 * header.type == T_ERROR, data -> -errno
149 * header.type == T_SUCCESS, data -> response
150 * size of errno/response is given by header.size
151 * returns < 0, on transport error. response is
152 * valid only if status >= 0.
154 static int v9fs_receive_response(V9fsProxy *proxy, int type,
155 int *status, void *response)
159 struct iovec *reply = &proxy->in_iovec;
163 retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ);
167 reply->iov_len = PROXY_HDR_SZ;
168 proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
170 * if response size > PROXY_MAX_IO_SZ, read the response but ignore it and
173 if (header.size > PROXY_MAX_IO_SZ) {
175 while (header.size > 0) {
176 count = MIN(PROXY_MAX_IO_SZ, header.size);
177 count = socket_read(proxy->sockfd, reply->iov_base, count);
181 header.size -= count;
187 retval = socket_read(proxy->sockfd,
188 reply->iov_base + PROXY_HDR_SZ, header.size);
192 reply->iov_len += header.size;
193 /* there was an error during processing request */
194 if (header.type == T_ERROR) {
196 ret = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
206 retval = proxy_unmarshal(reply, PROXY_HDR_SZ,
207 "qqqdddqqqqqqqqqq", &prstat.st_dev,
208 &prstat.st_ino, &prstat.st_nlink,
209 &prstat.st_mode, &prstat.st_uid,
210 &prstat.st_gid, &prstat.st_rdev,
211 &prstat.st_size, &prstat.st_blksize,
213 &prstat.st_atim_sec, &prstat.st_atim_nsec,
214 &prstat.st_mtim_sec, &prstat.st_mtim_nsec,
215 &prstat.st_ctim_sec, &prstat.st_ctim_nsec);
216 prstat_to_stat(response, &prstat);
221 retval = proxy_unmarshal(reply, PROXY_HDR_SZ,
222 "qqqqqqqqqqq", &prstfs.f_type,
223 &prstfs.f_bsize, &prstfs.f_blocks,
224 &prstfs.f_bfree, &prstfs.f_bavail,
225 &prstfs.f_files, &prstfs.f_ffree,
226 &prstfs.f_fsid[0], &prstfs.f_fsid[1],
227 &prstfs.f_namelen, &prstfs.f_frsize);
228 prstatfs_to_statfs(response, &prstfs);
233 v9fs_string_init(&target);
234 retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "s", &target);
235 strcpy(response, target.data);
236 v9fs_string_free(&target);
242 v9fs_string_init(&xattr);
243 retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "s", &xattr);
244 memcpy(response, xattr.data, xattr.size);
245 v9fs_string_free(&xattr);
249 proxy_unmarshal(reply, PROXY_HDR_SZ, "q", response);
261 * return < 0 on transport error.
262 * *status is valid only if return >= 0
264 static int v9fs_receive_status(V9fsProxy *proxy,
265 struct iovec *reply, int *status)
272 retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ);
276 reply->iov_len = PROXY_HDR_SZ;
277 proxy_unmarshal(reply, 0, "dd", &header.type, &header.size);
278 if (header.size != sizeof(int)) {
282 retval = socket_read(proxy->sockfd,
283 reply->iov_base + PROXY_HDR_SZ, header.size);
287 reply->iov_len += header.size;
288 proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status);
293 * Proxy->header and proxy->request written to socket by QEMU process.
294 * This request read by proxy helper process
295 * returns 0 on success and -errno on error
297 static int v9fs_request(V9fsProxy *proxy, int type,
298 void *response, const char *fmt, ...)
305 ProxyHeader header = { 0, 0};
306 struct timespec spec[2];
307 int flags, mode, uid, gid;
308 V9fsString *name, *value;
309 V9fsString *path, *oldpath;
310 struct iovec *iovec = NULL, *reply = NULL;
312 qemu_mutex_lock(&proxy->mutex);
314 if (proxy->sockfd == -1) {
318 iovec = &proxy->out_iovec;
319 reply = &proxy->in_iovec;
323 path = va_arg(ap, V9fsString *);
324 flags = va_arg(ap, int);
325 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, flags);
327 header.size = retval;
328 header.type = T_OPEN;
332 path = va_arg(ap, V9fsString *);
333 flags = va_arg(ap, int);
334 mode = va_arg(ap, int);
335 uid = va_arg(ap, int);
336 gid = va_arg(ap, int);
337 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sdddd", path,
338 flags, mode, uid, gid);
340 header.size = retval;
341 header.type = T_CREATE;
345 path = va_arg(ap, V9fsString *);
346 mode = va_arg(ap, int);
347 rdev = va_arg(ap, long int);
348 uid = va_arg(ap, int);
349 gid = va_arg(ap, int);
350 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddsdq",
351 uid, gid, path, mode, rdev);
353 header.size = retval;
354 header.type = T_MKNOD;
358 path = va_arg(ap, V9fsString *);
359 mode = va_arg(ap, int);
360 uid = va_arg(ap, int);
361 gid = va_arg(ap, int);
362 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddsd",
363 uid, gid, path, mode);
365 header.size = retval;
366 header.type = T_MKDIR;
370 oldpath = va_arg(ap, V9fsString *);
371 path = va_arg(ap, V9fsString *);
372 uid = va_arg(ap, int);
373 gid = va_arg(ap, int);
374 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddss",
375 uid, gid, oldpath, path);
377 header.size = retval;
378 header.type = T_SYMLINK;
382 oldpath = va_arg(ap, V9fsString *);
383 path = va_arg(ap, V9fsString *);
384 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss",
387 header.size = retval;
388 header.type = T_LINK;
392 path = va_arg(ap, V9fsString *);
393 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
395 header.size = retval;
396 header.type = T_LSTAT;
400 path = va_arg(ap, V9fsString *);
401 size = va_arg(ap, int);
402 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, size);
404 header.size = retval;
405 header.type = T_READLINK;
409 path = va_arg(ap, V9fsString *);
410 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
412 header.size = retval;
413 header.type = T_STATFS;
417 path = va_arg(ap, V9fsString *);
418 mode = va_arg(ap, int);
419 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, mode);
421 header.size = retval;
422 header.type = T_CHMOD;
426 path = va_arg(ap, V9fsString *);
427 uid = va_arg(ap, int);
428 gid = va_arg(ap, int);
429 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sdd", path, uid, gid);
431 header.size = retval;
432 header.type = T_CHOWN;
436 path = va_arg(ap, V9fsString *);
437 offset = va_arg(ap, uint64_t);
438 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sq", path, offset);
440 header.size = retval;
441 header.type = T_TRUNCATE;
445 path = va_arg(ap, V9fsString *);
446 spec[0].tv_sec = va_arg(ap, long);
447 spec[0].tv_nsec = va_arg(ap, long);
448 spec[1].tv_sec = va_arg(ap, long);
449 spec[1].tv_nsec = va_arg(ap, long);
450 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sqqqq", path,
451 spec[0].tv_sec, spec[1].tv_nsec,
452 spec[1].tv_sec, spec[1].tv_nsec);
454 header.size = retval;
455 header.type = T_UTIME;
459 oldpath = va_arg(ap, V9fsString *);
460 path = va_arg(ap, V9fsString *);
461 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", oldpath, path);
463 header.size = retval;
464 header.type = T_RENAME;
468 path = va_arg(ap, V9fsString *);
469 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
471 header.size = retval;
472 header.type = T_REMOVE;
476 size = va_arg(ap, int);
477 path = va_arg(ap, V9fsString *);
478 name = va_arg(ap, V9fsString *);
479 retval = proxy_marshal(iovec, PROXY_HDR_SZ,
480 "dss", size, path, name);
482 header.size = retval;
483 header.type = T_LGETXATTR;
487 size = va_arg(ap, int);
488 path = va_arg(ap, V9fsString *);
489 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ds", size, path);
491 header.size = retval;
492 header.type = T_LLISTXATTR;
496 path = va_arg(ap, V9fsString *);
497 name = va_arg(ap, V9fsString *);
498 value = va_arg(ap, V9fsString *);
499 size = va_arg(ap, int);
500 flags = va_arg(ap, int);
501 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sssdd",
502 path, name, value, size, flags);
504 header.size = retval;
505 header.type = T_LSETXATTR;
509 path = va_arg(ap, V9fsString *);
510 name = va_arg(ap, V9fsString *);
511 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", path, name);
513 header.size = retval;
514 header.type = T_LREMOVEXATTR;
518 path = va_arg(ap, V9fsString *);
519 retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path);
521 header.size = retval;
522 header.type = T_GETVERSION;
526 error_report("Invalid type %d", type);
536 /* marshal the header details */
537 proxy_marshal(iovec, 0, "dd", header.type, header.size);
538 header.size += PROXY_HDR_SZ;
540 retval = qemu_write_full(proxy->sockfd, iovec->iov_base, header.size);
541 if (retval != header.size) {
549 * A file descriptor is returned as response for
550 * T_OPEN,T_CREATE on success
552 if (v9fs_receivefd(proxy->sockfd, &retval) < 0) {
568 if (v9fs_receive_status(proxy, reply, &retval) < 0) {
576 if (v9fs_receive_response(proxy, type, &retval, response) < 0) {
583 if (v9fs_receive_status(proxy, reply, &retval) < 0) {
587 if (v9fs_receive_response(proxy, type, &retval, response) < 0) {
595 qemu_mutex_unlock(&proxy->mutex);
599 close(proxy->sockfd);
601 qemu_mutex_unlock(&proxy->mutex);
605 static int proxy_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
608 retval = v9fs_request(fs_ctx->private, T_LSTAT, stbuf, "s", fs_path);
616 static ssize_t proxy_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
617 char *buf, size_t bufsz)
620 retval = v9fs_request(fs_ctx->private, T_READLINK, buf, "sd",
629 static int proxy_close(FsContext *ctx, V9fsFidOpenState *fs)
631 return close(fs->fd);
634 static int proxy_closedir(FsContext *ctx, V9fsFidOpenState *fs)
636 return closedir(fs->dir);
639 static int proxy_open(FsContext *ctx, V9fsPath *fs_path,
640 int flags, V9fsFidOpenState *fs)
642 fs->fd = v9fs_request(ctx->private, T_OPEN, NULL, "sd", fs_path, flags);
650 static int proxy_opendir(FsContext *ctx,
651 V9fsPath *fs_path, V9fsFidOpenState *fs)
656 fd = v9fs_request(ctx->private, T_OPEN, NULL, "sd", fs_path, O_DIRECTORY);
661 fs->dir = fdopendir(fd);
671 static void proxy_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
676 static off_t proxy_telldir(FsContext *ctx, V9fsFidOpenState *fs)
678 return telldir(fs->dir);
681 static int proxy_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
682 struct dirent *entry,
683 struct dirent **result)
685 return readdir_r(fs->dir, entry, result);
688 static void proxy_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
690 seekdir(fs->dir, off);
693 static ssize_t proxy_preadv(FsContext *ctx, V9fsFidOpenState *fs,
694 const struct iovec *iov,
695 int iovcnt, off_t offset)
699 ret = preadv(fs->fd, iov, iovcnt, offset);
701 ret = lseek(fs->fd, offset, SEEK_SET);
703 ret = readv(fs->fd, iov, iovcnt);
709 static ssize_t proxy_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
710 const struct iovec *iov,
711 int iovcnt, off_t offset)
716 ret = pwritev(fs->fd, iov, iovcnt, offset);
718 ret = lseek(fs->fd, offset, SEEK_SET);
720 ret = writev(fs->fd, iov, iovcnt);
723 #ifdef CONFIG_SYNC_FILE_RANGE
724 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
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.
730 sync_file_range(fs->fd, offset, ret,
731 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
737 static int proxy_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
740 retval = v9fs_request(fs_ctx->private, T_CHMOD, NULL, "sd",
741 fs_path, credp->fc_mode);
748 static int proxy_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
749 const char *name, FsCred *credp)
754 v9fs_string_init(&fullname);
755 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
757 retval = v9fs_request(fs_ctx->private, T_MKNOD, NULL, "sdqdd",
758 &fullname, credp->fc_mode, credp->fc_rdev,
759 credp->fc_uid, credp->fc_gid);
760 v9fs_string_free(&fullname);
768 static int proxy_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
769 const char *name, FsCred *credp)
774 v9fs_string_init(&fullname);
775 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
777 retval = v9fs_request(fs_ctx->private, T_MKDIR, NULL, "sddd", &fullname,
778 credp->fc_mode, credp->fc_uid, credp->fc_gid);
779 v9fs_string_free(&fullname);
784 v9fs_string_free(&fullname);
788 static int proxy_fstat(FsContext *fs_ctx, int fid_type,
789 V9fsFidOpenState *fs, struct stat *stbuf)
793 if (fid_type == P9_FID_DIR) {
798 return fstat(fd, stbuf);
801 static int proxy_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
802 int flags, FsCred *credp, V9fsFidOpenState *fs)
806 v9fs_string_init(&fullname);
807 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
809 fs->fd = v9fs_request(fs_ctx->private, T_CREATE, NULL, "sdddd",
810 &fullname, flags, credp->fc_mode,
811 credp->fc_uid, credp->fc_gid);
812 v9fs_string_free(&fullname);
820 static int proxy_symlink(FsContext *fs_ctx, const char *oldpath,
821 V9fsPath *dir_path, const char *name, FsCred *credp)
824 V9fsString fullname, target;
826 v9fs_string_init(&fullname);
827 v9fs_string_init(&target);
829 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
830 v9fs_string_sprintf(&target, "%s", oldpath);
832 retval = v9fs_request(fs_ctx->private, T_SYMLINK, NULL, "ssdd",
833 &target, &fullname, credp->fc_uid, credp->fc_gid);
834 v9fs_string_free(&fullname);
835 v9fs_string_free(&target);
843 static int proxy_link(FsContext *ctx, V9fsPath *oldpath,
844 V9fsPath *dirpath, const char *name)
849 v9fs_string_init(&newpath);
850 v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name);
852 retval = v9fs_request(ctx->private, T_LINK, NULL, "ss", oldpath, &newpath);
853 v9fs_string_free(&newpath);
861 static int proxy_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
865 retval = v9fs_request(ctx->private, T_TRUNCATE, NULL, "sq", fs_path, size);
873 static int proxy_rename(FsContext *ctx, const char *oldpath,
877 V9fsString oldname, newname;
879 v9fs_string_init(&oldname);
880 v9fs_string_init(&newname);
882 v9fs_string_sprintf(&oldname, "%s", oldpath);
883 v9fs_string_sprintf(&newname, "%s", newpath);
884 retval = v9fs_request(ctx->private, T_RENAME, NULL, "ss",
886 v9fs_string_free(&oldname);
887 v9fs_string_free(&newname);
894 static int proxy_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
897 retval = v9fs_request(fs_ctx->private, T_CHOWN, NULL, "sdd",
898 fs_path, credp->fc_uid, credp->fc_gid);
905 static int proxy_utimensat(FsContext *s, V9fsPath *fs_path,
906 const struct timespec *buf)
909 retval = v9fs_request(s->private, T_UTIME, NULL, "sqqqq",
911 buf[0].tv_sec, buf[0].tv_nsec,
912 buf[1].tv_sec, buf[1].tv_nsec);
919 static int proxy_remove(FsContext *ctx, const char *path)
923 v9fs_string_init(&name);
924 v9fs_string_sprintf(&name, "%s", path);
925 retval = v9fs_request(ctx->private, T_REMOVE, NULL, "s", &name);
926 v9fs_string_free(&name);
933 static int proxy_fsync(FsContext *ctx, int fid_type,
934 V9fsFidOpenState *fs, int datasync)
938 if (fid_type == P9_FID_DIR) {
945 return qemu_fdatasync(fd);
951 static int proxy_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
954 retval = v9fs_request(s->private, T_STATFS, stbuf, "s", fs_path);
962 static ssize_t proxy_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
963 const char *name, void *value, size_t size)
968 v9fs_string_init(&xname);
969 v9fs_string_sprintf(&xname, "%s", name);
970 retval = v9fs_request(ctx->private, T_LGETXATTR, value, "dss", size,
972 v9fs_string_free(&xname);
979 static ssize_t proxy_llistxattr(FsContext *ctx, V9fsPath *fs_path,
980 void *value, size_t size)
983 retval = v9fs_request(ctx->private, T_LLISTXATTR, value, "ds", size,
991 static int proxy_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
992 void *value, size_t size, int flags)
995 V9fsString xname, xvalue;
997 v9fs_string_init(&xname);
998 v9fs_string_sprintf(&xname, "%s", name);
1000 v9fs_string_init(&xvalue);
1002 xvalue.data = g_malloc(size);
1003 memcpy(xvalue.data, value, size);
1005 retval = v9fs_request(ctx->private, T_LSETXATTR, value, "sssdd",
1006 fs_path, &xname, &xvalue, size, flags);
1007 v9fs_string_free(&xname);
1008 v9fs_string_free(&xvalue);
1015 static int proxy_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
1021 v9fs_string_init(&xname);
1022 v9fs_string_sprintf(&xname, "%s", name);
1023 retval = v9fs_request(ctx->private, T_LREMOVEXATTR, NULL, "ss",
1025 v9fs_string_free(&xname);
1032 static int proxy_name_to_path(FsContext *ctx, V9fsPath *dir_path,
1033 const char *name, V9fsPath *target)
1036 v9fs_string_sprintf((V9fsString *)target, "%s/%s",
1037 dir_path->data, name);
1039 v9fs_string_sprintf((V9fsString *)target, "%s", name);
1041 /* Bump the size for including terminating NULL */
1046 static int proxy_renameat(FsContext *ctx, V9fsPath *olddir,
1047 const char *old_name, V9fsPath *newdir,
1048 const char *new_name)
1051 V9fsString old_full_name, new_full_name;
1053 v9fs_string_init(&old_full_name);
1054 v9fs_string_init(&new_full_name);
1056 v9fs_string_sprintf(&old_full_name, "%s/%s", olddir->data, old_name);
1057 v9fs_string_sprintf(&new_full_name, "%s/%s", newdir->data, new_name);
1059 ret = proxy_rename(ctx, old_full_name.data, new_full_name.data);
1060 v9fs_string_free(&old_full_name);
1061 v9fs_string_free(&new_full_name);
1065 static int proxy_unlinkat(FsContext *ctx, V9fsPath *dir,
1066 const char *name, int flags)
1069 V9fsString fullname;
1070 v9fs_string_init(&fullname);
1072 v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);
1073 ret = proxy_remove(ctx, fullname.data);
1074 v9fs_string_free(&fullname);
1079 static int proxy_ioc_getversion(FsContext *fs_ctx, V9fsPath *path,
1080 mode_t st_mode, uint64_t *st_gen)
1084 /* Do not try to open special files like device nodes, fifos etc
1085 * we can get fd for regular files and directories only
1087 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
1091 err = v9fs_request(fs_ctx->private, T_GETVERSION, st_gen, "s", path);
1099 static int connect_namedsocket(const char *path)
1102 struct sockaddr_un helper;
1104 if (strlen(path) >= sizeof(helper.sun_path)) {
1105 error_report("Socket name too long");
1108 sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
1110 error_report("Failed to create socket: %s", strerror(errno));
1113 strcpy(helper.sun_path, path);
1114 helper.sun_family = AF_UNIX;
1115 size = strlen(helper.sun_path) + sizeof(helper.sun_family);
1116 if (connect(sockfd, (struct sockaddr *)&helper, size) < 0) {
1117 error_report("Failed to connect to %s: %s", path, strerror(errno));
1122 /* remove the socket for security reasons */
1127 static int proxy_parse_opts(QemuOpts *opts, struct FsDriverEntry *fs)
1129 const char *socket = qemu_opt_get(opts, "socket");
1130 const char *sock_fd = qemu_opt_get(opts, "sock_fd");
1132 if (!socket && !sock_fd) {
1133 error_report("Must specify either socket or sock_fd");
1136 if (socket && sock_fd) {
1137 error_report("Both socket and sock_fd options specified");
1141 fs->path = g_strdup(socket);
1142 fs->export_flags = V9FS_PROXY_SOCK_NAME;
1144 fs->path = g_strdup(sock_fd);
1145 fs->export_flags = V9FS_PROXY_SOCK_FD;
1150 static int proxy_init(FsContext *ctx)
1152 V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy));
1155 if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) {
1156 sock_id = connect_namedsocket(ctx->fs_root);
1158 sock_id = atoi(ctx->fs_root);
1160 error_report("Socket descriptor not initialized");
1167 g_free(ctx->fs_root);
1168 ctx->fs_root = NULL;
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;
1175 ctx->private = proxy;
1176 proxy->sockfd = sock_id;
1177 qemu_mutex_init(&proxy->mutex);
1179 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
1180 ctx->exops.get_st_gen = proxy_ioc_getversion;
1184 FileOperations proxy_ops = {
1185 .parse_opts = proxy_parse_opts,
1187 .lstat = proxy_lstat,
1188 .readlink = proxy_readlink,
1189 .close = proxy_close,
1190 .closedir = proxy_closedir,
1192 .opendir = proxy_opendir,
1193 .rewinddir = proxy_rewinddir,
1194 .telldir = proxy_telldir,
1195 .readdir_r = proxy_readdir_r,
1196 .seekdir = proxy_seekdir,
1197 .preadv = proxy_preadv,
1198 .pwritev = proxy_pwritev,
1199 .chmod = proxy_chmod,
1200 .mknod = proxy_mknod,
1201 .mkdir = proxy_mkdir,
1202 .fstat = proxy_fstat,
1203 .open2 = proxy_open2,
1204 .symlink = proxy_symlink,
1206 .truncate = proxy_truncate,
1207 .rename = proxy_rename,
1208 .chown = proxy_chown,
1209 .utimensat = proxy_utimensat,
1210 .remove = proxy_remove,
1211 .fsync = proxy_fsync,
1212 .statfs = proxy_statfs,
1213 .lgetxattr = proxy_lgetxattr,
1214 .llistxattr = proxy_llistxattr,
1215 .lsetxattr = proxy_lsetxattr,
1216 .lremovexattr = proxy_lremovexattr,
1217 .name_to_path = proxy_name_to_path,
1218 .renameat = proxy_renameat,
1219 .unlinkat = proxy_unlinkat,