1 /* 2 * 9p Posix callback 3 * 4 * Copyright IBM, Corp. 2010 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.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 #include "qemu/osdep.h" 15 #include "9p.h" 16 #include "9p-local.h" 17 #include "9p-xattr.h" 18 #include "9p-util.h" 19 #include "fsdev/qemu-fsdev.h" /* local_ops */ 20 #include <arpa/inet.h> 21 #include <pwd.h> 22 #include <grp.h> 23 #include <sys/socket.h> 24 #include <sys/un.h> 25 #include "qemu/xattr.h" 26 #include "qemu/cutils.h" 27 #include "qemu/error-report.h" 28 #include <libgen.h> 29 #include <linux/fs.h> 30 #ifdef CONFIG_LINUX_MAGIC_H 31 #include <linux/magic.h> 32 #endif 33 #include <sys/ioctl.h> 34 35 #ifndef XFS_SUPER_MAGIC 36 #define XFS_SUPER_MAGIC 0x58465342 37 #endif 38 #ifndef EXT2_SUPER_MAGIC 39 #define EXT2_SUPER_MAGIC 0xEF53 40 #endif 41 #ifndef REISERFS_SUPER_MAGIC 42 #define REISERFS_SUPER_MAGIC 0x52654973 43 #endif 44 #ifndef BTRFS_SUPER_MAGIC 45 #define BTRFS_SUPER_MAGIC 0x9123683E 46 #endif 47 48 typedef struct { 49 int mountfd; 50 } LocalData; 51 52 int local_open_nofollow(FsContext *fs_ctx, const char *path, int flags, 53 mode_t mode) 54 { 55 LocalData *data = fs_ctx->private; 56 57 /* All paths are relative to the path data->mountfd points to */ 58 while (*path == '/') { 59 path++; 60 } 61 62 return relative_openat_nofollow(data->mountfd, path, flags, mode); 63 } 64 65 int local_opendir_nofollow(FsContext *fs_ctx, const char *path) 66 { 67 return local_open_nofollow(fs_ctx, path, O_DIRECTORY | O_RDONLY, 0); 68 } 69 70 static void renameat_preserve_errno(int odirfd, const char *opath, int ndirfd, 71 const char *npath) 72 { 73 int serrno = errno; 74 renameat(odirfd, opath, ndirfd, npath); 75 errno = serrno; 76 } 77 78 #define VIRTFS_META_DIR ".virtfs_metadata" 79 80 static char *local_mapped_attr_path(FsContext *ctx, const char *path) 81 { 82 int dirlen; 83 const char *name = strrchr(path, '/'); 84 if (name) { 85 dirlen = name - path; 86 ++name; 87 } else { 88 name = path; 89 dirlen = 0; 90 } 91 return g_strdup_printf("%s/%.*s/%s/%s", ctx->fs_root, 92 dirlen, path, VIRTFS_META_DIR, name); 93 } 94 95 static FILE *local_fopen(const char *path, const char *mode) 96 { 97 int fd, o_mode = 0; 98 FILE *fp; 99 int flags = O_NOFOLLOW; 100 /* 101 * only supports two modes 102 */ 103 if (mode[0] == 'r') { 104 flags |= O_RDONLY; 105 } else if (mode[0] == 'w') { 106 flags |= O_WRONLY | O_TRUNC | O_CREAT; 107 o_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; 108 } else { 109 return NULL; 110 } 111 fd = open(path, flags, o_mode); 112 if (fd == -1) { 113 return NULL; 114 } 115 fp = fdopen(fd, mode); 116 if (!fp) { 117 close(fd); 118 } 119 return fp; 120 } 121 122 static FILE *local_fopenat(int dirfd, const char *name, const char *mode) 123 { 124 int fd, o_mode = 0; 125 FILE *fp; 126 int flags; 127 /* 128 * only supports two modes 129 */ 130 if (mode[0] == 'r') { 131 flags = O_RDONLY; 132 } else if (mode[0] == 'w') { 133 flags = O_WRONLY | O_TRUNC | O_CREAT; 134 o_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; 135 } else { 136 return NULL; 137 } 138 fd = openat_file(dirfd, name, flags, o_mode); 139 if (fd == -1) { 140 return NULL; 141 } 142 fp = fdopen(fd, mode); 143 if (!fp) { 144 close(fd); 145 } 146 return fp; 147 } 148 149 #define ATTR_MAX 100 150 static void local_mapped_file_attr(int dirfd, const char *name, 151 struct stat *stbuf) 152 { 153 FILE *fp; 154 char buf[ATTR_MAX]; 155 int map_dirfd; 156 157 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR); 158 if (map_dirfd == -1) { 159 return; 160 } 161 162 fp = local_fopenat(map_dirfd, name, "r"); 163 close_preserve_errno(map_dirfd); 164 if (!fp) { 165 return; 166 } 167 memset(buf, 0, ATTR_MAX); 168 while (fgets(buf, ATTR_MAX, fp)) { 169 if (!strncmp(buf, "virtfs.uid", 10)) { 170 stbuf->st_uid = atoi(buf+11); 171 } else if (!strncmp(buf, "virtfs.gid", 10)) { 172 stbuf->st_gid = atoi(buf+11); 173 } else if (!strncmp(buf, "virtfs.mode", 11)) { 174 stbuf->st_mode = atoi(buf+12); 175 } else if (!strncmp(buf, "virtfs.rdev", 11)) { 176 stbuf->st_rdev = atoi(buf+12); 177 } 178 memset(buf, 0, ATTR_MAX); 179 } 180 fclose(fp); 181 } 182 183 static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf) 184 { 185 int err = -1; 186 char *dirpath = g_path_get_dirname(fs_path->data); 187 char *name = g_path_get_basename(fs_path->data); 188 int dirfd; 189 190 dirfd = local_opendir_nofollow(fs_ctx, dirpath); 191 if (dirfd == -1) { 192 goto out; 193 } 194 195 err = fstatat(dirfd, name, stbuf, AT_SYMLINK_NOFOLLOW); 196 if (err) { 197 goto err_out; 198 } 199 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 200 /* Actual credentials are part of extended attrs */ 201 uid_t tmp_uid; 202 gid_t tmp_gid; 203 mode_t tmp_mode; 204 dev_t tmp_dev; 205 206 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.uid", &tmp_uid, 207 sizeof(uid_t)) > 0) { 208 stbuf->st_uid = le32_to_cpu(tmp_uid); 209 } 210 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.gid", &tmp_gid, 211 sizeof(gid_t)) > 0) { 212 stbuf->st_gid = le32_to_cpu(tmp_gid); 213 } 214 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.mode", &tmp_mode, 215 sizeof(mode_t)) > 0) { 216 stbuf->st_mode = le32_to_cpu(tmp_mode); 217 } 218 if (fgetxattrat_nofollow(dirfd, name, "user.virtfs.rdev", &tmp_dev, 219 sizeof(dev_t)) > 0) { 220 stbuf->st_rdev = le64_to_cpu(tmp_dev); 221 } 222 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 223 local_mapped_file_attr(dirfd, name, stbuf); 224 } 225 226 err_out: 227 close_preserve_errno(dirfd); 228 out: 229 g_free(name); 230 g_free(dirpath); 231 return err; 232 } 233 234 static int local_create_mapped_attr_dir(FsContext *ctx, const char *path) 235 { 236 int err; 237 char *attr_dir; 238 char *tmp_path = g_strdup(path); 239 240 attr_dir = g_strdup_printf("%s/%s/%s", 241 ctx->fs_root, dirname(tmp_path), VIRTFS_META_DIR); 242 243 err = mkdir(attr_dir, 0700); 244 if (err < 0 && errno == EEXIST) { 245 err = 0; 246 } 247 g_free(attr_dir); 248 g_free(tmp_path); 249 return err; 250 } 251 252 static int local_set_mapped_file_attr(FsContext *ctx, 253 const char *path, FsCred *credp) 254 { 255 FILE *fp; 256 int ret = 0; 257 char buf[ATTR_MAX]; 258 char *attr_path; 259 int uid = -1, gid = -1, mode = -1, rdev = -1; 260 261 attr_path = local_mapped_attr_path(ctx, path); 262 fp = local_fopen(attr_path, "r"); 263 if (!fp) { 264 goto create_map_file; 265 } 266 memset(buf, 0, ATTR_MAX); 267 while (fgets(buf, ATTR_MAX, fp)) { 268 if (!strncmp(buf, "virtfs.uid", 10)) { 269 uid = atoi(buf+11); 270 } else if (!strncmp(buf, "virtfs.gid", 10)) { 271 gid = atoi(buf+11); 272 } else if (!strncmp(buf, "virtfs.mode", 11)) { 273 mode = atoi(buf+12); 274 } else if (!strncmp(buf, "virtfs.rdev", 11)) { 275 rdev = atoi(buf+12); 276 } 277 memset(buf, 0, ATTR_MAX); 278 } 279 fclose(fp); 280 goto update_map_file; 281 282 create_map_file: 283 ret = local_create_mapped_attr_dir(ctx, path); 284 if (ret < 0) { 285 goto err_out; 286 } 287 288 update_map_file: 289 fp = local_fopen(attr_path, "w"); 290 if (!fp) { 291 ret = -1; 292 goto err_out; 293 } 294 295 if (credp->fc_uid != -1) { 296 uid = credp->fc_uid; 297 } 298 if (credp->fc_gid != -1) { 299 gid = credp->fc_gid; 300 } 301 if (credp->fc_mode != -1) { 302 mode = credp->fc_mode; 303 } 304 if (credp->fc_rdev != -1) { 305 rdev = credp->fc_rdev; 306 } 307 308 309 if (uid != -1) { 310 fprintf(fp, "virtfs.uid=%d\n", uid); 311 } 312 if (gid != -1) { 313 fprintf(fp, "virtfs.gid=%d\n", gid); 314 } 315 if (mode != -1) { 316 fprintf(fp, "virtfs.mode=%d\n", mode); 317 } 318 if (rdev != -1) { 319 fprintf(fp, "virtfs.rdev=%d\n", rdev); 320 } 321 fclose(fp); 322 323 err_out: 324 g_free(attr_path); 325 return ret; 326 } 327 328 static int local_set_xattr(const char *path, FsCred *credp) 329 { 330 int err; 331 332 if (credp->fc_uid != -1) { 333 uint32_t tmp_uid = cpu_to_le32(credp->fc_uid); 334 err = setxattr(path, "user.virtfs.uid", &tmp_uid, sizeof(uid_t), 0); 335 if (err) { 336 return err; 337 } 338 } 339 if (credp->fc_gid != -1) { 340 uint32_t tmp_gid = cpu_to_le32(credp->fc_gid); 341 err = setxattr(path, "user.virtfs.gid", &tmp_gid, sizeof(gid_t), 0); 342 if (err) { 343 return err; 344 } 345 } 346 if (credp->fc_mode != -1) { 347 uint32_t tmp_mode = cpu_to_le32(credp->fc_mode); 348 err = setxattr(path, "user.virtfs.mode", &tmp_mode, sizeof(mode_t), 0); 349 if (err) { 350 return err; 351 } 352 } 353 if (credp->fc_rdev != -1) { 354 uint64_t tmp_rdev = cpu_to_le64(credp->fc_rdev); 355 err = setxattr(path, "user.virtfs.rdev", &tmp_rdev, sizeof(dev_t), 0); 356 if (err) { 357 return err; 358 } 359 } 360 return 0; 361 } 362 363 static int local_post_create_passthrough(FsContext *fs_ctx, const char *path, 364 FsCred *credp) 365 { 366 char *buffer; 367 368 buffer = rpath(fs_ctx, path); 369 if (lchown(buffer, credp->fc_uid, credp->fc_gid) < 0) { 370 /* 371 * If we fail to change ownership and if we are 372 * using security model none. Ignore the error 373 */ 374 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) { 375 goto err; 376 } 377 } 378 379 if (chmod(buffer, credp->fc_mode & 07777) < 0) { 380 goto err; 381 } 382 383 g_free(buffer); 384 return 0; 385 err: 386 g_free(buffer); 387 return -1; 388 } 389 390 static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path, 391 char *buf, size_t bufsz) 392 { 393 ssize_t tsize = -1; 394 395 if ((fs_ctx->export_flags & V9FS_SM_MAPPED) || 396 (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE)) { 397 int fd; 398 399 fd = local_open_nofollow(fs_ctx, fs_path->data, O_RDONLY, 0); 400 if (fd == -1) { 401 return -1; 402 } 403 do { 404 tsize = read(fd, (void *)buf, bufsz); 405 } while (tsize == -1 && errno == EINTR); 406 close_preserve_errno(fd); 407 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 408 (fs_ctx->export_flags & V9FS_SM_NONE)) { 409 char *dirpath = g_path_get_dirname(fs_path->data); 410 char *name = g_path_get_basename(fs_path->data); 411 int dirfd; 412 413 dirfd = local_opendir_nofollow(fs_ctx, dirpath); 414 if (dirfd == -1) { 415 goto out; 416 } 417 418 tsize = readlinkat(dirfd, name, buf, bufsz); 419 close_preserve_errno(dirfd); 420 out: 421 g_free(name); 422 g_free(dirpath); 423 } 424 return tsize; 425 } 426 427 static int local_close(FsContext *ctx, V9fsFidOpenState *fs) 428 { 429 return close(fs->fd); 430 } 431 432 static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs) 433 { 434 return closedir(fs->dir.stream); 435 } 436 437 static int local_open(FsContext *ctx, V9fsPath *fs_path, 438 int flags, V9fsFidOpenState *fs) 439 { 440 int fd; 441 442 fd = local_open_nofollow(ctx, fs_path->data, flags, 0); 443 if (fd == -1) { 444 return -1; 445 } 446 fs->fd = fd; 447 return fs->fd; 448 } 449 450 static int local_opendir(FsContext *ctx, 451 V9fsPath *fs_path, V9fsFidOpenState *fs) 452 { 453 int dirfd; 454 DIR *stream; 455 456 dirfd = local_opendir_nofollow(ctx, fs_path->data); 457 if (dirfd == -1) { 458 return -1; 459 } 460 461 stream = fdopendir(dirfd); 462 if (!stream) { 463 return -1; 464 } 465 fs->dir.stream = stream; 466 return 0; 467 } 468 469 static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs) 470 { 471 rewinddir(fs->dir.stream); 472 } 473 474 static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs) 475 { 476 return telldir(fs->dir.stream); 477 } 478 479 static struct dirent *local_readdir(FsContext *ctx, V9fsFidOpenState *fs) 480 { 481 struct dirent *entry; 482 483 again: 484 entry = readdir(fs->dir.stream); 485 if (!entry) { 486 return NULL; 487 } 488 489 if (ctx->export_flags & V9FS_SM_MAPPED) { 490 entry->d_type = DT_UNKNOWN; 491 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { 492 if (!strcmp(entry->d_name, VIRTFS_META_DIR)) { 493 /* skp the meta data directory */ 494 goto again; 495 } 496 entry->d_type = DT_UNKNOWN; 497 } 498 499 return entry; 500 } 501 502 static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off) 503 { 504 seekdir(fs->dir.stream, off); 505 } 506 507 static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs, 508 const struct iovec *iov, 509 int iovcnt, off_t offset) 510 { 511 #ifdef CONFIG_PREADV 512 return preadv(fs->fd, iov, iovcnt, offset); 513 #else 514 int err = lseek(fs->fd, offset, SEEK_SET); 515 if (err == -1) { 516 return err; 517 } else { 518 return readv(fs->fd, iov, iovcnt); 519 } 520 #endif 521 } 522 523 static ssize_t local_pwritev(FsContext *ctx, V9fsFidOpenState *fs, 524 const struct iovec *iov, 525 int iovcnt, off_t offset) 526 { 527 ssize_t ret; 528 #ifdef CONFIG_PREADV 529 ret = pwritev(fs->fd, iov, iovcnt, offset); 530 #else 531 int err = lseek(fs->fd, offset, SEEK_SET); 532 if (err == -1) { 533 return err; 534 } else { 535 ret = writev(fs->fd, iov, iovcnt); 536 } 537 #endif 538 #ifdef CONFIG_SYNC_FILE_RANGE 539 if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) { 540 /* 541 * Initiate a writeback. This is not a data integrity sync. 542 * We want to ensure that we don't leave dirty pages in the cache 543 * after write when writeout=immediate is sepcified. 544 */ 545 sync_file_range(fs->fd, offset, ret, 546 SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE); 547 } 548 #endif 549 return ret; 550 } 551 552 static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp) 553 { 554 char *buffer; 555 int ret = -1; 556 char *path = fs_path->data; 557 558 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 559 buffer = rpath(fs_ctx, path); 560 ret = local_set_xattr(buffer, credp); 561 g_free(buffer); 562 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 563 return local_set_mapped_file_attr(fs_ctx, path, credp); 564 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 565 (fs_ctx->export_flags & V9FS_SM_NONE)) { 566 buffer = rpath(fs_ctx, path); 567 ret = chmod(buffer, credp->fc_mode); 568 g_free(buffer); 569 } 570 return ret; 571 } 572 573 static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path, 574 const char *name, FsCred *credp) 575 { 576 char *path; 577 int err = -1; 578 int serrno = 0; 579 V9fsString fullname; 580 char *buffer = NULL; 581 582 v9fs_string_init(&fullname); 583 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); 584 path = fullname.data; 585 586 /* Determine the security model */ 587 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 588 buffer = rpath(fs_ctx, path); 589 err = mknod(buffer, SM_LOCAL_MODE_BITS|S_IFREG, 0); 590 if (err == -1) { 591 goto out; 592 } 593 err = local_set_xattr(buffer, credp); 594 if (err == -1) { 595 serrno = errno; 596 goto err_end; 597 } 598 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 599 600 buffer = rpath(fs_ctx, path); 601 err = mknod(buffer, SM_LOCAL_MODE_BITS|S_IFREG, 0); 602 if (err == -1) { 603 goto out; 604 } 605 err = local_set_mapped_file_attr(fs_ctx, path, credp); 606 if (err == -1) { 607 serrno = errno; 608 goto err_end; 609 } 610 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 611 (fs_ctx->export_flags & V9FS_SM_NONE)) { 612 buffer = rpath(fs_ctx, path); 613 err = mknod(buffer, credp->fc_mode, credp->fc_rdev); 614 if (err == -1) { 615 goto out; 616 } 617 err = local_post_create_passthrough(fs_ctx, path, credp); 618 if (err == -1) { 619 serrno = errno; 620 goto err_end; 621 } 622 } 623 goto out; 624 625 err_end: 626 remove(buffer); 627 errno = serrno; 628 out: 629 g_free(buffer); 630 v9fs_string_free(&fullname); 631 return err; 632 } 633 634 static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path, 635 const char *name, FsCred *credp) 636 { 637 char *path; 638 int err = -1; 639 int serrno = 0; 640 V9fsString fullname; 641 char *buffer = NULL; 642 643 v9fs_string_init(&fullname); 644 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); 645 path = fullname.data; 646 647 /* Determine the security model */ 648 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 649 buffer = rpath(fs_ctx, path); 650 err = mkdir(buffer, SM_LOCAL_DIR_MODE_BITS); 651 if (err == -1) { 652 goto out; 653 } 654 credp->fc_mode = credp->fc_mode|S_IFDIR; 655 err = local_set_xattr(buffer, credp); 656 if (err == -1) { 657 serrno = errno; 658 goto err_end; 659 } 660 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 661 buffer = rpath(fs_ctx, path); 662 err = mkdir(buffer, SM_LOCAL_DIR_MODE_BITS); 663 if (err == -1) { 664 goto out; 665 } 666 credp->fc_mode = credp->fc_mode|S_IFDIR; 667 err = local_set_mapped_file_attr(fs_ctx, path, credp); 668 if (err == -1) { 669 serrno = errno; 670 goto err_end; 671 } 672 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 673 (fs_ctx->export_flags & V9FS_SM_NONE)) { 674 buffer = rpath(fs_ctx, path); 675 err = mkdir(buffer, credp->fc_mode); 676 if (err == -1) { 677 goto out; 678 } 679 err = local_post_create_passthrough(fs_ctx, path, credp); 680 if (err == -1) { 681 serrno = errno; 682 goto err_end; 683 } 684 } 685 goto out; 686 687 err_end: 688 remove(buffer); 689 errno = serrno; 690 out: 691 g_free(buffer); 692 v9fs_string_free(&fullname); 693 return err; 694 } 695 696 static int local_fstat(FsContext *fs_ctx, int fid_type, 697 V9fsFidOpenState *fs, struct stat *stbuf) 698 { 699 int err, fd; 700 701 if (fid_type == P9_FID_DIR) { 702 fd = dirfd(fs->dir.stream); 703 } else { 704 fd = fs->fd; 705 } 706 707 err = fstat(fd, stbuf); 708 if (err) { 709 return err; 710 } 711 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 712 /* Actual credentials are part of extended attrs */ 713 uid_t tmp_uid; 714 gid_t tmp_gid; 715 mode_t tmp_mode; 716 dev_t tmp_dev; 717 718 if (fgetxattr(fd, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > 0) { 719 stbuf->st_uid = le32_to_cpu(tmp_uid); 720 } 721 if (fgetxattr(fd, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > 0) { 722 stbuf->st_gid = le32_to_cpu(tmp_gid); 723 } 724 if (fgetxattr(fd, "user.virtfs.mode", &tmp_mode, sizeof(mode_t)) > 0) { 725 stbuf->st_mode = le32_to_cpu(tmp_mode); 726 } 727 if (fgetxattr(fd, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > 0) { 728 stbuf->st_rdev = le64_to_cpu(tmp_dev); 729 } 730 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 731 errno = EOPNOTSUPP; 732 return -1; 733 } 734 return err; 735 } 736 737 static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name, 738 int flags, FsCred *credp, V9fsFidOpenState *fs) 739 { 740 char *path; 741 int fd = -1; 742 int err = -1; 743 int serrno = 0; 744 V9fsString fullname; 745 char *buffer = NULL; 746 747 /* 748 * Mark all the open to not follow symlinks 749 */ 750 flags |= O_NOFOLLOW; 751 752 v9fs_string_init(&fullname); 753 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); 754 path = fullname.data; 755 756 /* Determine the security model */ 757 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 758 buffer = rpath(fs_ctx, path); 759 fd = open(buffer, flags, SM_LOCAL_MODE_BITS); 760 if (fd == -1) { 761 err = fd; 762 goto out; 763 } 764 credp->fc_mode = credp->fc_mode|S_IFREG; 765 /* Set cleint credentials in xattr */ 766 err = local_set_xattr(buffer, credp); 767 if (err == -1) { 768 serrno = errno; 769 goto err_end; 770 } 771 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 772 buffer = rpath(fs_ctx, path); 773 fd = open(buffer, flags, SM_LOCAL_MODE_BITS); 774 if (fd == -1) { 775 err = fd; 776 goto out; 777 } 778 credp->fc_mode = credp->fc_mode|S_IFREG; 779 /* Set client credentials in .virtfs_metadata directory files */ 780 err = local_set_mapped_file_attr(fs_ctx, path, credp); 781 if (err == -1) { 782 serrno = errno; 783 goto err_end; 784 } 785 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 786 (fs_ctx->export_flags & V9FS_SM_NONE)) { 787 buffer = rpath(fs_ctx, path); 788 fd = open(buffer, flags, credp->fc_mode); 789 if (fd == -1) { 790 err = fd; 791 goto out; 792 } 793 err = local_post_create_passthrough(fs_ctx, path, credp); 794 if (err == -1) { 795 serrno = errno; 796 goto err_end; 797 } 798 } 799 err = fd; 800 fs->fd = fd; 801 goto out; 802 803 err_end: 804 close(fd); 805 remove(buffer); 806 errno = serrno; 807 out: 808 g_free(buffer); 809 v9fs_string_free(&fullname); 810 return err; 811 } 812 813 814 static int local_symlink(FsContext *fs_ctx, const char *oldpath, 815 V9fsPath *dir_path, const char *name, FsCred *credp) 816 { 817 int err = -1; 818 int serrno = 0; 819 char *newpath; 820 V9fsString fullname; 821 char *buffer = NULL; 822 823 v9fs_string_init(&fullname); 824 v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); 825 newpath = fullname.data; 826 827 /* Determine the security model */ 828 if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 829 int fd; 830 ssize_t oldpath_size, write_size; 831 buffer = rpath(fs_ctx, newpath); 832 fd = open(buffer, O_CREAT|O_EXCL|O_RDWR|O_NOFOLLOW, SM_LOCAL_MODE_BITS); 833 if (fd == -1) { 834 err = fd; 835 goto out; 836 } 837 /* Write the oldpath (target) to the file. */ 838 oldpath_size = strlen(oldpath); 839 do { 840 write_size = write(fd, (void *)oldpath, oldpath_size); 841 } while (write_size == -1 && errno == EINTR); 842 843 if (write_size != oldpath_size) { 844 serrno = errno; 845 close(fd); 846 err = -1; 847 goto err_end; 848 } 849 close(fd); 850 /* Set cleint credentials in symlink's xattr */ 851 credp->fc_mode = credp->fc_mode|S_IFLNK; 852 err = local_set_xattr(buffer, credp); 853 if (err == -1) { 854 serrno = errno; 855 goto err_end; 856 } 857 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 858 int fd; 859 ssize_t oldpath_size, write_size; 860 buffer = rpath(fs_ctx, newpath); 861 fd = open(buffer, O_CREAT|O_EXCL|O_RDWR|O_NOFOLLOW, SM_LOCAL_MODE_BITS); 862 if (fd == -1) { 863 err = fd; 864 goto out; 865 } 866 /* Write the oldpath (target) to the file. */ 867 oldpath_size = strlen(oldpath); 868 do { 869 write_size = write(fd, (void *)oldpath, oldpath_size); 870 } while (write_size == -1 && errno == EINTR); 871 872 if (write_size != oldpath_size) { 873 serrno = errno; 874 close(fd); 875 err = -1; 876 goto err_end; 877 } 878 close(fd); 879 /* Set cleint credentials in symlink's xattr */ 880 credp->fc_mode = credp->fc_mode|S_IFLNK; 881 err = local_set_mapped_file_attr(fs_ctx, newpath, credp); 882 if (err == -1) { 883 serrno = errno; 884 goto err_end; 885 } 886 } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 887 (fs_ctx->export_flags & V9FS_SM_NONE)) { 888 buffer = rpath(fs_ctx, newpath); 889 err = symlink(oldpath, buffer); 890 if (err) { 891 goto out; 892 } 893 err = lchown(buffer, credp->fc_uid, credp->fc_gid); 894 if (err == -1) { 895 /* 896 * If we fail to change ownership and if we are 897 * using security model none. Ignore the error 898 */ 899 if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) { 900 serrno = errno; 901 goto err_end; 902 } else 903 err = 0; 904 } 905 } 906 goto out; 907 908 err_end: 909 remove(buffer); 910 errno = serrno; 911 out: 912 g_free(buffer); 913 v9fs_string_free(&fullname); 914 return err; 915 } 916 917 static int local_link(FsContext *ctx, V9fsPath *oldpath, 918 V9fsPath *dirpath, const char *name) 919 { 920 int ret; 921 V9fsString newpath; 922 char *buffer, *buffer1; 923 int serrno; 924 925 v9fs_string_init(&newpath); 926 v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name); 927 928 buffer = rpath(ctx, oldpath->data); 929 buffer1 = rpath(ctx, newpath.data); 930 ret = link(buffer, buffer1); 931 g_free(buffer); 932 if (ret < 0) { 933 goto out; 934 } 935 936 /* now link the virtfs_metadata files */ 937 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { 938 char *vbuffer, *vbuffer1; 939 940 /* Link the .virtfs_metadata files. Create the metada directory */ 941 ret = local_create_mapped_attr_dir(ctx, newpath.data); 942 if (ret < 0) { 943 goto err_out; 944 } 945 vbuffer = local_mapped_attr_path(ctx, oldpath->data); 946 vbuffer1 = local_mapped_attr_path(ctx, newpath.data); 947 ret = link(vbuffer, vbuffer1); 948 g_free(vbuffer); 949 g_free(vbuffer1); 950 if (ret < 0 && errno != ENOENT) { 951 goto err_out; 952 } 953 } 954 goto out; 955 956 err_out: 957 serrno = errno; 958 remove(buffer1); 959 errno = serrno; 960 out: 961 g_free(buffer1); 962 v9fs_string_free(&newpath); 963 return ret; 964 } 965 966 static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size) 967 { 968 int fd, ret; 969 970 fd = local_open_nofollow(ctx, fs_path->data, O_WRONLY, 0); 971 if (fd == -1) { 972 return -1; 973 } 974 ret = ftruncate(fd, size); 975 close_preserve_errno(fd); 976 return ret; 977 } 978 979 static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp) 980 { 981 char *buffer; 982 int ret = -1; 983 char *path = fs_path->data; 984 985 if ((credp->fc_uid == -1 && credp->fc_gid == -1) || 986 (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || 987 (fs_ctx->export_flags & V9FS_SM_NONE)) { 988 buffer = rpath(fs_ctx, path); 989 ret = lchown(buffer, credp->fc_uid, credp->fc_gid); 990 g_free(buffer); 991 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) { 992 buffer = rpath(fs_ctx, path); 993 ret = local_set_xattr(buffer, credp); 994 g_free(buffer); 995 } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { 996 return local_set_mapped_file_attr(fs_ctx, path, credp); 997 } 998 return ret; 999 } 1000 1001 static int local_utimensat(FsContext *s, V9fsPath *fs_path, 1002 const struct timespec *buf) 1003 { 1004 char *dirpath = g_path_get_dirname(fs_path->data); 1005 char *name = g_path_get_basename(fs_path->data); 1006 int dirfd, ret = -1; 1007 1008 dirfd = local_opendir_nofollow(s, dirpath); 1009 if (dirfd == -1) { 1010 goto out; 1011 } 1012 1013 ret = utimensat(dirfd, name, buf, AT_SYMLINK_NOFOLLOW); 1014 close_preserve_errno(dirfd); 1015 out: 1016 g_free(dirpath); 1017 g_free(name); 1018 return ret; 1019 } 1020 1021 static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name, 1022 int flags) 1023 { 1024 int ret = -1; 1025 1026 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { 1027 int map_dirfd; 1028 1029 if (flags == AT_REMOVEDIR) { 1030 int fd; 1031 1032 fd = openat(dirfd, name, O_RDONLY | O_DIRECTORY | O_PATH); 1033 if (fd == -1) { 1034 goto err_out; 1035 } 1036 /* 1037 * If directory remove .virtfs_metadata contained in the 1038 * directory 1039 */ 1040 ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR); 1041 close_preserve_errno(fd); 1042 if (ret < 0 && errno != ENOENT) { 1043 /* 1044 * We didn't had the .virtfs_metadata file. May be file created 1045 * in non-mapped mode ?. Ignore ENOENT. 1046 */ 1047 goto err_out; 1048 } 1049 } 1050 /* 1051 * Now remove the name from parent directory 1052 * .virtfs_metadata directory. 1053 */ 1054 map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR); 1055 ret = unlinkat(map_dirfd, name, 0); 1056 close_preserve_errno(map_dirfd); 1057 if (ret < 0 && errno != ENOENT) { 1058 /* 1059 * We didn't had the .virtfs_metadata file. May be file created 1060 * in non-mapped mode ?. Ignore ENOENT. 1061 */ 1062 goto err_out; 1063 } 1064 } 1065 1066 ret = unlinkat(dirfd, name, flags); 1067 err_out: 1068 return ret; 1069 } 1070 1071 static int local_remove(FsContext *ctx, const char *path) 1072 { 1073 struct stat stbuf; 1074 char *dirpath = g_path_get_dirname(path); 1075 char *name = g_path_get_basename(path); 1076 int flags = 0; 1077 int dirfd; 1078 int err = -1; 1079 1080 dirfd = local_opendir_nofollow(ctx, dirpath); 1081 if (dirfd) { 1082 goto out; 1083 } 1084 1085 if (fstatat(dirfd, path, &stbuf, AT_SYMLINK_NOFOLLOW) < 0) { 1086 goto err_out; 1087 } 1088 1089 if (S_ISDIR(stbuf.st_mode)) { 1090 flags |= AT_REMOVEDIR; 1091 } 1092 1093 err = local_unlinkat_common(ctx, dirfd, name, flags); 1094 err_out: 1095 close_preserve_errno(dirfd); 1096 out: 1097 g_free(name); 1098 g_free(dirpath); 1099 return err; 1100 } 1101 1102 static int local_fsync(FsContext *ctx, int fid_type, 1103 V9fsFidOpenState *fs, int datasync) 1104 { 1105 int fd; 1106 1107 if (fid_type == P9_FID_DIR) { 1108 fd = dirfd(fs->dir.stream); 1109 } else { 1110 fd = fs->fd; 1111 } 1112 1113 if (datasync) { 1114 return qemu_fdatasync(fd); 1115 } else { 1116 return fsync(fd); 1117 } 1118 } 1119 1120 static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf) 1121 { 1122 int fd, ret; 1123 1124 fd = local_open_nofollow(s, fs_path->data, O_RDONLY, 0); 1125 ret = fstatfs(fd, stbuf); 1126 close_preserve_errno(fd); 1127 return ret; 1128 } 1129 1130 static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path, 1131 const char *name, void *value, size_t size) 1132 { 1133 char *path = fs_path->data; 1134 1135 return v9fs_get_xattr(ctx, path, name, value, size); 1136 } 1137 1138 static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path, 1139 void *value, size_t size) 1140 { 1141 char *path = fs_path->data; 1142 1143 return v9fs_list_xattr(ctx, path, value, size); 1144 } 1145 1146 static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name, 1147 void *value, size_t size, int flags) 1148 { 1149 char *path = fs_path->data; 1150 1151 return v9fs_set_xattr(ctx, path, name, value, size, flags); 1152 } 1153 1154 static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path, 1155 const char *name) 1156 { 1157 char *path = fs_path->data; 1158 1159 return v9fs_remove_xattr(ctx, path, name); 1160 } 1161 1162 static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path, 1163 const char *name, V9fsPath *target) 1164 { 1165 if (dir_path) { 1166 v9fs_path_sprintf(target, "%s/%s", dir_path->data, name); 1167 } else { 1168 v9fs_path_sprintf(target, "%s", name); 1169 } 1170 return 0; 1171 } 1172 1173 static int local_renameat(FsContext *ctx, V9fsPath *olddir, 1174 const char *old_name, V9fsPath *newdir, 1175 const char *new_name) 1176 { 1177 int ret; 1178 int odirfd, ndirfd; 1179 1180 odirfd = local_opendir_nofollow(ctx, olddir->data); 1181 if (odirfd == -1) { 1182 return -1; 1183 } 1184 1185 ndirfd = local_opendir_nofollow(ctx, newdir->data); 1186 if (ndirfd == -1) { 1187 close_preserve_errno(odirfd); 1188 return -1; 1189 } 1190 1191 ret = renameat(odirfd, old_name, ndirfd, new_name); 1192 if (ret < 0) { 1193 goto out; 1194 } 1195 1196 if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { 1197 int omap_dirfd, nmap_dirfd; 1198 1199 ret = mkdirat(ndirfd, VIRTFS_META_DIR, 0700); 1200 if (ret < 0 && errno != EEXIST) { 1201 goto err_undo_rename; 1202 } 1203 1204 omap_dirfd = openat_dir(odirfd, VIRTFS_META_DIR); 1205 if (omap_dirfd == -1) { 1206 goto err; 1207 } 1208 1209 nmap_dirfd = openat_dir(ndirfd, VIRTFS_META_DIR); 1210 if (nmap_dirfd == -1) { 1211 close_preserve_errno(omap_dirfd); 1212 goto err; 1213 } 1214 1215 /* rename the .virtfs_metadata files */ 1216 ret = renameat(omap_dirfd, old_name, nmap_dirfd, new_name); 1217 close_preserve_errno(nmap_dirfd); 1218 close_preserve_errno(omap_dirfd); 1219 if (ret < 0 && errno != ENOENT) { 1220 goto err_undo_rename; 1221 } 1222 1223 ret = 0; 1224 } 1225 goto out; 1226 1227 err: 1228 ret = -1; 1229 err_undo_rename: 1230 renameat_preserve_errno(ndirfd, new_name, odirfd, old_name); 1231 out: 1232 close_preserve_errno(ndirfd); 1233 close_preserve_errno(odirfd); 1234 return ret; 1235 } 1236 1237 static void v9fs_path_init_dirname(V9fsPath *path, const char *str) 1238 { 1239 path->data = g_path_get_dirname(str); 1240 path->size = strlen(path->data) + 1; 1241 } 1242 1243 static int local_rename(FsContext *ctx, const char *oldpath, 1244 const char *newpath) 1245 { 1246 int err; 1247 char *oname = g_path_get_basename(oldpath); 1248 char *nname = g_path_get_basename(newpath); 1249 V9fsPath olddir, newdir; 1250 1251 v9fs_path_init_dirname(&olddir, oldpath); 1252 v9fs_path_init_dirname(&newdir, newpath); 1253 1254 err = local_renameat(ctx, &olddir, oname, &newdir, nname); 1255 1256 v9fs_path_free(&newdir); 1257 v9fs_path_free(&olddir); 1258 g_free(nname); 1259 g_free(oname); 1260 1261 return err; 1262 } 1263 1264 static int local_unlinkat(FsContext *ctx, V9fsPath *dir, 1265 const char *name, int flags) 1266 { 1267 int ret; 1268 int dirfd; 1269 1270 dirfd = local_opendir_nofollow(ctx, dir->data); 1271 if (dirfd == -1) { 1272 return -1; 1273 } 1274 1275 ret = local_unlinkat_common(ctx, dirfd, name, flags); 1276 close_preserve_errno(dirfd); 1277 return ret; 1278 } 1279 1280 static int local_ioc_getversion(FsContext *ctx, V9fsPath *path, 1281 mode_t st_mode, uint64_t *st_gen) 1282 { 1283 #ifdef FS_IOC_GETVERSION 1284 int err; 1285 V9fsFidOpenState fid_open; 1286 1287 /* 1288 * Do not try to open special files like device nodes, fifos etc 1289 * We can get fd for regular files and directories only 1290 */ 1291 if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) { 1292 errno = ENOTTY; 1293 return -1; 1294 } 1295 err = local_open(ctx, path, O_RDONLY, &fid_open); 1296 if (err < 0) { 1297 return err; 1298 } 1299 err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen); 1300 local_close(ctx, &fid_open); 1301 return err; 1302 #else 1303 errno = ENOTTY; 1304 return -1; 1305 #endif 1306 } 1307 1308 static int local_init(FsContext *ctx) 1309 { 1310 struct statfs stbuf; 1311 LocalData *data = g_malloc(sizeof(*data)); 1312 1313 data->mountfd = open(ctx->fs_root, O_DIRECTORY | O_RDONLY); 1314 if (data->mountfd == -1) { 1315 goto err; 1316 } 1317 1318 #ifdef FS_IOC_GETVERSION 1319 /* 1320 * use ioc_getversion only if the ioctl is definied 1321 */ 1322 if (fstatfs(data->mountfd, &stbuf) < 0) { 1323 close_preserve_errno(data->mountfd); 1324 goto err; 1325 } 1326 switch (stbuf.f_type) { 1327 case EXT2_SUPER_MAGIC: 1328 case BTRFS_SUPER_MAGIC: 1329 case REISERFS_SUPER_MAGIC: 1330 case XFS_SUPER_MAGIC: 1331 ctx->exops.get_st_gen = local_ioc_getversion; 1332 break; 1333 } 1334 #endif 1335 1336 if (ctx->export_flags & V9FS_SM_PASSTHROUGH) { 1337 ctx->xops = passthrough_xattr_ops; 1338 } else if (ctx->export_flags & V9FS_SM_MAPPED) { 1339 ctx->xops = mapped_xattr_ops; 1340 } else if (ctx->export_flags & V9FS_SM_NONE) { 1341 ctx->xops = none_xattr_ops; 1342 } else if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { 1343 /* 1344 * xattr operation for mapped-file and passthrough 1345 * remain same. 1346 */ 1347 ctx->xops = passthrough_xattr_ops; 1348 } 1349 ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT; 1350 1351 ctx->private = data; 1352 return 0; 1353 1354 err: 1355 g_free(data); 1356 return -1; 1357 } 1358 1359 static void local_cleanup(FsContext *ctx) 1360 { 1361 LocalData *data = ctx->private; 1362 1363 close(data->mountfd); 1364 g_free(data); 1365 } 1366 1367 static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse) 1368 { 1369 const char *sec_model = qemu_opt_get(opts, "security_model"); 1370 const char *path = qemu_opt_get(opts, "path"); 1371 1372 if (!sec_model) { 1373 error_report("Security model not specified, local fs needs security model"); 1374 error_printf("valid options are:" 1375 "\tsecurity_model=[passthrough|mapped-xattr|mapped-file|none]\n"); 1376 return -1; 1377 } 1378 1379 if (!strcmp(sec_model, "passthrough")) { 1380 fse->export_flags |= V9FS_SM_PASSTHROUGH; 1381 } else if (!strcmp(sec_model, "mapped") || 1382 !strcmp(sec_model, "mapped-xattr")) { 1383 fse->export_flags |= V9FS_SM_MAPPED; 1384 } else if (!strcmp(sec_model, "none")) { 1385 fse->export_flags |= V9FS_SM_NONE; 1386 } else if (!strcmp(sec_model, "mapped-file")) { 1387 fse->export_flags |= V9FS_SM_MAPPED_FILE; 1388 } else { 1389 error_report("Invalid security model %s specified", sec_model); 1390 error_printf("valid options are:" 1391 "\t[passthrough|mapped-xattr|mapped-file|none]\n"); 1392 return -1; 1393 } 1394 1395 if (!path) { 1396 error_report("fsdev: No path specified"); 1397 return -1; 1398 } 1399 fse->path = g_strdup(path); 1400 1401 return 0; 1402 } 1403 1404 FileOperations local_ops = { 1405 .parse_opts = local_parse_opts, 1406 .init = local_init, 1407 .cleanup = local_cleanup, 1408 .lstat = local_lstat, 1409 .readlink = local_readlink, 1410 .close = local_close, 1411 .closedir = local_closedir, 1412 .open = local_open, 1413 .opendir = local_opendir, 1414 .rewinddir = local_rewinddir, 1415 .telldir = local_telldir, 1416 .readdir = local_readdir, 1417 .seekdir = local_seekdir, 1418 .preadv = local_preadv, 1419 .pwritev = local_pwritev, 1420 .chmod = local_chmod, 1421 .mknod = local_mknod, 1422 .mkdir = local_mkdir, 1423 .fstat = local_fstat, 1424 .open2 = local_open2, 1425 .symlink = local_symlink, 1426 .link = local_link, 1427 .truncate = local_truncate, 1428 .rename = local_rename, 1429 .chown = local_chown, 1430 .utimensat = local_utimensat, 1431 .remove = local_remove, 1432 .fsync = local_fsync, 1433 .statfs = local_statfs, 1434 .lgetxattr = local_lgetxattr, 1435 .llistxattr = local_llistxattr, 1436 .lsetxattr = local_lsetxattr, 1437 .lremovexattr = local_lremovexattr, 1438 .name_to_path = local_name_to_path, 1439 .renameat = local_renameat, 1440 .unlinkat = local_unlinkat, 1441 }; 1442