sys/vfs/fuse/fuse_vfsops.c

   1 /*-
   2  * Copyright (c) 2019 Tomohiro Kusumi <tkusumi@netbsd.org>
   3  * Copyright (c) 2019 The DragonFly Project
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include "fuse.h"
  29
  30 #include <sys/device.h>
  31 #include <sys/devfs.h>
  32 #include <sys/nlookup.h>
  33 #include <sys/file.h>
  34 #include <sys/sysctl.h>
  35 #include <sys/statvfs.h>
  36 #include <sys/caps.h>
  37 #include <sys/spinlock.h>
  38
  39 #include <sys/spinlock2.h>
  40
  41 int fuse_debug = 0;
  42
  43 SYSCTL_NODE(_vfs, OID_AUTO, fuse, CTLFLAG_RD, 0, "FUSE");
  44
  45 SYSCTL_INT(_vfs_fuse, OID_AUTO, version_major, CTLFLAG_RD, NULL,
  46     FUSE_KERNEL_VERSION, "FUSE kernel version (major)");
  47 SYSCTL_INT(_vfs_fuse, OID_AUTO, version_minor, CTLFLAG_RD, NULL,
  48     FUSE_KERNEL_MINOR_VERSION, "FUSE kernel version (minor)");
  49
  50 SYSCTL_INT(_vfs_fuse, OID_AUTO, debug, CTLFLAG_RW, &fuse_debug, 1, "");
  51
  52 int
  53 fuse_cmp_version(struct fuse_mount *fmp, uint32_t major, uint32_t minor)
  54 {
  55         if (fmp->abi_major == major && fmp->abi_minor == minor)
  56                 return 0;
  57
  58         if (fmp->abi_major > major ||
  59             (fmp->abi_major == major && fmp->abi_minor > minor))
  60                 return 1;
  61
  62         return -1;
  63 }
  64
  65 int
  66 fuse_mount_kill(struct fuse_mount *fmp)
  67 {
  68         if (!fuse_test_dead(fmp)) {
  69                 fuse_set_dead(fmp);
  70                 wakeup(fmp);
  71                 KNOTE(&fmp->kq.ki_note, 0);
  72                 return 0;
  73         }
  74
  75         return -1;
  76 }
  77
  78 int
  79 fuse_mount_free(struct fuse_mount *fmp)
  80 {
  81         if (refcount_release(&fmp->refcnt)) {
  82                 fuse_dbg("fmp=%p free\n", fmp);
  83                 mtx_uninit(&fmp->ipc_lock);
  84                 mtx_uninit(&fmp->mnt_lock);
  85                 mtx_uninit(&fmp->ino_lock);
  86                 crfree(fmp->cred);
  87                 kfree(fmp, M_TEMP);
  88                 return 0;
  89         }
  90         fuse_dbg("fmp=%p %u refcnt left\n", fmp, fmp->refcnt);
  91
  92         return -1;
  93 }
  94
  95 static int
  96 fuse_mount(struct mount *mp, char *mntpt, caddr_t data, struct ucred *cred)
  97 {
  98         struct statfs *sbp = &mp->mnt_stat;
  99         struct vnode *devvp;
 100         struct file *file;
 101         struct nlookupdata nd;
 102         struct fuse_mount_info args;
 103         struct fuse_mount *fmp;
 104         struct fuse_ipc *fip;
 105         struct fuse_init_in *fii;
 106         struct fuse_init_out *fio;
 107         char subtype[512];
 108         int error;
 109
 110         if (mp->mnt_flag & MNT_UPDATE)
 111                 return EOPNOTSUPP;
 112
 113         error = copyin(data, &args, sizeof(args));
 114         if (error)
 115                 return error;
 116
 117         memset(sbp->f_mntfromname, 0, sizeof(sbp->f_mntfromname));
 118         error = copyinstr(args.from, sbp->f_mntfromname,
 119             sizeof(sbp->f_mntfromname), NULL);
 120         if (error)
 121                 return error;
 122
 123         memset(sbp->f_mntonname, 0, sizeof(sbp->f_mntonname));
 124         error = copyinstr(mntpt, sbp->f_mntonname, sizeof(sbp->f_mntonname),
 125             NULL);
 126         if (error)
 127                 return error;
 128
 129         memset(subtype, 0, sizeof(subtype));
 130         if (args.subtype != NULL) {
 131                 error = copyinstr(args.subtype, subtype, sizeof(subtype), NULL);
 132                 if (error)
 133                         return error;
 134                 if (strlen(subtype)) {
 135                         strlcat(sbp->f_fstypename, ".", sizeof(sbp->f_fstypename));
 136                         strlcat(sbp->f_fstypename, subtype, sizeof(sbp->f_fstypename));
 137                 }
 138         }
 139
 140         error = nlookup_init(&nd, sbp->f_mntfromname, UIO_SYSSPACE, NLC_FOLLOW);
 141         if (!error) {
 142                 error = nlookup(&nd);
 143                 if (!error)
 144                         error = cache_vref(&nd.nl_nch, nd.nl_cred, &devvp);
 145                 nlookup_done(&nd);
 146         }
 147         if (error)
 148                 return error;
 149         if (!devvp)
 150                 return ENODEV;
 151
 152         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 153         error = VOP_ACCESS(devvp, VREAD | VWRITE, cred);
 154         if (error == 0)
 155                 error = caps_priv_check(cred, SYSCAP_NOMOUNT_FUSE);
 156         if (error) {
 157                 vput(devvp);
 158                 return error;
 159         }
 160         vn_unlock(devvp);
 161
 162         fuse_dbg("fd=%d\n", args.fd);
 163         file = holdfp_fdp(curthread->td_proc->p_fd, args.fd, FREAD | FWRITE);
 164         if (!file) {
 165                 vrele(devvp);
 166                 return EBADF;
 167         }
 168         error = devfs_get_cdevpriv(file, (void**)&fmp);
 169         dropfp(curthread, args.fd, file);
 170         if (error) {
 171                 vrele(devvp);
 172                 return error;
 173         }
 174         KKASSERT(fmp);
 175
 176         fmp->mp = mp;
 177         fmp->dead = false;
 178         mtx_init(&fmp->mnt_lock, "fuse_mnt_lock");
 179         mtx_init(&fmp->ipc_lock, "fuse_ipc_lock");
 180         mtx_init(&fmp->ino_lock, "fuse_ino_lock");
 181         TAILQ_INIT(&fmp->request_head);
 182         TAILQ_INIT(&fmp->reply_head);
 183         RB_INIT(&fmp->node_head);
 184         fmp->devvp = devvp;
 185         fmp->cred = crhold(cred);
 186         KKASSERT(fmp->refcnt > 0);
 187         refcount_acquire(&fmp->refcnt);
 188
 189         mp->mnt_flag |= MNT_LOCAL;
 190         mp->mnt_kern_flag |= MNTK_ALL_MPSAFE;
 191         mp->mnt_kern_flag |= MNTK_THR_SYNC;
 192         mp->mnt_data = (qaddr_t)fmp;
 193
 194         fuse_node_new(fmp, FUSE_ROOT_ID, VDIR, &fmp->rfnp);
 195         KKASSERT(fmp->rfnp->ino == FUSE_ROOT_ID);
 196
 197         vfs_getnewfsid(mp);
 198         vfs_add_vnodeops(mp, &fuse_vnode_vops, &mp->mnt_vn_norm_ops);
 199         vfs_add_vnodeops(mp, &fuse_spec_vops, &mp->mnt_vn_spec_ops);
 200         /* XXX fifo ops */
 201
 202         fip = fuse_ipc_get(fmp, sizeof(*fii));
 203         fii = fuse_ipc_fill(fip, FUSE_INIT, FUSE_ROOT_ID, NULL);
 204         fii->major = FUSE_KERNEL_VERSION;
 205         fii->minor = FUSE_KERNEL_MINOR_VERSION;
 206         fii->max_readahead = FUSE_BLKSIZE;
 207         /* unused */
 208         //fii->flags = ...;
 209
 210         error = fuse_ipc_tx(fip);
 211         if (error) {
 212                 vrele(devvp);
 213                 return error;
 214         }
 215
 216         fio = fuse_out_data(fip);
 217         fmp->abi_major = fio->major;
 218         fmp->abi_minor = fio->minor;
 219         fmp->max_write = fio->max_write;
 220
 221         if (fuse_cmp_version(fmp, 7, 0) < 0) {
 222                 fuse_ipc_put(fip);
 223                 vrele(devvp);
 224                 return EPROTONOSUPPORT;
 225         }
 226
 227         /* unused */
 228         //fio->max_readahead
 229         //fio->flags
 230         //fio->max_background
 231         //fio->congestion_threshold
 232         //fio->time_gran
 233         //fio->max_pages
 234         fuse_print("FUSE UABI %d.%d\n", fmp->abi_major, fmp->abi_minor);
 235
 236         fuse_ipc_put(fip);
 237
 238         VFS_STATFS(mp, &mp->mnt_stat, cred);
 239
 240         spin_init(&fmp->helper_spin, "fuse_spin");
 241         TAILQ_INIT(&fmp->bioq);
 242         lwkt_create(fuse_io_thread, fmp, &fmp->helper_td,
 243                     NULL, 0, -1, "fuse_helper");
 244
 245         return 0;
 246 }
 247
 248 static int
 249 fuse_unmount(struct mount *mp, int mntflags)
 250 {
 251         struct fuse_mount *fmp = VFSTOFUSE(mp);
 252         struct fuse_ipc *fip;
 253         int error, flags = 0;
 254
 255         mtx_lock(&fmp->mnt_lock);
 256         if (mntflags & MNT_FORCE)
 257                 flags |= FORCECLOSE;
 258
 259         error = vflush(mp, 0, flags);
 260         if (error) {
 261                 mtx_unlock(&fmp->mnt_lock);
 262                 fuse_dbg("vflush error=%d\n", error);
 263                 return error;
 264         }
 265
 266         if (!fuse_test_dead(fmp)) {
 267                 fuse_dbg("not dead yet, destroying\n");
 268                 fip = fuse_ipc_get(fmp, 0);
 269                 fuse_ipc_fill(fip, FUSE_DESTROY, FUSE_ROOT_ID, NULL);
 270                 if (!fuse_ipc_tx(fip))
 271                         fuse_ipc_put(fip);
 272                 fuse_mount_kill(fmp);
 273         }
 274
 275         /* Wait for helper thread to exit */
 276         while (fmp->helper_td) {
 277                 wakeup(&fmp->helper_td);
 278                 tsleep(&fmp->helper_td, 0, "fusehumnt", 2);
 279         }
 280
 281         KKASSERT(fmp->rfnp->vp == NULL);
 282         fuse_node_free(fmp, fmp->rfnp);
 283         fmp->rfnp = NULL;
 284
 285         /* The userspace fs will exit anyway after FUSE_DESTROY. */
 286         vn_lock(fmp->devvp, LK_EXCLUSIVE | LK_RETRY);
 287         VOP_CLOSE(fmp->devvp, FREAD | FWRITE, NULL);
 288         vn_unlock(fmp->devvp);
 289
 290         vrele(fmp->devvp);
 291         mtx_unlock(&fmp->mnt_lock);
 292
 293         fuse_mount_free(fmp);
 294         mp->mnt_data = NULL;
 295         mp->mnt_flag &= ~MNT_LOCAL;
 296
 297         fuse_dbg("unmount done\n");
 298
 299         return 0;
 300 }
 301
 302 /*
 303  *
 304  * fuse_sync() and friends
 305  *
 306  * This is an alternative faster way for DragonFlyBSD to flush vnodes,
 307  * but requires a bit of code structure.  vsetisdirty() puts the vnode
 308  * on a per-thread syncer list.  When the list is non-empty, .vfs_sync()
 309  * is called periodically to flush dirty vnodes.
 310  *
 311  * In the case of fuse, at the moment file writes are asynchronous and
 312  * other attribute changes are synchronous so we only have to check for
 313  * dirty buffers.
 314  */
 315 static int fuse_sync_scan1(struct mount *mp, struct vnode *vp, void *data);
 316 static int fuse_sync_scan2(struct mount *mp, struct vnode *vp, void *data);
 317
 318 struct scaninfo {
 319         int rescan;
 320         int waitfor;
 321         int allerror;
 322 };
 323
 324
 325 static int
 326 fuse_sync(struct mount *mp, int waitfor)
 327 {
 328         struct scaninfo scaninfo;
 329
 330         scaninfo.allerror = 0;
 331         scaninfo.rescan = 1;
 332         scaninfo.waitfor = waitfor;
 333         while (scaninfo.rescan) {
 334                 scaninfo.rescan = 0;
 335                 vmntvnodescan(mp, VMSC_GETVP|VMSC_NOWAIT,
 336                               fuse_sync_scan1, fuse_sync_scan2, &scaninfo);
 337         }
 338         return (scaninfo.allerror);
 339 }
 340
 341 /*
 342  * Fast pre-check requires flush?
 343  */
 344 static int
 345 fuse_sync_scan1(struct mount *mp, struct vnode *vp, void *data)
 346 {
 347         if (RB_EMPTY(&vp->v_rbdirty_tree))
 348                 return -1;
 349         return 0;
 350 }
 351
 352 /*
 353  * Main flush (re-check)
 354  */
 355 static int
 356 fuse_sync_scan2(struct mount *mp, struct vnode *vp, void *data)
 357 {
 358         struct scaninfo *info = data;
 359         int error;
 360
 361         if ((error = VOP_FSYNC(vp, info->waitfor, 0)) != 0)
 362                 info->allerror = error;
 363         return 0;
 364 }
 365
 366 static int
 367 fuse_root(struct mount *mp, struct vnode **vpp)
 368 {
 369         struct fuse_mount *fmp = VFSTOFUSE(mp);
 370         int error;
 371
 372         KASSERT(fmp->rfnp, ("no root node"));
 373         KKASSERT(fmp->rfnp->fmp);
 374
 375         error = fuse_node_vn(fmp->rfnp, vpp);
 376         if (!error) {
 377                 struct vnode *vp = *vpp;
 378                 vsetflags(vp, VROOT);
 379                 KKASSERT(vp->v_type == VDIR);
 380         }
 381
 382         return error;
 383 }
 384
 385 static int
 386 fuse_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 387 {
 388         struct fuse_mount *fmp = VFSTOFUSE(mp);
 389         struct fuse_ipc *fip;
 390         struct fuse_statfs_out *fso;
 391         int error;
 392
 393         fip = fuse_ipc_get(fmp, 0);
 394         fuse_ipc_fill(fip, FUSE_STATFS, FUSE_ROOT_ID, cred);
 395         error = fuse_ipc_tx(fip);
 396         if (error)
 397                 return error;
 398
 399         fso = fuse_out_data(fip);
 400
 401         mtx_lock(&fmp->mnt_lock);
 402         sbp->f_bsize = fso->st.frsize;
 403         sbp->f_iosize = FUSE_BLKSIZE;
 404         sbp->f_blocks = fso->st.blocks;
 405         sbp->f_bfree = fso->st.bfree;
 406         sbp->f_bavail = fso->st.bavail;
 407         sbp->f_files = fso->st.files;
 408         sbp->f_ffree = fso->st.ffree;
 409         mtx_unlock(&fmp->mnt_lock);
 410
 411         fuse_ipc_put(fip);
 412
 413         return 0;
 414 }
 415
 416 static int
 417 fuse_statvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred)
 418 {
 419         struct fuse_mount *fmp = VFSTOFUSE(mp);
 420         struct fuse_ipc *fip;
 421         struct fuse_statfs_out *fso;
 422         int error;
 423
 424         fip = fuse_ipc_get(fmp, 0);
 425         fuse_ipc_fill(fip, FUSE_STATFS, FUSE_ROOT_ID, cred);
 426         error = fuse_ipc_tx(fip);
 427         if (error)
 428                 return error;
 429
 430         fso = fuse_out_data(fip);
 431
 432         mtx_lock(&fmp->mnt_lock);
 433         sbp->f_bsize = fso->st.frsize;
 434         sbp->f_frsize = FUSE_BLKSIZE;
 435         sbp->f_blocks = fso->st.blocks;
 436         sbp->f_bfree = fso->st.bfree;
 437         sbp->f_bavail = fso->st.bavail;
 438         sbp->f_files = fso->st.files;
 439         sbp->f_ffree = fso->st.ffree;
 440         mtx_unlock(&fmp->mnt_lock);
 441
 442         fuse_ipc_put(fip);
 443
 444         return 0;
 445 }
 446
 447 static int
 448 fuse_init(struct vfsconf *vfsp)
 449 {
 450         int error;
 451
 452         fuse_node_init();
 453         fuse_ipc_init();
 454
 455         error = fuse_device_init();
 456         if (error) {
 457                 fuse_ipc_cleanup();
 458                 fuse_node_cleanup();
 459                 return error;
 460         }
 461
 462         fuse_print("FUSE ABI %d.%d\n", FUSE_KERNEL_VERSION,
 463             FUSE_KERNEL_MINOR_VERSION);
 464
 465         return 0;
 466 }
 467
 468 static int
 469 fuse_uninit(struct vfsconf *vfsp)
 470 {
 471         fuse_ipc_cleanup();
 472         fuse_node_cleanup();
 473         fuse_device_cleanup();
 474
 475         return 0;
 476 }
 477
 478 static struct vfsops fuse_vfsops = {
 479         .vfs_flags = 0,
 480         .vfs_init = fuse_init,
 481         .vfs_uninit = fuse_uninit,
 482         .vfs_mount = fuse_mount,
 483         .vfs_unmount = fuse_unmount,
 484         .vfs_sync = fuse_sync,
 485         .vfs_root = fuse_root,
 486         .vfs_statfs = fuse_statfs,
 487         .vfs_statvfs = fuse_statvfs,
 488 };
 489
 490 VFS_SET(fuse_vfsops, fuse, VFCF_SYNTHETIC | VFCF_MPSAFE);
 491 MODULE_VERSION(fuse, 1);