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

   1 /*
   2  * Virtio 9p handle callback
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *    Aneesh Kumar K.V <aneesh.kumar@linux.vnet.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/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 "qemu/xattr.h"
  23 #include <unistd.h>
  24 #include <linux/fs.h>
  25 #ifdef CONFIG_LINUX_MAGIC_H
  26 #include <linux/magic.h>
  27 #endif
  28 #include <sys/ioctl.h>
  29
  30 #ifndef XFS_SUPER_MAGIC
  31 #define XFS_SUPER_MAGIC  0x58465342
  32 #endif
  33 #ifndef EXT2_SUPER_MAGIC
  34 #define EXT2_SUPER_MAGIC 0xEF53
  35 #endif
  36 #ifndef REISERFS_SUPER_MAGIC
  37 #define REISERFS_SUPER_MAGIC 0x52654973
  38 #endif
  39 #ifndef BTRFS_SUPER_MAGIC
  40 #define BTRFS_SUPER_MAGIC 0x9123683E
  41 #endif
  42
  43 struct handle_data {
  44     int mountfd;
  45     int handle_bytes;
  46 };
  47
  48 static inline int name_to_handle(int dirfd, const char *name,
  49                                  struct file_handle *fh, int *mnt_id, int flags)
  50 {
  51     return name_to_handle_at(dirfd, name, fh, mnt_id, flags);
  52 }
  53
  54 static inline int open_by_handle(int mountfd, const char *fh, int flags)
  55 {
  56     return open_by_handle_at(mountfd, (struct file_handle *)fh, flags);
  57 }
  58
  59 static int handle_update_file_cred(int dirfd, const char *name, FsCred *credp)
  60 {
  61     int fd, ret;
  62     fd = openat(dirfd, name, O_NONBLOCK | O_NOFOLLOW);
  63     if (fd < 0) {
  64         return fd;
  65     }
  66     ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
  67     if (ret < 0) {
  68         goto err_out;
  69     }
  70     ret = fchmod(fd, credp->fc_mode & 07777);
  71 err_out:
  72     close(fd);
  73     return ret;
  74 }
  75
  76
  77 static int handle_lstat(FsContext *fs_ctx, V9fsPath *fs_path,
  78                         struct stat *stbuf)
  79 {
  80     int fd, ret;
  81     struct handle_data *data = (struct handle_data *)fs_ctx->private;
  82
  83     fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
  84     if (fd < 0) {
  85         return fd;
  86     }
  87     ret = fstatat(fd, "", stbuf, AT_EMPTY_PATH);
  88     close(fd);
  89     return ret;
  90 }
  91
  92 static ssize_t handle_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
  93                                char *buf, size_t bufsz)
  94 {
  95     int fd, ret;
  96     struct handle_data *data = (struct handle_data *)fs_ctx->private;
  97
  98     fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
  99     if (fd < 0) {
 100         return fd;
 101     }
 102     ret = readlinkat(fd, "", buf, bufsz);
 103     close(fd);
 104     return ret;
 105 }
 106
 107 static int handle_close(FsContext *ctx, V9fsFidOpenState *fs)
 108 {
 109     return close(fs->fd);
 110 }
 111
 112 static int handle_closedir(FsContext *ctx, V9fsFidOpenState *fs)
 113 {
 114     return closedir(fs->dir);
 115 }
 116
 117 static int handle_open(FsContext *ctx, V9fsPath *fs_path,
 118                        int flags, V9fsFidOpenState *fs)
 119 {
 120     struct handle_data *data = (struct handle_data *)ctx->private;
 121
 122     fs->fd = open_by_handle(data->mountfd, fs_path->data, flags);
 123     return fs->fd;
 124 }
 125
 126 static int handle_opendir(FsContext *ctx,
 127                           V9fsPath *fs_path, V9fsFidOpenState *fs)
 128 {
 129     int ret;
 130     ret = handle_open(ctx, fs_path, O_DIRECTORY, fs);
 131     if (ret < 0) {
 132         return -1;
 133     }
 134     fs->dir = fdopendir(ret);
 135     if (!fs->dir) {
 136         return -1;
 137     }
 138     return 0;
 139 }
 140
 141 static void handle_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
 142 {
 143     rewinddir(fs->dir);
 144 }
 145
 146 static off_t handle_telldir(FsContext *ctx, V9fsFidOpenState *fs)
 147 {
 148     return telldir(fs->dir);
 149 }
 150
 151 static int handle_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
 152                             struct dirent *entry,
 153                             struct dirent **result)
 154 {
 155     return readdir_r(fs->dir, entry, result);
 156 }
 157
 158 static void handle_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
 159 {
 160     seekdir(fs->dir, off);
 161 }
 162
 163 static ssize_t handle_preadv(FsContext *ctx, V9fsFidOpenState *fs,
 164                              const struct iovec *iov,
 165                              int iovcnt, off_t offset)
 166 {
 167 #ifdef CONFIG_PREADV
 168     return preadv(fs->fd, iov, iovcnt, offset);
 169 #else
 170     int err = lseek(fs->fd, offset, SEEK_SET);
 171     if (err == -1) {
 172         return err;
 173     } else {
 174         return readv(fs->fd, iov, iovcnt);
 175     }
 176 #endif
 177 }
 178
 179 static ssize_t handle_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
 180                               const struct iovec *iov,
 181                               int iovcnt, off_t offset)
 182 {
 183     ssize_t ret;
 184 #ifdef CONFIG_PREADV
 185     ret = pwritev(fs->fd, iov, iovcnt, offset);
 186 #else
 187     int err = lseek(fs->fd, offset, SEEK_SET);
 188     if (err == -1) {
 189         return err;
 190     } else {
 191         ret = writev(fs->fd, iov, iovcnt);
 192     }
 193 #endif
 194 #ifdef CONFIG_SYNC_FILE_RANGE
 195     if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
 196         /*
 197          * Initiate a writeback. This is not a data integrity sync.
 198          * We want to ensure that we don't leave dirty pages in the cache
 199          * after write when writeout=immediate is sepcified.
 200          */
 201         sync_file_range(fs->fd, offset, ret,
 202                         SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
 203     }
 204 #endif
 205     return ret;
 206 }
 207
 208 static int handle_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
 209 {
 210     int fd, ret;
 211     struct handle_data *data = (struct handle_data *)fs_ctx->private;
 212
 213     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 214     if (fd < 0) {
 215         return fd;
 216     }
 217     ret = fchmod(fd, credp->fc_mode);
 218     close(fd);
 219     return ret;
 220 }
 221
 222 static int handle_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
 223                        const char *name, FsCred *credp)
 224 {
 225     int dirfd, ret;
 226     struct handle_data *data = (struct handle_data *)fs_ctx->private;
 227
 228     dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
 229     if (dirfd < 0) {
 230         return dirfd;
 231     }
 232     ret = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
 233     if (!ret) {
 234         ret = handle_update_file_cred(dirfd, name, credp);
 235     }
 236     close(dirfd);
 237     return ret;
 238 }
 239
 240 static int handle_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
 241                        const char *name, FsCred *credp)
 242 {
 243     int dirfd, ret;
 244     struct handle_data *data = (struct handle_data *)fs_ctx->private;
 245
 246     dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
 247     if (dirfd < 0) {
 248         return dirfd;
 249     }
 250     ret = mkdirat(dirfd, name, credp->fc_mode);
 251     if (!ret) {
 252         ret = handle_update_file_cred(dirfd, name, credp);
 253     }
 254     close(dirfd);
 255     return ret;
 256 }
 257
 258 static int handle_fstat(FsContext *fs_ctx, int fid_type,
 259                         V9fsFidOpenState *fs, struct stat *stbuf)
 260 {
 261     int fd;
 262
 263     if (fid_type == P9_FID_DIR) {
 264         fd = dirfd(fs->dir);
 265     } else {
 266         fd = fs->fd;
 267     }
 268     return fstat(fd, stbuf);
 269 }
 270
 271 static int handle_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
 272                         int flags, FsCred *credp, V9fsFidOpenState *fs)
 273 {
 274     int ret;
 275     int dirfd, fd;
 276     struct handle_data *data = (struct handle_data *)fs_ctx->private;
 277
 278     dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
 279     if (dirfd < 0) {
 280         return dirfd;
 281     }
 282     fd = openat(dirfd, name, flags | O_NOFOLLOW, credp->fc_mode);
 283     if (fd >= 0) {
 284         ret = handle_update_file_cred(dirfd, name, credp);
 285         if (ret < 0) {
 286             close(fd);
 287             fd = ret;
 288         } else {
 289             fs->fd = fd;
 290         }
 291     }
 292     close(dirfd);
 293     return fd;
 294 }
 295
 296
 297 static int handle_symlink(FsContext *fs_ctx, const char *oldpath,
 298                           V9fsPath *dir_path, const char *name, FsCred *credp)
 299 {
 300     int fd, dirfd, ret;
 301     struct handle_data *data = (struct handle_data *)fs_ctx->private;
 302
 303     dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
 304     if (dirfd < 0) {
 305         return dirfd;
 306     }
 307     ret = symlinkat(oldpath, dirfd, name);
 308     if (!ret) {
 309         fd = openat(dirfd, name, O_PATH | O_NOFOLLOW);
 310         if (fd < 0) {
 311             ret = fd;
 312             goto err_out;
 313         }
 314         ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
 315         close(fd);
 316     }
 317 err_out:
 318     close(dirfd);
 319     return ret;
 320 }
 321
 322 static int handle_link(FsContext *ctx, V9fsPath *oldpath,
 323                        V9fsPath *dirpath, const char *name)
 324 {
 325     int oldfd, newdirfd, ret;
 326     struct handle_data *data = (struct handle_data *)ctx->private;
 327
 328     oldfd = open_by_handle(data->mountfd, oldpath->data, O_PATH);
 329     if (oldfd < 0) {
 330         return oldfd;
 331     }
 332     newdirfd = open_by_handle(data->mountfd, dirpath->data, O_PATH);
 333     if (newdirfd < 0) {
 334         close(oldfd);
 335         return newdirfd;
 336     }
 337     ret = linkat(oldfd, "", newdirfd, name, AT_EMPTY_PATH);
 338     close(newdirfd);
 339     close(oldfd);
 340     return ret;
 341 }
 342
 343 static int handle_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
 344 {
 345     int fd, ret;
 346     struct handle_data *data = (struct handle_data *)ctx->private;
 347
 348     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK | O_WRONLY);
 349     if (fd < 0) {
 350         return fd;
 351     }
 352     ret = ftruncate(fd, size);
 353     close(fd);
 354     return ret;
 355 }
 356
 357 static int handle_rename(FsContext *ctx, const char *oldpath,
 358                          const char *newpath)
 359 {
 360     errno = EOPNOTSUPP;
 361     return -1;
 362 }
 363
 364 static int handle_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
 365 {
 366     int fd, ret;
 367     struct handle_data *data = (struct handle_data *)fs_ctx->private;
 368
 369     fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
 370     if (fd < 0) {
 371         return fd;
 372     }
 373     ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
 374     close(fd);
 375     return ret;
 376 }
 377
 378 static int handle_utimensat(FsContext *ctx, V9fsPath *fs_path,
 379                             const struct timespec *buf)
 380 {
 381     int ret;
 382 #ifdef CONFIG_UTIMENSAT
 383     int fd;
 384     struct handle_data *data = (struct handle_data *)ctx->private;
 385
 386     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 387     if (fd < 0) {
 388         return fd;
 389     }
 390     ret = futimens(fd, buf);
 391     close(fd);
 392 #else
 393     ret = -1;
 394     errno = ENOSYS;
 395 #endif
 396     return ret;
 397 }
 398
 399 static int handle_remove(FsContext *ctx, const char *path)
 400 {
 401     errno = EOPNOTSUPP;
 402     return -1;
 403 }
 404
 405 static int handle_fsync(FsContext *ctx, int fid_type,
 406                         V9fsFidOpenState *fs, int datasync)
 407 {
 408     int fd;
 409
 410     if (fid_type == P9_FID_DIR) {
 411         fd = dirfd(fs->dir);
 412     } else {
 413         fd = fs->fd;
 414     }
 415
 416     if (datasync) {
 417         return qemu_fdatasync(fd);
 418     } else {
 419         return fsync(fd);
 420     }
 421 }
 422
 423 static int handle_statfs(FsContext *ctx, V9fsPath *fs_path,
 424                          struct statfs *stbuf)
 425 {
 426     int fd, ret;
 427     struct handle_data *data = (struct handle_data *)ctx->private;
 428
 429     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 430     if (fd < 0) {
 431         return fd;
 432     }
 433     ret = fstatfs(fd, stbuf);
 434     close(fd);
 435     return ret;
 436 }
 437
 438 static ssize_t handle_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
 439                                 const char *name, void *value, size_t size)
 440 {
 441     int fd, ret;
 442     struct handle_data *data = (struct handle_data *)ctx->private;
 443
 444     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 445     if (fd < 0) {
 446         return fd;
 447     }
 448     ret = fgetxattr(fd, name, value, size);
 449     close(fd);
 450     return ret;
 451 }
 452
 453 static ssize_t handle_llistxattr(FsContext *ctx, V9fsPath *fs_path,
 454                                  void *value, size_t size)
 455 {
 456     int fd, ret;
 457     struct handle_data *data = (struct handle_data *)ctx->private;
 458
 459     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 460     if (fd < 0) {
 461         return fd;
 462     }
 463     ret = flistxattr(fd, value, size);
 464     close(fd);
 465     return ret;
 466 }
 467
 468 static int handle_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
 469                             void *value, size_t size, int flags)
 470 {
 471     int fd, ret;
 472     struct handle_data *data = (struct handle_data *)ctx->private;
 473
 474     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 475     if (fd < 0) {
 476         return fd;
 477     }
 478     ret = fsetxattr(fd, name, value, size, flags);
 479     close(fd);
 480     return ret;
 481 }
 482
 483 static int handle_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
 484                                const char *name)
 485 {
 486     int fd, ret;
 487     struct handle_data *data = (struct handle_data *)ctx->private;
 488
 489     fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
 490     if (fd < 0) {
 491         return fd;
 492     }
 493     ret = fremovexattr(fd, name);
 494     close(fd);
 495     return ret;
 496 }
 497
 498 static int handle_name_to_path(FsContext *ctx, V9fsPath *dir_path,
 499                               const char *name, V9fsPath *target)
 500 {
 501     char *buffer;
 502     struct file_handle *fh;
 503     int dirfd, ret, mnt_id;
 504     struct handle_data *data = (struct handle_data *)ctx->private;
 505
 506     /* "." and ".." are not allowed */
 507     if (!strcmp(name, ".") || !strcmp(name, "..")) {
 508         errno = EINVAL;
 509         return -1;
 510
 511     }
 512     if (dir_path) {
 513         dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
 514     } else {
 515         /* relative to export root */
 516         buffer = rpath(ctx, ".");
 517         dirfd = open(buffer, O_DIRECTORY);
 518         g_free(buffer);
 519     }
 520     if (dirfd < 0) {
 521         return dirfd;
 522     }
 523     fh = g_malloc(sizeof(struct file_handle) + data->handle_bytes);
 524     fh->handle_bytes = data->handle_bytes;
 525     /* add a "./" at the beginning of the path */
 526     buffer = g_strdup_printf("./%s", name);
 527     /* flag = 0 imply don't follow symlink */
 528     ret = name_to_handle(dirfd, buffer, fh, &mnt_id, 0);
 529     if (!ret) {
 530         target->data = (char *)fh;
 531         target->size = sizeof(struct file_handle) + data->handle_bytes;
 532     } else {
 533         g_free(fh);
 534     }
 535     close(dirfd);
 536     g_free(buffer);
 537     return ret;
 538 }
 539
 540 static int handle_renameat(FsContext *ctx, V9fsPath *olddir,
 541                            const char *old_name, V9fsPath *newdir,
 542                            const char *new_name)
 543 {
 544     int olddirfd, newdirfd, ret;
 545     struct handle_data *data = (struct handle_data *)ctx->private;
 546
 547     olddirfd = open_by_handle(data->mountfd, olddir->data, O_PATH);
 548     if (olddirfd < 0) {
 549         return olddirfd;
 550     }
 551     newdirfd = open_by_handle(data->mountfd, newdir->data, O_PATH);
 552     if (newdirfd < 0) {
 553         close(olddirfd);
 554         return newdirfd;
 555     }
 556     ret = renameat(olddirfd, old_name, newdirfd, new_name);
 557     close(newdirfd);
 558     close(olddirfd);
 559     return ret;
 560 }
 561
 562 static int handle_unlinkat(FsContext *ctx, V9fsPath *dir,
 563                            const char *name, int flags)
 564 {
 565     int dirfd, ret;
 566     struct handle_data *data = (struct handle_data *)ctx->private;
 567     int rflags;
 568
 569     dirfd = open_by_handle(data->mountfd, dir->data, O_PATH);
 570     if (dirfd < 0) {
 571         return dirfd;
 572     }
 573
 574     rflags = 0;
 575     if (flags & P9_DOTL_AT_REMOVEDIR) {
 576         rflags |= AT_REMOVEDIR;
 577     }
 578
 579     ret = unlinkat(dirfd, name, rflags);
 580
 581     close(dirfd);
 582     return ret;
 583 }
 584
 585 static int handle_ioc_getversion(FsContext *ctx, V9fsPath *path,
 586                                  mode_t st_mode, uint64_t *st_gen)
 587 {
 588 #ifdef FS_IOC_GETVERSION
 589     int err;
 590     V9fsFidOpenState fid_open;
 591
 592     /*
 593      * Do not try to open special files like device nodes, fifos etc
 594      * We can get fd for regular files and directories only
 595      */
 596     if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
 597         errno = ENOTTY;
 598         return -1;
 599     }
 600     err = handle_open(ctx, path, O_RDONLY, &fid_open);
 601     if (err < 0) {
 602         return err;
 603     }
 604     err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
 605     handle_close(ctx, &fid_open);
 606     return err;
 607 #else
 608     errno = ENOTTY;
 609     return -1;
 610 #endif
 611 }
 612
 613 static int handle_init(FsContext *ctx)
 614 {
 615     int ret, mnt_id;
 616     struct statfs stbuf;
 617     struct file_handle fh;
 618     struct handle_data *data = g_malloc(sizeof(struct handle_data));
 619
 620     data->mountfd = open(ctx->fs_root, O_DIRECTORY);
 621     if (data->mountfd < 0) {
 622         ret = data->mountfd;
 623         goto err_out;
 624     }
 625     ret = statfs(ctx->fs_root, &stbuf);
 626     if (!ret) {
 627         switch (stbuf.f_type) {
 628         case EXT2_SUPER_MAGIC:
 629         case BTRFS_SUPER_MAGIC:
 630         case REISERFS_SUPER_MAGIC:
 631         case XFS_SUPER_MAGIC:
 632             ctx->exops.get_st_gen = handle_ioc_getversion;
 633             break;
 634         }
 635     }
 636     memset(&fh, 0, sizeof(struct file_handle));
 637     ret = name_to_handle(data->mountfd, ".", &fh, &mnt_id, 0);
 638     if (ret && errno == EOVERFLOW) {
 639         data->handle_bytes = fh.handle_bytes;
 640         ctx->private = data;
 641         ret = 0;
 642         goto out;
 643     }
 644     /* we got 0 byte handle ? */
 645     ret = -1;
 646     close(data->mountfd);
 647 err_out:
 648     g_free(data);
 649 out:
 650     return ret;
 651 }
 652
 653 static int handle_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
 654 {
 655     const char *sec_model = qemu_opt_get(opts, "security_model");
 656     const char *path = qemu_opt_get(opts, "path");
 657
 658     if (sec_model) {
 659         fprintf(stderr, "Invalid argument security_model specified with handle fsdriver\n");
 660         return -1;
 661     }
 662
 663     if (!path) {
 664         fprintf(stderr, "fsdev: No path specified.\n");
 665         return -1;
 666     }
 667     fse->path = g_strdup(path);
 668     return 0;
 669
 670 }
 671
 672 FileOperations handle_ops = {
 673     .parse_opts   = handle_parse_opts,
 674     .init         = handle_init,
 675     .lstat        = handle_lstat,
 676     .readlink     = handle_readlink,
 677     .close        = handle_close,
 678     .closedir     = handle_closedir,
 679     .open         = handle_open,
 680     .opendir      = handle_opendir,
 681     .rewinddir    = handle_rewinddir,
 682     .telldir      = handle_telldir,
 683     .readdir_r    = handle_readdir_r,
 684     .seekdir      = handle_seekdir,
 685     .preadv       = handle_preadv,
 686     .pwritev      = handle_pwritev,
 687     .chmod        = handle_chmod,
 688     .mknod        = handle_mknod,
 689     .mkdir        = handle_mkdir,
 690     .fstat        = handle_fstat,
 691     .open2        = handle_open2,
 692     .symlink      = handle_symlink,
 693     .link         = handle_link,
 694     .truncate     = handle_truncate,
 695     .rename       = handle_rename,
 696     .chown        = handle_chown,
 697     .utimensat    = handle_utimensat,
 698     .remove       = handle_remove,
 699     .fsync        = handle_fsync,
 700     .statfs       = handle_statfs,
 701     .lgetxattr    = handle_lgetxattr,
 702     .llistxattr   = handle_llistxattr,
 703     .lsetxattr    = handle_lsetxattr,
 704     .lremovexattr = handle_lremovexattr,
 705     .name_to_path = handle_name_to_path,
 706     .renameat     = handle_renameat,
 707     .unlinkat     = handle_unlinkat,
 708 };