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