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