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