hw/9pfs/virtio-9p-local.c

   1 /*
   2  * Virtio 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 "hw/virtio.h"
  15 #include "virtio-9p.h"
  16 #include "virtio-9p-xattr.h"
  17 #include <arpa/inet.h>
  18 #include <pwd.h>
  19 #include <grp.h>
  20 #include <sys/socket.h>
  21 #include <sys/un.h>
  22 #include <attr/xattr.h>
  23 #include <linux/fs.h>
  24 #ifdef CONFIG_LINUX_MAGIC_H
  25 #include <linux/magic.h>
  26 #endif
  27 #include <sys/ioctl.h>
  28
  29 #ifndef XFS_SUPER_MAGIC
  30 #define XFS_SUPER_MAGIC  0x58465342
  31 #endif
  32 #ifndef EXT2_SUPER_MAGIC
  33 #define EXT2_SUPER_MAGIC 0xEF53
  34 #endif
  35 #ifndef REISERFS_SUPER_MAGIC
  36 #define REISERFS_SUPER_MAGIC 0x52654973
  37 #endif
  38 #ifndef BTRFS_SUPER_MAGIC
  39 #define BTRFS_SUPER_MAGIC 0x9123683E
  40 #endif
  41
  42 static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf)
  43 {
  44     int err;
  45     char buffer[PATH_MAX];
  46     char *path = fs_path->data;
  47
  48     err =  lstat(rpath(fs_ctx, path, buffer), stbuf);
  49     if (err) {
  50         return err;
  51     }
  52     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
  53         /* Actual credentials are part of extended attrs */
  54         uid_t tmp_uid;
  55         gid_t tmp_gid;
  56         mode_t tmp_mode;
  57         dev_t tmp_dev;
  58         if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.uid", &tmp_uid,
  59                     sizeof(uid_t)) > 0) {
  60             stbuf->st_uid = tmp_uid;
  61         }
  62         if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.gid", &tmp_gid,
  63                     sizeof(gid_t)) > 0) {
  64             stbuf->st_gid = tmp_gid;
  65         }
  66         if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.mode",
  67                     &tmp_mode, sizeof(mode_t)) > 0) {
  68             stbuf->st_mode = tmp_mode;
  69         }
  70         if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.rdev", &tmp_dev,
  71                         sizeof(dev_t)) > 0) {
  72                 stbuf->st_rdev = tmp_dev;
  73         }
  74     }
  75     return err;
  76 }
  77
  78 static int local_set_xattr(const char *path, FsCred *credp)
  79 {
  80     int err;
  81
  82     if (credp->fc_uid != -1) {
  83         err = setxattr(path, "user.virtfs.uid", &credp->fc_uid, sizeof(uid_t),
  84                 0);
  85         if (err) {
  86             return err;
  87         }
  88     }
  89     if (credp->fc_gid != -1) {
  90         err = setxattr(path, "user.virtfs.gid", &credp->fc_gid, sizeof(gid_t),
  91                 0);
  92         if (err) {
  93             return err;
  94         }
  95     }
  96     if (credp->fc_mode != -1) {
  97         err = setxattr(path, "user.virtfs.mode", &credp->fc_mode,
  98                 sizeof(mode_t), 0);
  99         if (err) {
 100             return err;
 101         }
 102     }
 103     if (credp->fc_rdev != -1) {
 104         err = setxattr(path, "user.virtfs.rdev", &credp->fc_rdev,
 105                 sizeof(dev_t), 0);
 106         if (err) {
 107             return err;
 108         }
 109     }
 110     return 0;
 111 }
 112
 113 static int local_post_create_passthrough(FsContext *fs_ctx, const char *path,
 114                                          FsCred *credp)
 115 {
 116     char buffer[PATH_MAX];
 117
 118     if (chmod(rpath(fs_ctx, path, buffer), credp->fc_mode & 07777) < 0) {
 119         return -1;
 120     }
 121     if (lchown(rpath(fs_ctx, path, buffer), credp->fc_uid,
 122                 credp->fc_gid) < 0) {
 123         /*
 124          * If we fail to change ownership and if we are
 125          * using security model none. Ignore the error
 126          */
 127         if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
 128             return -1;
 129         }
 130     }
 131     return 0;
 132 }
 133
 134 static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
 135                               char *buf, size_t bufsz)
 136 {
 137     ssize_t tsize = -1;
 138     char buffer[PATH_MAX];
 139     char *path = fs_path->data;
 140
 141     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 142         int fd;
 143         fd = open(rpath(fs_ctx, path, buffer), O_RDONLY);
 144         if (fd == -1) {
 145             return -1;
 146         }
 147         do {
 148             tsize = read(fd, (void *)buf, bufsz);
 149         } while (tsize == -1 && errno == EINTR);
 150         close(fd);
 151         return tsize;
 152     } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 153                (fs_ctx->export_flags & V9FS_SM_NONE)) {
 154         tsize = readlink(rpath(fs_ctx, path, buffer), buf, bufsz);
 155     }
 156     return tsize;
 157 }
 158
 159 static int local_close(FsContext *ctx, V9fsFidOpenState *fs)
 160 {
 161     return close(fs->fd);
 162 }
 163
 164 static int local_closedir(FsContext *ctx, V9fsFidOpenState *fs)
 165 {
 166     return closedir(fs->dir);
 167 }
 168
 169 static int local_open(FsContext *ctx, V9fsPath *fs_path,
 170                       int flags, V9fsFidOpenState *fs)
 171 {
 172     char buffer[PATH_MAX];
 173     char *path = fs_path->data;
 174
 175     fs->fd = open(rpath(ctx, path, buffer), flags);
 176     return fs->fd;
 177 }
 178
 179 static int local_opendir(FsContext *ctx,
 180                          V9fsPath *fs_path, V9fsFidOpenState *fs)
 181 {
 182     char buffer[PATH_MAX];
 183     char *path = fs_path->data;
 184
 185     fs->dir = opendir(rpath(ctx, path, buffer));
 186     if (!fs->dir) {
 187         return -1;
 188     }
 189     return 0;
 190 }
 191
 192 static void local_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
 193 {
 194     return rewinddir(fs->dir);
 195 }
 196
 197 static off_t local_telldir(FsContext *ctx, V9fsFidOpenState *fs)
 198 {
 199     return telldir(fs->dir);
 200 }
 201
 202 static int local_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
 203                            struct dirent *entry,
 204                            struct dirent **result)
 205 {
 206     return readdir_r(fs->dir, entry, result);
 207 }
 208
 209 static void local_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
 210 {
 211     return seekdir(fs->dir, off);
 212 }
 213
 214 static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs,
 215                             const struct iovec *iov,
 216                             int iovcnt, off_t offset)
 217 {
 218 #ifdef CONFIG_PREADV
 219     return preadv(fs->fd, iov, iovcnt, offset);
 220 #else
 221     int err = lseek(fs->fd, offset, SEEK_SET);
 222     if (err == -1) {
 223         return err;
 224     } else {
 225         return readv(fs->fd, iov, iovcnt);
 226     }
 227 #endif
 228 }
 229
 230 static ssize_t local_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
 231                              const struct iovec *iov,
 232                              int iovcnt, off_t offset)
 233 {
 234     ssize_t ret
 235 ;
 236 #ifdef CONFIG_PREADV
 237     ret = pwritev(fs->fd, iov, iovcnt, offset);
 238 #else
 239     int err = lseek(fs->fd, offset, SEEK_SET);
 240     if (err == -1) {
 241         return err;
 242     } else {
 243         ret = writev(fs->fd, iov, iovcnt);
 244     }
 245 #endif
 246 #ifdef CONFIG_SYNC_FILE_RANGE
 247     if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
 248         /*
 249          * Initiate a writeback. This is not a data integrity sync.
 250          * We want to ensure that we don't leave dirty pages in the cache
 251          * after write when writeout=immediate is sepcified.
 252          */
 253         sync_file_range(fs->fd, offset, ret,
 254                         SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
 255     }
 256 #endif
 257     return ret;
 258 }
 259
 260 static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
 261 {
 262     char buffer[PATH_MAX];
 263     char *path = fs_path->data;
 264
 265     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 266         return local_set_xattr(rpath(fs_ctx, path, buffer), credp);
 267     } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 268                (fs_ctx->export_flags & V9FS_SM_NONE)) {
 269         return chmod(rpath(fs_ctx, path, buffer), credp->fc_mode);
 270     }
 271     return -1;
 272 }
 273
 274 static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
 275                        const char *name, FsCred *credp)
 276 {
 277     char *path;
 278     int err = -1;
 279     int serrno = 0;
 280     V9fsString fullname;
 281     char buffer[PATH_MAX];
 282
 283     v9fs_string_init(&fullname);
 284     v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
 285     path = fullname.data;
 286
 287     /* Determine the security model */
 288     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 289         err = mknod(rpath(fs_ctx, path, buffer),
 290                 SM_LOCAL_MODE_BITS|S_IFREG, 0);
 291         if (err == -1) {
 292             goto out;
 293         }
 294         err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
 295         if (err == -1) {
 296             serrno = errno;
 297             goto err_end;
 298         }
 299     } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 300                (fs_ctx->export_flags & V9FS_SM_NONE)) {
 301         err = mknod(rpath(fs_ctx, path, buffer), credp->fc_mode,
 302                 credp->fc_rdev);
 303         if (err == -1) {
 304             goto out;
 305         }
 306         err = local_post_create_passthrough(fs_ctx, path, credp);
 307         if (err == -1) {
 308             serrno = errno;
 309             goto err_end;
 310         }
 311     }
 312     goto out;
 313
 314 err_end:
 315     remove(rpath(fs_ctx, path, buffer));
 316     errno = serrno;
 317 out:
 318     v9fs_string_free(&fullname);
 319     return err;
 320 }
 321
 322 static int local_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
 323                        const char *name, FsCred *credp)
 324 {
 325     char *path;
 326     int err = -1;
 327     int serrno = 0;
 328     V9fsString fullname;
 329     char buffer[PATH_MAX];
 330
 331     v9fs_string_init(&fullname);
 332     v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
 333     path = fullname.data;
 334
 335     /* Determine the security model */
 336     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 337         err = mkdir(rpath(fs_ctx, path, buffer), SM_LOCAL_DIR_MODE_BITS);
 338         if (err == -1) {
 339             goto out;
 340         }
 341         credp->fc_mode = credp->fc_mode|S_IFDIR;
 342         err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
 343         if (err == -1) {
 344             serrno = errno;
 345             goto err_end;
 346         }
 347     } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 348                (fs_ctx->export_flags & V9FS_SM_NONE)) {
 349         err = mkdir(rpath(fs_ctx, path, buffer), credp->fc_mode);
 350         if (err == -1) {
 351             goto out;
 352         }
 353         err = local_post_create_passthrough(fs_ctx, path, credp);
 354         if (err == -1) {
 355             serrno = errno;
 356             goto err_end;
 357         }
 358     }
 359     goto out;
 360
 361 err_end:
 362     remove(rpath(fs_ctx, path, buffer));
 363     errno = serrno;
 364 out:
 365     v9fs_string_free(&fullname);
 366     return err;
 367 }
 368
 369 static int local_fstat(FsContext *fs_ctx,
 370                        V9fsFidOpenState *fs, struct stat *stbuf)
 371 {
 372     int err;
 373     err = fstat(fs->fd, stbuf);
 374     if (err) {
 375         return err;
 376     }
 377     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 378         /* Actual credentials are part of extended attrs */
 379         uid_t tmp_uid;
 380         gid_t tmp_gid;
 381         mode_t tmp_mode;
 382         dev_t tmp_dev;
 383
 384         if (fgetxattr(fs->fd, "user.virtfs.uid",
 385                       &tmp_uid, sizeof(uid_t)) > 0) {
 386             stbuf->st_uid = tmp_uid;
 387         }
 388         if (fgetxattr(fs->fd, "user.virtfs.gid",
 389                       &tmp_gid, sizeof(gid_t)) > 0) {
 390             stbuf->st_gid = tmp_gid;
 391         }
 392         if (fgetxattr(fs->fd, "user.virtfs.mode",
 393                       &tmp_mode, sizeof(mode_t)) > 0) {
 394             stbuf->st_mode = tmp_mode;
 395         }
 396         if (fgetxattr(fs->fd, "user.virtfs.rdev",
 397                       &tmp_dev, sizeof(dev_t)) > 0) {
 398                 stbuf->st_rdev = tmp_dev;
 399         }
 400     }
 401     return err;
 402 }
 403
 404 static int local_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
 405                        int flags, FsCred *credp, V9fsFidOpenState *fs)
 406 {
 407     char *path;
 408     int fd = -1;
 409     int err = -1;
 410     int serrno = 0;
 411     V9fsString fullname;
 412     char buffer[PATH_MAX];
 413
 414     v9fs_string_init(&fullname);
 415     v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
 416     path = fullname.data;
 417
 418     /* Determine the security model */
 419     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 420         fd = open(rpath(fs_ctx, path, buffer), flags, SM_LOCAL_MODE_BITS);
 421         if (fd == -1) {
 422             err = fd;
 423             goto out;
 424         }
 425         credp->fc_mode = credp->fc_mode|S_IFREG;
 426         /* Set cleint credentials in xattr */
 427         err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
 428         if (err == -1) {
 429             serrno = errno;
 430             goto err_end;
 431         }
 432     } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 433                (fs_ctx->export_flags & V9FS_SM_NONE)) {
 434         fd = open(rpath(fs_ctx, path, buffer), flags, credp->fc_mode);
 435         if (fd == -1) {
 436             err = fd;
 437             goto out;
 438         }
 439         err = local_post_create_passthrough(fs_ctx, path, credp);
 440         if (err == -1) {
 441             serrno = errno;
 442             goto err_end;
 443         }
 444     }
 445     err = fd;
 446     fs->fd = fd;
 447     goto out;
 448
 449 err_end:
 450     close(fd);
 451     remove(rpath(fs_ctx, path, buffer));
 452     errno = serrno;
 453 out:
 454     v9fs_string_free(&fullname);
 455     return err;
 456 }
 457
 458
 459 static int local_symlink(FsContext *fs_ctx, const char *oldpath,
 460                          V9fsPath *dir_path, const char *name, FsCred *credp)
 461 {
 462     int err = -1;
 463     int serrno = 0;
 464     char *newpath;
 465     V9fsString fullname;
 466     char buffer[PATH_MAX];
 467
 468     v9fs_string_init(&fullname);
 469     v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
 470     newpath = fullname.data;
 471
 472     /* Determine the security model */
 473     if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 474         int fd;
 475         ssize_t oldpath_size, write_size;
 476         fd = open(rpath(fs_ctx, newpath, buffer), O_CREAT|O_EXCL|O_RDWR,
 477                 SM_LOCAL_MODE_BITS);
 478         if (fd == -1) {
 479             err = fd;
 480             goto out;
 481         }
 482         /* Write the oldpath (target) to the file. */
 483         oldpath_size = strlen(oldpath);
 484         do {
 485             write_size = write(fd, (void *)oldpath, oldpath_size);
 486         } while (write_size == -1 && errno == EINTR);
 487
 488         if (write_size != oldpath_size) {
 489             serrno = errno;
 490             close(fd);
 491             err = -1;
 492             goto err_end;
 493         }
 494         close(fd);
 495         /* Set cleint credentials in symlink's xattr */
 496         credp->fc_mode = credp->fc_mode|S_IFLNK;
 497         err = local_set_xattr(rpath(fs_ctx, newpath, buffer), credp);
 498         if (err == -1) {
 499             serrno = errno;
 500             goto err_end;
 501         }
 502     } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 503                (fs_ctx->export_flags & V9FS_SM_NONE)) {
 504         err = symlink(oldpath, rpath(fs_ctx, newpath, buffer));
 505         if (err) {
 506             goto out;
 507         }
 508         err = lchown(rpath(fs_ctx, newpath, buffer), credp->fc_uid,
 509                      credp->fc_gid);
 510         if (err == -1) {
 511             /*
 512              * If we fail to change ownership and if we are
 513              * using security model none. Ignore the error
 514              */
 515             if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) {
 516                 serrno = errno;
 517                 goto err_end;
 518             } else
 519                 err = 0;
 520         }
 521     }
 522     goto out;
 523
 524 err_end:
 525     remove(rpath(fs_ctx, newpath, buffer));
 526     errno = serrno;
 527 out:
 528     v9fs_string_free(&fullname);
 529     return err;
 530 }
 531
 532 static int local_link(FsContext *ctx, V9fsPath *oldpath,
 533                       V9fsPath *dirpath, const char *name)
 534 {
 535     int ret;
 536     V9fsString newpath;
 537     char buffer[PATH_MAX], buffer1[PATH_MAX];
 538
 539     v9fs_string_init(&newpath);
 540     v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name);
 541
 542     ret = link(rpath(ctx, oldpath->data, buffer),
 543                rpath(ctx, newpath.data, buffer1));
 544     v9fs_string_free(&newpath);
 545     return ret;
 546 }
 547
 548 static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
 549 {
 550     char buffer[PATH_MAX];
 551     char *path = fs_path->data;
 552
 553     return truncate(rpath(ctx, path, buffer), size);
 554 }
 555
 556 static int local_rename(FsContext *ctx, const char *oldpath,
 557                         const char *newpath)
 558 {
 559     char buffer[PATH_MAX], buffer1[PATH_MAX];
 560
 561     return rename(rpath(ctx, oldpath, buffer), rpath(ctx, newpath, buffer1));
 562 }
 563
 564 static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
 565 {
 566     char buffer[PATH_MAX];
 567     char *path = fs_path->data;
 568
 569     if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
 570         (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
 571         (fs_ctx->export_flags & V9FS_SM_NONE)) {
 572         return lchown(rpath(fs_ctx, path, buffer),
 573                       credp->fc_uid, credp->fc_gid);
 574     } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
 575         return local_set_xattr(rpath(fs_ctx, path, buffer), credp);
 576     }
 577     return -1;
 578 }
 579
 580 static int local_utimensat(FsContext *s, V9fsPath *fs_path,
 581                            const struct timespec *buf)
 582 {
 583     char buffer[PATH_MAX];
 584     char *path = fs_path->data;
 585
 586     return qemu_utimensat(AT_FDCWD, rpath(s, path, buffer), buf,
 587                           AT_SYMLINK_NOFOLLOW);
 588 }
 589
 590 static int local_remove(FsContext *ctx, const char *path)
 591 {
 592     char buffer[PATH_MAX];
 593     return remove(rpath(ctx, path, buffer));
 594 }
 595
 596 static int local_fsync(FsContext *ctx, V9fsFidOpenState *fs, int datasync)
 597 {
 598     if (datasync) {
 599         return qemu_fdatasync(fs->fd);
 600     } else {
 601         return fsync(fs->fd);
 602     }
 603 }
 604
 605 static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
 606 {
 607     char buffer[PATH_MAX];
 608     char *path = fs_path->data;
 609
 610     return statfs(rpath(s, path, buffer), stbuf);
 611 }
 612
 613 static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
 614                                const char *name, void *value, size_t size)
 615 {
 616     char *path = fs_path->data;
 617
 618     return v9fs_get_xattr(ctx, path, name, value, size);
 619 }
 620
 621 static ssize_t local_llistxattr(FsContext *ctx, V9fsPath *fs_path,
 622                                 void *value, size_t size)
 623 {
 624     char *path = fs_path->data;
 625
 626     return v9fs_list_xattr(ctx, path, value, size);
 627 }
 628
 629 static int local_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
 630                            void *value, size_t size, int flags)
 631 {
 632     char *path = fs_path->data;
 633
 634     return v9fs_set_xattr(ctx, path, name, value, size, flags);
 635 }
 636
 637 static int local_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
 638                               const char *name)
 639 {
 640     char *path = fs_path->data;
 641
 642     return v9fs_remove_xattr(ctx, path, name);
 643 }
 644
 645 static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path,
 646                               const char *name, V9fsPath *target)
 647 {
 648     if (dir_path) {
 649         v9fs_string_sprintf((V9fsString *)target, "%s/%s",
 650                             dir_path->data, name);
 651     } else {
 652         v9fs_string_sprintf((V9fsString *)target, "%s", name);
 653     }
 654     /* Bump the size for including terminating NULL */
 655     target->size++;
 656     return 0;
 657 }
 658
 659 static int local_renameat(FsContext *ctx, V9fsPath *olddir,
 660                           const char *old_name, V9fsPath *newdir,
 661                           const char *new_name)
 662 {
 663     int ret;
 664     V9fsString old_full_name, new_full_name;
 665
 666     v9fs_string_init(&old_full_name);
 667     v9fs_string_init(&new_full_name);
 668
 669     v9fs_string_sprintf(&old_full_name, "%s/%s", olddir->data, old_name);
 670     v9fs_string_sprintf(&new_full_name, "%s/%s", newdir->data, new_name);
 671
 672     ret = local_rename(ctx, old_full_name.data, new_full_name.data);
 673     v9fs_string_free(&old_full_name);
 674     v9fs_string_free(&new_full_name);
 675     return ret;
 676 }
 677
 678 static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
 679                           const char *name, int flags)
 680 {
 681     int ret;
 682     V9fsString fullname;
 683     char buffer[PATH_MAX];
 684     v9fs_string_init(&fullname);
 685
 686     v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);
 687     ret = remove(rpath(ctx, fullname.data, buffer));
 688     v9fs_string_free(&fullname);
 689
 690     return ret;
 691 }
 692
 693 static int local_ioc_getversion(FsContext *ctx, V9fsPath *path,
 694                                 mode_t st_mode, uint64_t *st_gen)
 695 {
 696     int err;
 697     V9fsFidOpenState fid_open;
 698
 699     /*
 700      * Do not try to open special files like device nodes, fifos etc
 701      * We can get fd for regular files and directories only
 702      */
 703     if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
 704             return 0;
 705     }
 706     err = local_open(ctx, path, O_RDONLY, &fid_open);
 707     if (err < 0) {
 708         return err;
 709     }
 710     err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
 711     local_close(ctx, &fid_open);
 712     return err;
 713 }
 714
 715 static int local_init(FsContext *ctx)
 716 {
 717     int err;
 718     struct statfs stbuf;
 719
 720     ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT;
 721     err = statfs(ctx->fs_root, &stbuf);
 722     if (!err) {
 723         switch (stbuf.f_type) {
 724         case EXT2_SUPER_MAGIC:
 725         case BTRFS_SUPER_MAGIC:
 726         case REISERFS_SUPER_MAGIC:
 727         case XFS_SUPER_MAGIC:
 728             ctx->exops.get_st_gen = local_ioc_getversion;
 729             break;
 730         }
 731     }
 732     return err;
 733 }
 734
 735 FileOperations local_ops = {
 736     .init  = local_init,
 737     .lstat = local_lstat,
 738     .readlink = local_readlink,
 739     .close = local_close,
 740     .closedir = local_closedir,
 741     .open = local_open,
 742     .opendir = local_opendir,
 743     .rewinddir = local_rewinddir,
 744     .telldir = local_telldir,
 745     .readdir_r = local_readdir_r,
 746     .seekdir = local_seekdir,
 747     .preadv = local_preadv,
 748     .pwritev = local_pwritev,
 749     .chmod = local_chmod,
 750     .mknod = local_mknod,
 751     .mkdir = local_mkdir,
 752     .fstat = local_fstat,
 753     .open2 = local_open2,
 754     .symlink = local_symlink,
 755     .link = local_link,
 756     .truncate = local_truncate,
 757     .rename = local_rename,
 758     .chown = local_chown,
 759     .utimensat = local_utimensat,
 760     .remove = local_remove,
 761     .fsync = local_fsync,
 762     .statfs = local_statfs,
 763     .lgetxattr = local_lgetxattr,
 764     .llistxattr = local_llistxattr,
 765     .lsetxattr = local_lsetxattr,
 766     .lremovexattr = local_lremovexattr,
 767     .name_to_path = local_name_to_path,
 768     .renameat  = local_renameat,
 769     .unlinkat = local_unlinkat,
 770 };