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