hw/9pfs/9p-local.c

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