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