fs/fuse/inode.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
   4
   5   This program can be distributed under the terms of the GNU GPL.
   6   See the file COPYING.
   7 */
   8
   9 #include "fuse_i.h"
  10
  11 #include <linux/pagemap.h>
  12 #include <linux/slab.h>
  13 #include <linux/file.h>
  14 #include <linux/seq_file.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/fs_context.h>
  19 #include <linux/fs_parser.h>
  20 #include <linux/statfs.h>
  21 #include <linux/random.h>
  22 #include <linux/sched.h>
  23 #include <linux/exportfs.h>
  24 #include <linux/posix_acl.h>
  25 #include <linux/pid_namespace.h>
  26 #include <uapi/linux/magic.h>
  27
  28 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
  29 MODULE_DESCRIPTION("Filesystem in Userspace");
  30 MODULE_LICENSE("GPL");
  31
  32 static struct kmem_cache *fuse_inode_cachep;
  33 struct list_head fuse_conn_list;
  34 DEFINE_MUTEX(fuse_mutex);
  35
  36 static int set_global_limit(const char *val, const struct kernel_param *kp);
  37
  38 unsigned max_user_bgreq;
  39 module_param_call(max_user_bgreq, set_global_limit, param_get_uint,
  40                   &max_user_bgreq, 0644);
  41 __MODULE_PARM_TYPE(max_user_bgreq, "uint");
  42 MODULE_PARM_DESC(max_user_bgreq,
  43  "Global limit for the maximum number of backgrounded requests an "
  44  "unprivileged user can set");
  45
  46 unsigned max_user_congthresh;
  47 module_param_call(max_user_congthresh, set_global_limit, param_get_uint,
  48                   &max_user_congthresh, 0644);
  49 __MODULE_PARM_TYPE(max_user_congthresh, "uint");
  50 MODULE_PARM_DESC(max_user_congthresh,
  51  "Global limit for the maximum congestion threshold an "
  52  "unprivileged user can set");
  53
  54 #define FUSE_DEFAULT_BLKSIZE 512
  55
  56 /** Maximum number of outstanding background requests */
  57 #define FUSE_DEFAULT_MAX_BACKGROUND 12
  58
  59 /** Congestion starts at 75% of maximum */
  60 #define FUSE_DEFAULT_CONGESTION_THRESHOLD (FUSE_DEFAULT_MAX_BACKGROUND * 3 / 4)
  61
  62 #ifdef CONFIG_BLOCK
  63 static struct file_system_type fuseblk_fs_type;
  64 #endif
  65
  66 struct fuse_forget_link *fuse_alloc_forget(void)
  67 {
  68         return kzalloc(sizeof(struct fuse_forget_link), GFP_KERNEL_ACCOUNT);
  69 }
  70
  71 static struct inode *fuse_alloc_inode(struct super_block *sb)
  72 {
  73         struct fuse_inode *fi;
  74
  75         fi = alloc_inode_sb(sb, fuse_inode_cachep, GFP_KERNEL);
  76         if (!fi)
  77                 return NULL;
  78
  79         fi->i_time = 0;
  80         fi->inval_mask = 0;
  81         fi->nodeid = 0;
  82         fi->nlookup = 0;
  83         fi->attr_version = 0;
  84         fi->orig_ino = 0;
  85         fi->state = 0;
  86         mutex_init(&fi->mutex);
  87         spin_lock_init(&fi->lock);
  88         fi->forget = fuse_alloc_forget();
  89         if (!fi->forget)
  90                 goto out_free;
  91
  92         if (IS_ENABLED(CONFIG_FUSE_DAX) && !fuse_dax_inode_alloc(sb, fi))
  93                 goto out_free_forget;
  94
  95         return &fi->inode;
  96
  97 out_free_forget:
  98         kfree(fi->forget);
  99 out_free:
 100         kmem_cache_free(fuse_inode_cachep, fi);
 101         return NULL;
 102 }
 103
 104 static void fuse_free_inode(struct inode *inode)
 105 {
 106         struct fuse_inode *fi = get_fuse_inode(inode);
 107
 108         mutex_destroy(&fi->mutex);
 109         kfree(fi->forget);
 110 #ifdef CONFIG_FUSE_DAX
 111         kfree(fi->dax);
 112 #endif
 113         kmem_cache_free(fuse_inode_cachep, fi);
 114 }
 115
 116 static void fuse_evict_inode(struct inode *inode)
 117 {
 118         struct fuse_inode *fi = get_fuse_inode(inode);
 119
 120         /* Will write inode on close/munmap and in all other dirtiers */
 121         WARN_ON(inode->i_state & I_DIRTY_INODE);
 122
 123         truncate_inode_pages_final(&inode->i_data);
 124         clear_inode(inode);
 125         if (inode->i_sb->s_flags & SB_ACTIVE) {
 126                 struct fuse_conn *fc = get_fuse_conn(inode);
 127
 128                 if (FUSE_IS_DAX(inode))
 129                         fuse_dax_inode_cleanup(inode);
 130                 if (fi->nlookup) {
 131                         fuse_queue_forget(fc, fi->forget, fi->nodeid,
 132                                           fi->nlookup);
 133                         fi->forget = NULL;
 134                 }
 135         }
 136         if (S_ISREG(inode->i_mode) && !fuse_is_bad(inode)) {
 137                 WARN_ON(!list_empty(&fi->write_files));
 138                 WARN_ON(!list_empty(&fi->queued_writes));
 139         }
 140 }
 141
 142 static int fuse_reconfigure(struct fs_context *fsc)
 143 {
 144         struct super_block *sb = fsc->root->d_sb;
 145
 146         sync_filesystem(sb);
 147         if (fsc->sb_flags & SB_MANDLOCK)
 148                 return -EINVAL;
 149
 150         return 0;
 151 }
 152
 153 /*
 154  * ino_t is 32-bits on 32-bit arch. We have to squash the 64-bit value down
 155  * so that it will fit.
 156  */
 157 static ino_t fuse_squash_ino(u64 ino64)
 158 {
 159         ino_t ino = (ino_t) ino64;
 160         if (sizeof(ino_t) < sizeof(u64))
 161                 ino ^= ino64 >> (sizeof(u64) - sizeof(ino_t)) * 8;
 162         return ino;
 163 }
 164
 165 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
 166                                    u64 attr_valid, u32 cache_mask)
 167 {
 168         struct fuse_conn *fc = get_fuse_conn(inode);
 169         struct fuse_inode *fi = get_fuse_inode(inode);
 170
 171         lockdep_assert_held(&fi->lock);
 172
 173         fi->attr_version = atomic64_inc_return(&fc->attr_version);
 174         fi->i_time = attr_valid;
 175         WRITE_ONCE(fi->inval_mask, 0);
 176
 177         inode->i_ino     = fuse_squash_ino(attr->ino);
 178         inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 179         set_nlink(inode, attr->nlink);
 180         inode->i_uid     = make_kuid(fc->user_ns, attr->uid);
 181         inode->i_gid     = make_kgid(fc->user_ns, attr->gid);
 182         inode->i_blocks  = attr->blocks;
 183
 184         /* Sanitize nsecs */
 185         attr->atimensec = min_t(u32, attr->atimensec, NSEC_PER_SEC - 1);
 186         attr->mtimensec = min_t(u32, attr->mtimensec, NSEC_PER_SEC - 1);
 187         attr->ctimensec = min_t(u32, attr->ctimensec, NSEC_PER_SEC - 1);
 188
 189         inode->i_atime.tv_sec   = attr->atime;
 190         inode->i_atime.tv_nsec  = attr->atimensec;
 191         /* mtime from server may be stale due to local buffered write */
 192         if (!(cache_mask & STATX_MTIME)) {
 193                 inode->i_mtime.tv_sec   = attr->mtime;
 194                 inode->i_mtime.tv_nsec  = attr->mtimensec;
 195         }
 196         if (!(cache_mask & STATX_CTIME)) {
 197                 inode->i_ctime.tv_sec   = attr->ctime;
 198                 inode->i_ctime.tv_nsec  = attr->ctimensec;
 199         }
 200
 201         if (attr->blksize != 0)
 202                 inode->i_blkbits = ilog2(attr->blksize);
 203         else
 204                 inode->i_blkbits = inode->i_sb->s_blocksize_bits;
 205
 206         /*
 207          * Don't set the sticky bit in i_mode, unless we want the VFS
 208          * to check permissions.  This prevents failures due to the
 209          * check in may_delete().
 210          */
 211         fi->orig_i_mode = inode->i_mode;
 212         if (!fc->default_permissions)
 213                 inode->i_mode &= ~S_ISVTX;
 214
 215         fi->orig_ino = attr->ino;
 216
 217         /*
 218          * We are refreshing inode data and it is possible that another
 219          * client set suid/sgid or security.capability xattr. So clear
 220          * S_NOSEC. Ideally, we could have cleared it only if suid/sgid
 221          * was set or if security.capability xattr was set. But we don't
 222          * know if security.capability has been set or not. So clear it
 223          * anyway. Its less efficient but should be safe.
 224          */
 225         inode->i_flags &= ~S_NOSEC;
 226 }
 227
 228 u32 fuse_get_cache_mask(struct inode *inode)
 229 {
 230         struct fuse_conn *fc = get_fuse_conn(inode);
 231
 232         if (!fc->writeback_cache || !S_ISREG(inode->i_mode))
 233                 return 0;
 234
 235         return STATX_MTIME | STATX_CTIME | STATX_SIZE;
 236 }
 237
 238 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
 239                             u64 attr_valid, u64 attr_version)
 240 {
 241         struct fuse_conn *fc = get_fuse_conn(inode);
 242         struct fuse_inode *fi = get_fuse_inode(inode);
 243         u32 cache_mask;
 244         loff_t oldsize;
 245         struct timespec64 old_mtime;
 246
 247         spin_lock(&fi->lock);
 248         /*
 249          * In case of writeback_cache enabled, writes update mtime, ctime and
 250          * may update i_size.  In these cases trust the cached value in the
 251          * inode.
 252          */
 253         cache_mask = fuse_get_cache_mask(inode);
 254         if (cache_mask & STATX_SIZE)
 255                 attr->size = i_size_read(inode);
 256
 257         if (cache_mask & STATX_MTIME) {
 258                 attr->mtime = inode->i_mtime.tv_sec;
 259                 attr->mtimensec = inode->i_mtime.tv_nsec;
 260         }
 261         if (cache_mask & STATX_CTIME) {
 262                 attr->ctime = inode->i_ctime.tv_sec;
 263                 attr->ctimensec = inode->i_ctime.tv_nsec;
 264         }
 265
 266         if ((attr_version != 0 && fi->attr_version > attr_version) ||
 267             test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
 268                 spin_unlock(&fi->lock);
 269                 return;
 270         }
 271
 272         old_mtime = inode->i_mtime;
 273         fuse_change_attributes_common(inode, attr, attr_valid, cache_mask);
 274
 275         oldsize = inode->i_size;
 276         /*
 277          * In case of writeback_cache enabled, the cached writes beyond EOF
 278          * extend local i_size without keeping userspace server in sync. So,
 279          * attr->size coming from server can be stale. We cannot trust it.
 280          */
 281         if (!(cache_mask & STATX_SIZE))
 282                 i_size_write(inode, attr->size);
 283         spin_unlock(&fi->lock);
 284
 285         if (!cache_mask && S_ISREG(inode->i_mode)) {
 286                 bool inval = false;
 287
 288                 if (oldsize != attr->size) {
 289                         truncate_pagecache(inode, attr->size);
 290                         if (!fc->explicit_inval_data)
 291                                 inval = true;
 292                 } else if (fc->auto_inval_data) {
 293                         struct timespec64 new_mtime = {
 294                                 .tv_sec = attr->mtime,
 295                                 .tv_nsec = attr->mtimensec,
 296                         };
 297
 298                         /*
 299                          * Auto inval mode also checks and invalidates if mtime
 300                          * has changed.
 301                          */
 302                         if (!timespec64_equal(&old_mtime, &new_mtime))
 303                                 inval = true;
 304                 }
 305
 306                 if (inval)
 307                         invalidate_inode_pages2(inode->i_mapping);
 308         }
 309
 310         if (IS_ENABLED(CONFIG_FUSE_DAX))
 311                 fuse_dax_dontcache(inode, attr->flags);
 312 }
 313
 314 static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr,
 315                             struct fuse_conn *fc)
 316 {
 317         inode->i_mode = attr->mode & S_IFMT;
 318         inode->i_size = attr->size;
 319         inode->i_mtime.tv_sec  = attr->mtime;
 320         inode->i_mtime.tv_nsec = attr->mtimensec;
 321         inode->i_ctime.tv_sec  = attr->ctime;
 322         inode->i_ctime.tv_nsec = attr->ctimensec;
 323         if (S_ISREG(inode->i_mode)) {
 324                 fuse_init_common(inode);
 325                 fuse_init_file_inode(inode, attr->flags);
 326         } else if (S_ISDIR(inode->i_mode))
 327                 fuse_init_dir(inode);
 328         else if (S_ISLNK(inode->i_mode))
 329                 fuse_init_symlink(inode);
 330         else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
 331                  S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
 332                 fuse_init_common(inode);
 333                 init_special_inode(inode, inode->i_mode,
 334                                    new_decode_dev(attr->rdev));
 335         } else
 336                 BUG();
 337         /*
 338          * Ensure that we don't cache acls for daemons without FUSE_POSIX_ACL
 339          * so they see the exact same behavior as before.
 340          */
 341         if (!fc->posix_acl)
 342                 inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE;
 343 }
 344
 345 static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
 346 {
 347         u64 nodeid = *(u64 *) _nodeidp;
 348         if (get_node_id(inode) == nodeid)
 349                 return 1;
 350         else
 351                 return 0;
 352 }
 353
 354 static int fuse_inode_set(struct inode *inode, void *_nodeidp)
 355 {
 356         u64 nodeid = *(u64 *) _nodeidp;
 357         get_fuse_inode(inode)->nodeid = nodeid;
 358         return 0;
 359 }
 360
 361 struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
 362                         int generation, struct fuse_attr *attr,
 363                         u64 attr_valid, u64 attr_version)
 364 {
 365         struct inode *inode;
 366         struct fuse_inode *fi;
 367         struct fuse_conn *fc = get_fuse_conn_super(sb);
 368
 369         /*
 370          * Auto mount points get their node id from the submount root, which is
 371          * not a unique identifier within this filesystem.
 372          *
 373          * To avoid conflicts, do not place submount points into the inode hash
 374          * table.
 375          */
 376         if (fc->auto_submounts && (attr->flags & FUSE_ATTR_SUBMOUNT) &&
 377             S_ISDIR(attr->mode)) {
 378                 inode = new_inode(sb);
 379                 if (!inode)
 380                         return NULL;
 381
 382                 fuse_init_inode(inode, attr, fc);
 383                 get_fuse_inode(inode)->nodeid = nodeid;
 384                 inode->i_flags |= S_AUTOMOUNT;
 385                 goto done;
 386         }
 387
 388 retry:
 389         inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
 390         if (!inode)
 391                 return NULL;
 392
 393         if ((inode->i_state & I_NEW)) {
 394                 inode->i_flags |= S_NOATIME;
 395                 if (!fc->writeback_cache || !S_ISREG(attr->mode))
 396                         inode->i_flags |= S_NOCMTIME;
 397                 inode->i_generation = generation;
 398                 fuse_init_inode(inode, attr, fc);
 399                 unlock_new_inode(inode);
 400         } else if (fuse_stale_inode(inode, generation, attr)) {
 401                 /* nodeid was reused, any I/O on the old inode should fail */
 402                 fuse_make_bad(inode);
 403                 iput(inode);
 404                 goto retry;
 405         }
 406 done:
 407         fi = get_fuse_inode(inode);
 408         spin_lock(&fi->lock);
 409         fi->nlookup++;
 410         spin_unlock(&fi->lock);
 411         fuse_change_attributes(inode, attr, attr_valid, attr_version);
 412
 413         return inode;
 414 }
 415
 416 struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
 417                            struct fuse_mount **fm)
 418 {
 419         struct fuse_mount *fm_iter;
 420         struct inode *inode;
 421
 422         WARN_ON(!rwsem_is_locked(&fc->killsb));
 423         list_for_each_entry(fm_iter, &fc->mounts, fc_entry) {
 424                 if (!fm_iter->sb)
 425                         continue;
 426
 427                 inode = ilookup5(fm_iter->sb, nodeid, fuse_inode_eq, &nodeid);
 428                 if (inode) {
 429                         if (fm)
 430                                 *fm = fm_iter;
 431                         return inode;
 432                 }
 433         }
 434
 435         return NULL;
 436 }
 437
 438 int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
 439                              loff_t offset, loff_t len)
 440 {
 441         struct fuse_inode *fi;
 442         struct inode *inode;
 443         pgoff_t pg_start;
 444         pgoff_t pg_end;
 445
 446         inode = fuse_ilookup(fc, nodeid, NULL);
 447         if (!inode)
 448                 return -ENOENT;
 449
 450         fi = get_fuse_inode(inode);
 451         spin_lock(&fi->lock);
 452         fi->attr_version = atomic64_inc_return(&fc->attr_version);
 453         spin_unlock(&fi->lock);
 454
 455         fuse_invalidate_attr(inode);
 456         forget_all_cached_acls(inode);
 457         if (offset >= 0) {
 458                 pg_start = offset >> PAGE_SHIFT;
 459                 if (len <= 0)
 460                         pg_end = -1;
 461                 else
 462                         pg_end = (offset + len - 1) >> PAGE_SHIFT;
 463                 invalidate_inode_pages2_range(inode->i_mapping,
 464                                               pg_start, pg_end);
 465         }
 466         iput(inode);
 467         return 0;
 468 }
 469
 470 bool fuse_lock_inode(struct inode *inode)
 471 {
 472         bool locked = false;
 473
 474         if (!get_fuse_conn(inode)->parallel_dirops) {
 475                 mutex_lock(&get_fuse_inode(inode)->mutex);
 476                 locked = true;
 477         }
 478
 479         return locked;
 480 }
 481
 482 void fuse_unlock_inode(struct inode *inode, bool locked)
 483 {
 484         if (locked)
 485                 mutex_unlock(&get_fuse_inode(inode)->mutex);
 486 }
 487
 488 static void fuse_umount_begin(struct super_block *sb)
 489 {
 490         struct fuse_conn *fc = get_fuse_conn_super(sb);
 491
 492         if (fc->no_force_umount)
 493                 return;
 494
 495         fuse_abort_conn(fc);
 496
 497         // Only retire block-device-based superblocks.
 498         if (sb->s_bdev != NULL)
 499                 retire_super(sb);
 500 }
 501
 502 static void fuse_send_destroy(struct fuse_mount *fm)
 503 {
 504         if (fm->fc->conn_init) {
 505                 FUSE_ARGS(args);
 506
 507                 args.opcode = FUSE_DESTROY;
 508                 args.force = true;
 509                 args.nocreds = true;
 510                 fuse_simple_request(fm, &args);
 511         }
 512 }
 513
 514 static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
 515 {
 516         stbuf->f_type    = FUSE_SUPER_MAGIC;
 517         stbuf->f_bsize   = attr->bsize;
 518         stbuf->f_frsize  = attr->frsize;
 519         stbuf->f_blocks  = attr->blocks;
 520         stbuf->f_bfree   = attr->bfree;
 521         stbuf->f_bavail  = attr->bavail;
 522         stbuf->f_files   = attr->files;
 523         stbuf->f_ffree   = attr->ffree;
 524         stbuf->f_namelen = attr->namelen;
 525         /* fsid is left zero */
 526 }
 527
 528 static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
 529 {
 530         struct super_block *sb = dentry->d_sb;
 531         struct fuse_mount *fm = get_fuse_mount_super(sb);
 532         FUSE_ARGS(args);
 533         struct fuse_statfs_out outarg;
 534         int err;
 535
 536         if (!fuse_allow_current_process(fm->fc)) {
 537                 buf->f_type = FUSE_SUPER_MAGIC;
 538                 return 0;
 539         }
 540
 541         memset(&outarg, 0, sizeof(outarg));
 542         args.in_numargs = 0;
 543         args.opcode = FUSE_STATFS;
 544         args.nodeid = get_node_id(d_inode(dentry));
 545         args.out_numargs = 1;
 546         args.out_args[0].size = sizeof(outarg);
 547         args.out_args[0].value = &outarg;
 548         err = fuse_simple_request(fm, &args);
 549         if (!err)
 550                 convert_fuse_statfs(buf, &outarg.st);
 551         return err;
 552 }
 553
 554 static struct fuse_sync_bucket *fuse_sync_bucket_alloc(void)
 555 {
 556         struct fuse_sync_bucket *bucket;
 557
 558         bucket = kzalloc(sizeof(*bucket), GFP_KERNEL | __GFP_NOFAIL);
 559         if (bucket) {
 560                 init_waitqueue_head(&bucket->waitq);
 561                 /* Initial active count */
 562                 atomic_set(&bucket->count, 1);
 563         }
 564         return bucket;
 565 }
 566
 567 static void fuse_sync_fs_writes(struct fuse_conn *fc)
 568 {
 569         struct fuse_sync_bucket *bucket, *new_bucket;
 570         int count;
 571
 572         new_bucket = fuse_sync_bucket_alloc();
 573         spin_lock(&fc->lock);
 574         bucket = rcu_dereference_protected(fc->curr_bucket, 1);
 575         count = atomic_read(&bucket->count);
 576         WARN_ON(count < 1);
 577         /* No outstanding writes? */
 578         if (count == 1) {
 579                 spin_unlock(&fc->lock);
 580                 kfree(new_bucket);
 581                 return;
 582         }
 583
 584         /*
 585          * Completion of new bucket depends on completion of this bucket, so add
 586          * one more count.
 587          */
 588         atomic_inc(&new_bucket->count);
 589         rcu_assign_pointer(fc->curr_bucket, new_bucket);
 590         spin_unlock(&fc->lock);
 591         /*
 592          * Drop initial active count.  At this point if all writes in this and
 593          * ancestor buckets complete, the count will go to zero and this task
 594          * will be woken up.
 595          */
 596         atomic_dec(&bucket->count);
 597
 598         wait_event(bucket->waitq, atomic_read(&bucket->count) == 0);
 599
 600         /* Drop temp count on descendant bucket */
 601         fuse_sync_bucket_dec(new_bucket);
 602         kfree_rcu(bucket, rcu);
 603 }
 604
 605 static int fuse_sync_fs(struct super_block *sb, int wait)
 606 {
 607         struct fuse_mount *fm = get_fuse_mount_super(sb);
 608         struct fuse_conn *fc = fm->fc;
 609         struct fuse_syncfs_in inarg;
 610         FUSE_ARGS(args);
 611         int err;
 612
 613         /*
 614          * Userspace cannot handle the wait == 0 case.  Avoid a
 615          * gratuitous roundtrip.
 616          */
 617         if (!wait)
 618                 return 0;
 619
 620         /* The filesystem is being unmounted.  Nothing to do. */
 621         if (!sb->s_root)
 622                 return 0;
 623
 624         if (!fc->sync_fs)
 625                 return 0;
 626
 627         fuse_sync_fs_writes(fc);
 628
 629         memset(&inarg, 0, sizeof(inarg));
 630         args.in_numargs = 1;
 631         args.in_args[0].size = sizeof(inarg);
 632         args.in_args[0].value = &inarg;
 633         args.opcode = FUSE_SYNCFS;
 634         args.nodeid = get_node_id(sb->s_root->d_inode);
 635         args.out_numargs = 0;
 636
 637         err = fuse_simple_request(fm, &args);
 638         if (err == -ENOSYS) {
 639                 fc->sync_fs = 0;
 640                 err = 0;
 641         }
 642
 643         return err;
 644 }
 645
 646 enum {
 647         OPT_SOURCE,
 648         OPT_SUBTYPE,
 649         OPT_FD,
 650         OPT_ROOTMODE,
 651         OPT_USER_ID,
 652         OPT_GROUP_ID,
 653         OPT_DEFAULT_PERMISSIONS,
 654         OPT_ALLOW_OTHER,
 655         OPT_MAX_READ,
 656         OPT_BLKSIZE,
 657         OPT_ERR
 658 };
 659
 660 static const struct fs_parameter_spec fuse_fs_parameters[] = {
 661         fsparam_string  ("source",              OPT_SOURCE),
 662         fsparam_u32     ("fd",                  OPT_FD),
 663         fsparam_u32oct  ("rootmode",            OPT_ROOTMODE),
 664         fsparam_u32     ("user_id",             OPT_USER_ID),
 665         fsparam_u32     ("group_id",            OPT_GROUP_ID),
 666         fsparam_flag    ("default_permissions", OPT_DEFAULT_PERMISSIONS),
 667         fsparam_flag    ("allow_other",         OPT_ALLOW_OTHER),
 668         fsparam_u32     ("max_read",            OPT_MAX_READ),
 669         fsparam_u32     ("blksize",             OPT_BLKSIZE),
 670         fsparam_string  ("subtype",             OPT_SUBTYPE),
 671         {}
 672 };
 673
 674 static int fuse_parse_param(struct fs_context *fsc, struct fs_parameter *param)
 675 {
 676         struct fs_parse_result result;
 677         struct fuse_fs_context *ctx = fsc->fs_private;
 678         int opt;
 679
 680         if (fsc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
 681                 /*
 682                  * Ignore options coming from mount(MS_REMOUNT) for backward
 683                  * compatibility.
 684                  */
 685                 if (fsc->oldapi)
 686                         return 0;
 687
 688                 return invalfc(fsc, "No changes allowed in reconfigure");
 689         }
 690
 691         opt = fs_parse(fsc, fuse_fs_parameters, param, &result);
 692         if (opt < 0)
 693                 return opt;
 694
 695         switch (opt) {
 696         case OPT_SOURCE:
 697                 if (fsc->source)
 698                         return invalfc(fsc, "Multiple sources specified");
 699                 fsc->source = param->string;
 700                 param->string = NULL;
 701                 break;
 702
 703         case OPT_SUBTYPE:
 704                 if (ctx->subtype)
 705                         return invalfc(fsc, "Multiple subtypes specified");
 706                 ctx->subtype = param->string;
 707                 param->string = NULL;
 708                 return 0;
 709
 710         case OPT_FD:
 711                 ctx->fd = result.uint_32;
 712                 ctx->fd_present = true;
 713                 break;
 714
 715         case OPT_ROOTMODE:
 716                 if (!fuse_valid_type(result.uint_32))
 717                         return invalfc(fsc, "Invalid rootmode");
 718                 ctx->rootmode = result.uint_32;
 719                 ctx->rootmode_present = true;
 720                 break;
 721
 722         case OPT_USER_ID:
 723                 ctx->user_id = make_kuid(fsc->user_ns, result.uint_32);
 724                 if (!uid_valid(ctx->user_id))
 725                         return invalfc(fsc, "Invalid user_id");
 726                 ctx->user_id_present = true;
 727                 break;
 728
 729         case OPT_GROUP_ID:
 730                 ctx->group_id = make_kgid(fsc->user_ns, result.uint_32);
 731                 if (!gid_valid(ctx->group_id))
 732                         return invalfc(fsc, "Invalid group_id");
 733                 ctx->group_id_present = true;
 734                 break;
 735
 736         case OPT_DEFAULT_PERMISSIONS:
 737                 ctx->default_permissions = true;
 738                 break;
 739
 740         case OPT_ALLOW_OTHER:
 741                 ctx->allow_other = true;
 742                 break;
 743
 744         case OPT_MAX_READ:
 745                 ctx->max_read = result.uint_32;
 746                 break;
 747
 748         case OPT_BLKSIZE:
 749                 if (!ctx->is_bdev)
 750                         return invalfc(fsc, "blksize only supported for fuseblk");
 751                 ctx->blksize = result.uint_32;
 752                 break;
 753
 754         default:
 755                 return -EINVAL;
 756         }
 757
 758         return 0;
 759 }
 760
 761 static void fuse_free_fsc(struct fs_context *fsc)
 762 {
 763         struct fuse_fs_context *ctx = fsc->fs_private;
 764
 765         if (ctx) {
 766                 kfree(ctx->subtype);
 767                 kfree(ctx);
 768         }
 769 }
 770
 771 static int fuse_show_options(struct seq_file *m, struct dentry *root)
 772 {
 773         struct super_block *sb = root->d_sb;
 774         struct fuse_conn *fc = get_fuse_conn_super(sb);
 775
 776         if (fc->legacy_opts_show) {
 777                 seq_printf(m, ",user_id=%u",
 778                            from_kuid_munged(fc->user_ns, fc->user_id));
 779                 seq_printf(m, ",group_id=%u",
 780                            from_kgid_munged(fc->user_ns, fc->group_id));
 781                 if (fc->default_permissions)
 782                         seq_puts(m, ",default_permissions");
 783                 if (fc->allow_other)
 784                         seq_puts(m, ",allow_other");
 785                 if (fc->max_read != ~0)
 786                         seq_printf(m, ",max_read=%u", fc->max_read);
 787                 if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
 788                         seq_printf(m, ",blksize=%lu", sb->s_blocksize);
 789         }
 790 #ifdef CONFIG_FUSE_DAX
 791         if (fc->dax_mode == FUSE_DAX_ALWAYS)
 792                 seq_puts(m, ",dax=always");
 793         else if (fc->dax_mode == FUSE_DAX_NEVER)
 794                 seq_puts(m, ",dax=never");
 795         else if (fc->dax_mode == FUSE_DAX_INODE_USER)
 796                 seq_puts(m, ",dax=inode");
 797 #endif
 798
 799         return 0;
 800 }
 801
 802 static void fuse_iqueue_init(struct fuse_iqueue *fiq,
 803                              const struct fuse_iqueue_ops *ops,
 804                              void *priv)
 805 {
 806         memset(fiq, 0, sizeof(struct fuse_iqueue));
 807         spin_lock_init(&fiq->lock);
 808         init_waitqueue_head(&fiq->waitq);
 809         INIT_LIST_HEAD(&fiq->pending);
 810         INIT_LIST_HEAD(&fiq->interrupts);
 811         fiq->forget_list_tail = &fiq->forget_list_head;
 812         fiq->connected = 1;
 813         fiq->ops = ops;
 814         fiq->priv = priv;
 815 }
 816
 817 static void fuse_pqueue_init(struct fuse_pqueue *fpq)
 818 {
 819         unsigned int i;
 820
 821         spin_lock_init(&fpq->lock);
 822         for (i = 0; i < FUSE_PQ_HASH_SIZE; i++)
 823                 INIT_LIST_HEAD(&fpq->processing[i]);
 824         INIT_LIST_HEAD(&fpq->io);
 825         fpq->connected = 1;
 826 }
 827
 828 void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
 829                     struct user_namespace *user_ns,
 830                     const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv)
 831 {
 832         memset(fc, 0, sizeof(*fc));
 833         spin_lock_init(&fc->lock);
 834         spin_lock_init(&fc->bg_lock);
 835         init_rwsem(&fc->killsb);
 836         refcount_set(&fc->count, 1);
 837         atomic_set(&fc->dev_count, 1);
 838         init_waitqueue_head(&fc->blocked_waitq);
 839         fuse_iqueue_init(&fc->iq, fiq_ops, fiq_priv);
 840         INIT_LIST_HEAD(&fc->bg_queue);
 841         INIT_LIST_HEAD(&fc->entry);
 842         INIT_LIST_HEAD(&fc->devices);
 843         atomic_set(&fc->num_waiting, 0);
 844         fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
 845         fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
 846         atomic64_set(&fc->khctr, 0);
 847         fc->polled_files = RB_ROOT;
 848         fc->blocked = 0;
 849         fc->initialized = 0;
 850         fc->connected = 1;
 851         atomic64_set(&fc->attr_version, 1);
 852         get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
 853         fc->pid_ns = get_pid_ns(task_active_pid_ns(current));
 854         fc->user_ns = get_user_ns(user_ns);
 855         fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ;
 856         fc->max_pages_limit = FUSE_MAX_MAX_PAGES;
 857
 858         INIT_LIST_HEAD(&fc->mounts);
 859         list_add(&fm->fc_entry, &fc->mounts);
 860         fm->fc = fc;
 861 }
 862 EXPORT_SYMBOL_GPL(fuse_conn_init);
 863
 864 void fuse_conn_put(struct fuse_conn *fc)
 865 {
 866         if (refcount_dec_and_test(&fc->count)) {
 867                 struct fuse_iqueue *fiq = &fc->iq;
 868                 struct fuse_sync_bucket *bucket;
 869
 870                 if (IS_ENABLED(CONFIG_FUSE_DAX))
 871                         fuse_dax_conn_free(fc);
 872                 if (fiq->ops->release)
 873                         fiq->ops->release(fiq);
 874                 put_pid_ns(fc->pid_ns);
 875                 put_user_ns(fc->user_ns);
 876                 bucket = rcu_dereference_protected(fc->curr_bucket, 1);
 877                 if (bucket) {
 878                         WARN_ON(atomic_read(&bucket->count) != 1);
 879                         kfree(bucket);
 880                 }
 881                 fc->release(fc);
 882         }
 883 }
 884 EXPORT_SYMBOL_GPL(fuse_conn_put);
 885
 886 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
 887 {
 888         refcount_inc(&fc->count);
 889         return fc;
 890 }
 891 EXPORT_SYMBOL_GPL(fuse_conn_get);
 892
 893 static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
 894 {
 895         struct fuse_attr attr;
 896         memset(&attr, 0, sizeof(attr));
 897
 898         attr.mode = mode;
 899         attr.ino = FUSE_ROOT_ID;
 900         attr.nlink = 1;
 901         return fuse_iget(sb, 1, 0, &attr, 0, 0);
 902 }
 903
 904 struct fuse_inode_handle {
 905         u64 nodeid;
 906         u32 generation;
 907 };
 908
 909 static struct dentry *fuse_get_dentry(struct super_block *sb,
 910                                       struct fuse_inode_handle *handle)
 911 {
 912         struct fuse_conn *fc = get_fuse_conn_super(sb);
 913         struct inode *inode;
 914         struct dentry *entry;
 915         int err = -ESTALE;
 916
 917         if (handle->nodeid == 0)
 918                 goto out_err;
 919
 920         inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid);
 921         if (!inode) {
 922                 struct fuse_entry_out outarg;
 923                 const struct qstr name = QSTR_INIT(".", 1);
 924
 925                 if (!fc->export_support)
 926                         goto out_err;
 927
 928                 err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg,
 929                                        &inode);
 930                 if (err && err != -ENOENT)
 931                         goto out_err;
 932                 if (err || !inode) {
 933                         err = -ESTALE;
 934                         goto out_err;
 935                 }
 936                 err = -EIO;
 937                 if (get_node_id(inode) != handle->nodeid)
 938                         goto out_iput;
 939         }
 940         err = -ESTALE;
 941         if (inode->i_generation != handle->generation)
 942                 goto out_iput;
 943
 944         entry = d_obtain_alias(inode);
 945         if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
 946                 fuse_invalidate_entry_cache(entry);
 947
 948         return entry;
 949
 950  out_iput:
 951         iput(inode);
 952  out_err:
 953         return ERR_PTR(err);
 954 }
 955
 956 static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
 957                            struct inode *parent)
 958 {
 959         int len = parent ? 6 : 3;
 960         u64 nodeid;
 961         u32 generation;
 962
 963         if (*max_len < len) {
 964                 *max_len = len;
 965                 return  FILEID_INVALID;
 966         }
 967
 968         nodeid = get_fuse_inode(inode)->nodeid;
 969         generation = inode->i_generation;
 970
 971         fh[0] = (u32)(nodeid >> 32);
 972         fh[1] = (u32)(nodeid & 0xffffffff);
 973         fh[2] = generation;
 974
 975         if (parent) {
 976                 nodeid = get_fuse_inode(parent)->nodeid;
 977                 generation = parent->i_generation;
 978
 979                 fh[3] = (u32)(nodeid >> 32);
 980                 fh[4] = (u32)(nodeid & 0xffffffff);
 981                 fh[5] = generation;
 982         }
 983
 984         *max_len = len;
 985         return parent ? 0x82 : 0x81;
 986 }
 987
 988 static struct dentry *fuse_fh_to_dentry(struct super_block *sb,
 989                 struct fid *fid, int fh_len, int fh_type)
 990 {
 991         struct fuse_inode_handle handle;
 992
 993         if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3)
 994                 return NULL;
 995
 996         handle.nodeid = (u64) fid->raw[0] << 32;
 997         handle.nodeid |= (u64) fid->raw[1];
 998         handle.generation = fid->raw[2];
 999         return fuse_get_dentry(sb, &handle);
1000 }
1001
1002 static struct dentry *fuse_fh_to_parent(struct super_block *sb,
1003                 struct fid *fid, int fh_len, int fh_type)
1004 {
1005         struct fuse_inode_handle parent;
1006
1007         if (fh_type != 0x82 || fh_len < 6)
1008                 return NULL;
1009
1010         parent.nodeid = (u64) fid->raw[3] << 32;
1011         parent.nodeid |= (u64) fid->raw[4];
1012         parent.generation = fid->raw[5];
1013         return fuse_get_dentry(sb, &parent);
1014 }
1015
1016 static struct dentry *fuse_get_parent(struct dentry *child)
1017 {
1018         struct inode *child_inode = d_inode(child);
1019         struct fuse_conn *fc = get_fuse_conn(child_inode);
1020         struct inode *inode;
1021         struct dentry *parent;
1022         struct fuse_entry_out outarg;
1023         int err;
1024
1025         if (!fc->export_support)
1026                 return ERR_PTR(-ESTALE);
1027
1028         err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
1029                                &dotdot_name, &outarg, &inode);
1030         if (err) {
1031                 if (err == -ENOENT)
1032                         return ERR_PTR(-ESTALE);
1033                 return ERR_PTR(err);
1034         }
1035
1036         parent = d_obtain_alias(inode);
1037         if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
1038                 fuse_invalidate_entry_cache(parent);
1039
1040         return parent;
1041 }
1042
1043 static const struct export_operations fuse_export_operations = {
1044         .fh_to_dentry   = fuse_fh_to_dentry,
1045         .fh_to_parent   = fuse_fh_to_parent,
1046         .encode_fh      = fuse_encode_fh,
1047         .get_parent     = fuse_get_parent,
1048 };
1049
1050 static const struct super_operations fuse_super_operations = {
1051         .alloc_inode    = fuse_alloc_inode,
1052         .free_inode     = fuse_free_inode,
1053         .evict_inode    = fuse_evict_inode,
1054         .write_inode    = fuse_write_inode,
1055         .drop_inode     = generic_delete_inode,
1056         .umount_begin   = fuse_umount_begin,
1057         .statfs         = fuse_statfs,
1058         .sync_fs        = fuse_sync_fs,
1059         .show_options   = fuse_show_options,
1060 };
1061
1062 static void sanitize_global_limit(unsigned *limit)
1063 {
1064         /*
1065          * The default maximum number of async requests is calculated to consume
1066          * 1/2^13 of the total memory, assuming 392 bytes per request.
1067          */
1068         if (*limit == 0)
1069                 *limit = ((totalram_pages() << PAGE_SHIFT) >> 13) / 392;
1070
1071         if (*limit >= 1 << 16)
1072                 *limit = (1 << 16) - 1;
1073 }
1074
1075 static int set_global_limit(const char *val, const struct kernel_param *kp)
1076 {
1077         int rv;
1078
1079         rv = param_set_uint(val, kp);
1080         if (rv)
1081                 return rv;
1082
1083         sanitize_global_limit((unsigned *)kp->arg);
1084
1085         return 0;
1086 }
1087
1088 static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg)
1089 {
1090         int cap_sys_admin = capable(CAP_SYS_ADMIN);
1091
1092         if (arg->minor < 13)
1093                 return;
1094
1095         sanitize_global_limit(&max_user_bgreq);
1096         sanitize_global_limit(&max_user_congthresh);
1097
1098         spin_lock(&fc->bg_lock);
1099         if (arg->max_background) {
1100                 fc->max_background = arg->max_background;
1101
1102                 if (!cap_sys_admin && fc->max_background > max_user_bgreq)
1103                         fc->max_background = max_user_bgreq;
1104         }
1105         if (arg->congestion_threshold) {
1106                 fc->congestion_threshold = arg->congestion_threshold;
1107
1108                 if (!cap_sys_admin &&
1109                     fc->congestion_threshold > max_user_congthresh)
1110                         fc->congestion_threshold = max_user_congthresh;
1111         }
1112         spin_unlock(&fc->bg_lock);
1113 }
1114
1115 struct fuse_init_args {
1116         struct fuse_args args;
1117         struct fuse_init_in in;
1118         struct fuse_init_out out;
1119 };
1120
1121 static void process_init_reply(struct fuse_mount *fm, struct fuse_args *args,
1122                                int error)
1123 {
1124         struct fuse_conn *fc = fm->fc;
1125         struct fuse_init_args *ia = container_of(args, typeof(*ia), args);
1126         struct fuse_init_out *arg = &ia->out;
1127         bool ok = true;
1128
1129         if (error || arg->major != FUSE_KERNEL_VERSION)
1130                 ok = false;
1131         else {
1132                 unsigned long ra_pages;
1133
1134                 process_init_limits(fc, arg);
1135
1136                 if (arg->minor >= 6) {
1137                         u64 flags = arg->flags | (u64) arg->flags2 << 32;
1138
1139                         ra_pages = arg->max_readahead / PAGE_SIZE;
1140                         if (flags & FUSE_ASYNC_READ)
1141                                 fc->async_read = 1;
1142                         if (!(flags & FUSE_POSIX_LOCKS))
1143                                 fc->no_lock = 1;
1144                         if (arg->minor >= 17) {
1145                                 if (!(flags & FUSE_FLOCK_LOCKS))
1146                                         fc->no_flock = 1;
1147                         } else {
1148                                 if (!(flags & FUSE_POSIX_LOCKS))
1149                                         fc->no_flock = 1;
1150                         }
1151                         if (flags & FUSE_ATOMIC_O_TRUNC)
1152                                 fc->atomic_o_trunc = 1;
1153                         if (arg->minor >= 9) {
1154                                 /* LOOKUP has dependency on proto version */
1155                                 if (flags & FUSE_EXPORT_SUPPORT)
1156                                         fc->export_support = 1;
1157                         }
1158                         if (flags & FUSE_BIG_WRITES)
1159                                 fc->big_writes = 1;
1160                         if (flags & FUSE_DONT_MASK)
1161                                 fc->dont_mask = 1;
1162                         if (flags & FUSE_AUTO_INVAL_DATA)
1163                                 fc->auto_inval_data = 1;
1164                         else if (flags & FUSE_EXPLICIT_INVAL_DATA)
1165                                 fc->explicit_inval_data = 1;
1166                         if (flags & FUSE_DO_READDIRPLUS) {
1167                                 fc->do_readdirplus = 1;
1168                                 if (flags & FUSE_READDIRPLUS_AUTO)
1169                                         fc->readdirplus_auto = 1;
1170                         }
1171                         if (flags & FUSE_ASYNC_DIO)
1172                                 fc->async_dio = 1;
1173                         if (flags & FUSE_WRITEBACK_CACHE)
1174                                 fc->writeback_cache = 1;
1175                         if (flags & FUSE_PARALLEL_DIROPS)
1176                                 fc->parallel_dirops = 1;
1177                         if (flags & FUSE_HANDLE_KILLPRIV)
1178                                 fc->handle_killpriv = 1;
1179                         if (arg->time_gran && arg->time_gran <= 1000000000)
1180                                 fm->sb->s_time_gran = arg->time_gran;
1181                         if ((flags & FUSE_POSIX_ACL)) {
1182                                 fc->default_permissions = 1;
1183                                 fc->posix_acl = 1;
1184                         }
1185                         if (flags & FUSE_CACHE_SYMLINKS)
1186                                 fc->cache_symlinks = 1;
1187                         if (flags & FUSE_ABORT_ERROR)
1188                                 fc->abort_err = 1;
1189                         if (flags & FUSE_MAX_PAGES) {
1190                                 fc->max_pages =
1191                                         min_t(unsigned int, fc->max_pages_limit,
1192                                         max_t(unsigned int, arg->max_pages, 1));
1193                         }
1194                         if (IS_ENABLED(CONFIG_FUSE_DAX)) {
1195                                 if (flags & FUSE_MAP_ALIGNMENT &&
1196                                     !fuse_dax_check_alignment(fc, arg->map_alignment)) {
1197                                         ok = false;
1198                                 }
1199                                 if (flags & FUSE_HAS_INODE_DAX)
1200                                         fc->inode_dax = 1;
1201                         }
1202                         if (flags & FUSE_HANDLE_KILLPRIV_V2) {
1203                                 fc->handle_killpriv_v2 = 1;
1204                                 fm->sb->s_flags |= SB_NOSEC;
1205                         }
1206                         if (flags & FUSE_SETXATTR_EXT)
1207                                 fc->setxattr_ext = 1;
1208                         if (flags & FUSE_SECURITY_CTX)
1209                                 fc->init_security = 1;
1210                 } else {
1211                         ra_pages = fc->max_read / PAGE_SIZE;
1212                         fc->no_lock = 1;
1213                         fc->no_flock = 1;
1214                 }
1215
1216                 fm->sb->s_bdi->ra_pages =
1217                                 min(fm->sb->s_bdi->ra_pages, ra_pages);
1218                 fc->minor = arg->minor;
1219                 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
1220                 fc->max_write = max_t(unsigned, 4096, fc->max_write);
1221                 fc->conn_init = 1;
1222         }
1223         kfree(ia);
1224
1225         if (!ok) {
1226                 fc->conn_init = 0;
1227                 fc->conn_error = 1;
1228         }
1229
1230         fuse_set_initialized(fc);
1231         wake_up_all(&fc->blocked_waitq);
1232 }
1233
1234 void fuse_send_init(struct fuse_mount *fm)
1235 {
1236         struct fuse_init_args *ia;
1237         u64 flags;
1238
1239         ia = kzalloc(sizeof(*ia), GFP_KERNEL | __GFP_NOFAIL);
1240
1241         ia->in.major = FUSE_KERNEL_VERSION;
1242         ia->in.minor = FUSE_KERNEL_MINOR_VERSION;
1243         ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE;
1244         flags =
1245                 FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
1246                 FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
1247                 FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
1248                 FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
1249                 FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
1250                 FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
1251                 FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL |
1252                 FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS |
1253                 FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA |
1254                 FUSE_HANDLE_KILLPRIV_V2 | FUSE_SETXATTR_EXT | FUSE_INIT_EXT |
1255                 FUSE_SECURITY_CTX;
1256 #ifdef CONFIG_FUSE_DAX
1257         if (fm->fc->dax)
1258                 flags |= FUSE_MAP_ALIGNMENT;
1259         if (fuse_is_inode_dax_mode(fm->fc->dax_mode))
1260                 flags |= FUSE_HAS_INODE_DAX;
1261 #endif
1262         if (fm->fc->auto_submounts)
1263                 flags |= FUSE_SUBMOUNTS;
1264
1265         ia->in.flags = flags;
1266         ia->in.flags2 = flags >> 32;
1267
1268         ia->args.opcode = FUSE_INIT;
1269         ia->args.in_numargs = 1;
1270         ia->args.in_args[0].size = sizeof(ia->in);
1271         ia->args.in_args[0].value = &ia->in;
1272         ia->args.out_numargs = 1;
1273         /* Variable length argument used for backward compatibility
1274            with interface version < 7.5.  Rest of init_out is zeroed
1275            by do_get_request(), so a short reply is not a problem */
1276         ia->args.out_argvar = true;
1277         ia->args.out_args[0].size = sizeof(ia->out);
1278         ia->args.out_args[0].value = &ia->out;
1279         ia->args.force = true;
1280         ia->args.nocreds = true;
1281         ia->args.end = process_init_reply;
1282
1283         if (fuse_simple_background(fm, &ia->args, GFP_KERNEL) != 0)
1284                 process_init_reply(fm, &ia->args, -ENOTCONN);
1285 }
1286 EXPORT_SYMBOL_GPL(fuse_send_init);
1287
1288 void fuse_free_conn(struct fuse_conn *fc)
1289 {
1290         WARN_ON(!list_empty(&fc->devices));
1291         kfree_rcu(fc, rcu);
1292 }
1293 EXPORT_SYMBOL_GPL(fuse_free_conn);
1294
1295 static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
1296 {
1297         int err;
1298         char *suffix = "";
1299
1300         if (sb->s_bdev) {
1301                 suffix = "-fuseblk";
1302                 /*
1303                  * sb->s_bdi points to blkdev's bdi however we want to redirect
1304                  * it to our private bdi...
1305                  */
1306                 bdi_put(sb->s_bdi);
1307                 sb->s_bdi = &noop_backing_dev_info;
1308         }
1309         err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev),
1310                                    MINOR(fc->dev), suffix);
1311         if (err)
1312                 return err;
1313
1314         /* fuse does it's own writeback accounting */
1315         sb->s_bdi->capabilities &= ~BDI_CAP_WRITEBACK_ACCT;
1316         sb->s_bdi->capabilities |= BDI_CAP_STRICTLIMIT;
1317
1318         /*
1319          * For a single fuse filesystem use max 1% of dirty +
1320          * writeback threshold.
1321          *
1322          * This gives about 1M of write buffer for memory maps on a
1323          * machine with 1G and 10% dirty_ratio, which should be more
1324          * than enough.
1325          *
1326          * Privileged users can raise it by writing to
1327          *
1328          *    /sys/class/bdi/<bdi>/max_ratio
1329          */
1330         bdi_set_max_ratio(sb->s_bdi, 1);
1331
1332         return 0;
1333 }
1334
1335 struct fuse_dev *fuse_dev_alloc(void)
1336 {
1337         struct fuse_dev *fud;
1338         struct list_head *pq;
1339
1340         fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL);
1341         if (!fud)
1342                 return NULL;
1343
1344         pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL);
1345         if (!pq) {
1346                 kfree(fud);
1347                 return NULL;
1348         }
1349
1350         fud->pq.processing = pq;
1351         fuse_pqueue_init(&fud->pq);
1352
1353         return fud;
1354 }
1355 EXPORT_SYMBOL_GPL(fuse_dev_alloc);
1356
1357 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc)
1358 {
1359         fud->fc = fuse_conn_get(fc);
1360         spin_lock(&fc->lock);
1361         list_add_tail(&fud->entry, &fc->devices);
1362         spin_unlock(&fc->lock);
1363 }
1364 EXPORT_SYMBOL_GPL(fuse_dev_install);
1365
1366 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc)
1367 {
1368         struct fuse_dev *fud;
1369
1370         fud = fuse_dev_alloc();
1371         if (!fud)
1372                 return NULL;
1373
1374         fuse_dev_install(fud, fc);
1375         return fud;
1376 }
1377 EXPORT_SYMBOL_GPL(fuse_dev_alloc_install);
1378
1379 void fuse_dev_free(struct fuse_dev *fud)
1380 {
1381         struct fuse_conn *fc = fud->fc;
1382
1383         if (fc) {
1384                 spin_lock(&fc->lock);
1385                 list_del(&fud->entry);
1386                 spin_unlock(&fc->lock);
1387
1388                 fuse_conn_put(fc);
1389         }
1390         kfree(fud->pq.processing);
1391         kfree(fud);
1392 }
1393 EXPORT_SYMBOL_GPL(fuse_dev_free);
1394
1395 static void fuse_fill_attr_from_inode(struct fuse_attr *attr,
1396                                       const struct fuse_inode *fi)
1397 {
1398         *attr = (struct fuse_attr){
1399                 .ino            = fi->inode.i_ino,
1400                 .size           = fi->inode.i_size,
1401                 .blocks         = fi->inode.i_blocks,
1402                 .atime          = fi->inode.i_atime.tv_sec,
1403                 .mtime          = fi->inode.i_mtime.tv_sec,
1404                 .ctime          = fi->inode.i_ctime.tv_sec,
1405                 .atimensec      = fi->inode.i_atime.tv_nsec,
1406                 .mtimensec      = fi->inode.i_mtime.tv_nsec,
1407                 .ctimensec      = fi->inode.i_ctime.tv_nsec,
1408                 .mode           = fi->inode.i_mode,
1409                 .nlink          = fi->inode.i_nlink,
1410                 .uid            = fi->inode.i_uid.val,
1411                 .gid            = fi->inode.i_gid.val,
1412                 .rdev           = fi->inode.i_rdev,
1413                 .blksize        = 1u << fi->inode.i_blkbits,
1414         };
1415 }
1416
1417 static void fuse_sb_defaults(struct super_block *sb)
1418 {
1419         sb->s_magic = FUSE_SUPER_MAGIC;
1420         sb->s_op = &fuse_super_operations;
1421         sb->s_xattr = fuse_xattr_handlers;
1422         sb->s_maxbytes = MAX_LFS_FILESIZE;
1423         sb->s_time_gran = 1;
1424         sb->s_export_op = &fuse_export_operations;
1425         sb->s_iflags |= SB_I_IMA_UNVERIFIABLE_SIGNATURE;
1426         if (sb->s_user_ns != &init_user_ns)
1427                 sb->s_iflags |= SB_I_UNTRUSTED_MOUNTER;
1428         sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION);
1429 }
1430
1431 static int fuse_fill_super_submount(struct super_block *sb,
1432                                     struct fuse_inode *parent_fi)
1433 {
1434         struct fuse_mount *fm = get_fuse_mount_super(sb);
1435         struct super_block *parent_sb = parent_fi->inode.i_sb;
1436         struct fuse_attr root_attr;
1437         struct inode *root;
1438
1439         fuse_sb_defaults(sb);
1440         fm->sb = sb;
1441
1442         WARN_ON(sb->s_bdi != &noop_backing_dev_info);
1443         sb->s_bdi = bdi_get(parent_sb->s_bdi);
1444
1445         sb->s_xattr = parent_sb->s_xattr;
1446         sb->s_time_gran = parent_sb->s_time_gran;
1447         sb->s_blocksize = parent_sb->s_blocksize;
1448         sb->s_blocksize_bits = parent_sb->s_blocksize_bits;
1449         sb->s_subtype = kstrdup(parent_sb->s_subtype, GFP_KERNEL);
1450         if (parent_sb->s_subtype && !sb->s_subtype)
1451                 return -ENOMEM;
1452
1453         fuse_fill_attr_from_inode(&root_attr, parent_fi);
1454         root = fuse_iget(sb, parent_fi->nodeid, 0, &root_attr, 0, 0);
1455         /*
1456          * This inode is just a duplicate, so it is not looked up and
1457          * its nlookup should not be incremented.  fuse_iget() does
1458          * that, though, so undo it here.
1459          */
1460         get_fuse_inode(root)->nlookup--;
1461         sb->s_d_op = &fuse_dentry_operations;
1462         sb->s_root = d_make_root(root);
1463         if (!sb->s_root)
1464                 return -ENOMEM;
1465
1466         return 0;
1467 }
1468
1469 /* Filesystem context private data holds the FUSE inode of the mount point */
1470 static int fuse_get_tree_submount(struct fs_context *fsc)
1471 {
1472         struct fuse_mount *fm;
1473         struct fuse_inode *mp_fi = fsc->fs_private;
1474         struct fuse_conn *fc = get_fuse_conn(&mp_fi->inode);
1475         struct super_block *sb;
1476         int err;
1477
1478         fm = kzalloc(sizeof(struct fuse_mount), GFP_KERNEL);
1479         if (!fm)
1480                 return -ENOMEM;
1481
1482         fm->fc = fuse_conn_get(fc);
1483         fsc->s_fs_info = fm;
1484         sb = sget_fc(fsc, NULL, set_anon_super_fc);
1485         if (fsc->s_fs_info)
1486                 fuse_mount_destroy(fm);
1487         if (IS_ERR(sb))
1488                 return PTR_ERR(sb);
1489
1490         /* Initialize superblock, making @mp_fi its root */
1491         err = fuse_fill_super_submount(sb, mp_fi);
1492         if (err) {
1493                 deactivate_locked_super(sb);
1494                 return err;
1495         }
1496
1497         down_write(&fc->killsb);
1498         list_add_tail(&fm->fc_entry, &fc->mounts);
1499         up_write(&fc->killsb);
1500
1501         sb->s_flags |= SB_ACTIVE;
1502         fsc->root = dget(sb->s_root);
1503
1504         return 0;
1505 }
1506
1507 static const struct fs_context_operations fuse_context_submount_ops = {
1508         .get_tree       = fuse_get_tree_submount,
1509 };
1510
1511 int fuse_init_fs_context_submount(struct fs_context *fsc)
1512 {
1513         fsc->ops = &fuse_context_submount_ops;
1514         return 0;
1515 }
1516 EXPORT_SYMBOL_GPL(fuse_init_fs_context_submount);
1517
1518 int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
1519 {
1520         struct fuse_dev *fud = NULL;
1521         struct fuse_mount *fm = get_fuse_mount_super(sb);
1522         struct fuse_conn *fc = fm->fc;
1523         struct inode *root;
1524         struct dentry *root_dentry;
1525         int err;
1526
1527         err = -EINVAL;
1528         if (sb->s_flags & SB_MANDLOCK)
1529                 goto err;
1530
1531         rcu_assign_pointer(fc->curr_bucket, fuse_sync_bucket_alloc());
1532         fuse_sb_defaults(sb);
1533
1534         if (ctx->is_bdev) {
1535 #ifdef CONFIG_BLOCK
1536                 err = -EINVAL;
1537                 if (!sb_set_blocksize(sb, ctx->blksize))
1538                         goto err;
1539 #endif
1540         } else {
1541                 sb->s_blocksize = PAGE_SIZE;
1542                 sb->s_blocksize_bits = PAGE_SHIFT;
1543         }
1544
1545         sb->s_subtype = ctx->subtype;
1546         ctx->subtype = NULL;
1547         if (IS_ENABLED(CONFIG_FUSE_DAX)) {
1548                 err = fuse_dax_conn_alloc(fc, ctx->dax_mode, ctx->dax_dev);
1549                 if (err)
1550                         goto err;
1551         }
1552
1553         if (ctx->fudptr) {
1554                 err = -ENOMEM;
1555                 fud = fuse_dev_alloc_install(fc);
1556                 if (!fud)
1557                         goto err_free_dax;
1558         }
1559
1560         fc->dev = sb->s_dev;
1561         fm->sb = sb;
1562         err = fuse_bdi_init(fc, sb);
1563         if (err)
1564                 goto err_dev_free;
1565
1566         /* Handle umasking inside the fuse code */
1567         if (sb->s_flags & SB_POSIXACL)
1568                 fc->dont_mask = 1;
1569         sb->s_flags |= SB_POSIXACL;
1570
1571         fc->default_permissions = ctx->default_permissions;
1572         fc->allow_other = ctx->allow_other;
1573         fc->user_id = ctx->user_id;
1574         fc->group_id = ctx->group_id;
1575         fc->legacy_opts_show = ctx->legacy_opts_show;
1576         fc->max_read = max_t(unsigned int, 4096, ctx->max_read);
1577         fc->destroy = ctx->destroy;
1578         fc->no_control = ctx->no_control;
1579         fc->no_force_umount = ctx->no_force_umount;
1580
1581         err = -ENOMEM;
1582         root = fuse_get_root_inode(sb, ctx->rootmode);
1583         sb->s_d_op = &fuse_root_dentry_operations;
1584         root_dentry = d_make_root(root);
1585         if (!root_dentry)
1586                 goto err_dev_free;
1587         /* Root dentry doesn't have .d_revalidate */
1588         sb->s_d_op = &fuse_dentry_operations;
1589
1590         mutex_lock(&fuse_mutex);
1591         err = -EINVAL;
1592         if (ctx->fudptr && *ctx->fudptr)
1593                 goto err_unlock;
1594
1595         err = fuse_ctl_add_conn(fc);
1596         if (err)
1597                 goto err_unlock;
1598
1599         list_add_tail(&fc->entry, &fuse_conn_list);
1600         sb->s_root = root_dentry;
1601         if (ctx->fudptr)
1602                 *ctx->fudptr = fud;
1603         mutex_unlock(&fuse_mutex);
1604         return 0;
1605
1606  err_unlock:
1607         mutex_unlock(&fuse_mutex);
1608         dput(root_dentry);
1609  err_dev_free:
1610         if (fud)
1611                 fuse_dev_free(fud);
1612  err_free_dax:
1613         if (IS_ENABLED(CONFIG_FUSE_DAX))
1614                 fuse_dax_conn_free(fc);
1615  err:
1616         return err;
1617 }
1618 EXPORT_SYMBOL_GPL(fuse_fill_super_common);
1619
1620 static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
1621 {
1622         struct fuse_fs_context *ctx = fsc->fs_private;
1623         int err;
1624
1625         if (!ctx->file || !ctx->rootmode_present ||
1626             !ctx->user_id_present || !ctx->group_id_present)
1627                 return -EINVAL;
1628
1629         /*
1630          * Require mount to happen from the same user namespace which
1631          * opened /dev/fuse to prevent potential attacks.
1632          */
1633         if ((ctx->file->f_op != &fuse_dev_operations) ||
1634             (ctx->file->f_cred->user_ns != sb->s_user_ns))
1635                 return -EINVAL;
1636         ctx->fudptr = &ctx->file->private_data;
1637
1638         err = fuse_fill_super_common(sb, ctx);
1639         if (err)
1640                 return err;
1641         /* file->private_data shall be visible on all CPUs after this */
1642         smp_mb();
1643         fuse_send_init(get_fuse_mount_super(sb));
1644         return 0;
1645 }
1646
1647 /*
1648  * This is the path where user supplied an already initialized fuse dev.  In
1649  * this case never create a new super if the old one is gone.
1650  */
1651 static int fuse_set_no_super(struct super_block *sb, struct fs_context *fsc)
1652 {
1653         return -ENOTCONN;
1654 }
1655
1656 static int fuse_test_super(struct super_block *sb, struct fs_context *fsc)
1657 {
1658
1659         return fsc->sget_key == get_fuse_conn_super(sb);
1660 }
1661
1662 static int fuse_get_tree(struct fs_context *fsc)
1663 {
1664         struct fuse_fs_context *ctx = fsc->fs_private;
1665         struct fuse_dev *fud;
1666         struct fuse_conn *fc;
1667         struct fuse_mount *fm;
1668         struct super_block *sb;
1669         int err;
1670
1671         fc = kmalloc(sizeof(*fc), GFP_KERNEL);
1672         if (!fc)
1673                 return -ENOMEM;
1674
1675         fm = kzalloc(sizeof(*fm), GFP_KERNEL);
1676         if (!fm) {
1677                 kfree(fc);
1678                 return -ENOMEM;
1679         }
1680
1681         fuse_conn_init(fc, fm, fsc->user_ns, &fuse_dev_fiq_ops, NULL);
1682         fc->release = fuse_free_conn;
1683
1684         fsc->s_fs_info = fm;
1685
1686         if (ctx->fd_present)
1687                 ctx->file = fget(ctx->fd);
1688
1689         if (IS_ENABLED(CONFIG_BLOCK) && ctx->is_bdev) {
1690                 err = get_tree_bdev(fsc, fuse_fill_super);
1691                 goto out;
1692         }
1693         /*
1694          * While block dev mount can be initialized with a dummy device fd
1695          * (found by device name), normal fuse mounts can't
1696          */
1697         err = -EINVAL;
1698         if (!ctx->file)
1699                 goto out;
1700
1701         /*
1702          * Allow creating a fuse mount with an already initialized fuse
1703          * connection
1704          */
1705         fud = READ_ONCE(ctx->file->private_data);
1706         if (ctx->file->f_op == &fuse_dev_operations && fud) {
1707                 fsc->sget_key = fud->fc;
1708                 sb = sget_fc(fsc, fuse_test_super, fuse_set_no_super);
1709                 err = PTR_ERR_OR_ZERO(sb);
1710                 if (!IS_ERR(sb))
1711                         fsc->root = dget(sb->s_root);
1712         } else {
1713                 err = get_tree_nodev(fsc, fuse_fill_super);
1714         }
1715 out:
1716         if (fsc->s_fs_info)
1717                 fuse_mount_destroy(fm);
1718         if (ctx->file)
1719                 fput(ctx->file);
1720         return err;
1721 }
1722
1723 static const struct fs_context_operations fuse_context_ops = {
1724         .free           = fuse_free_fsc,
1725         .parse_param    = fuse_parse_param,
1726         .reconfigure    = fuse_reconfigure,
1727         .get_tree       = fuse_get_tree,
1728 };
1729
1730 /*
1731  * Set up the filesystem mount context.
1732  */
1733 static int fuse_init_fs_context(struct fs_context *fsc)
1734 {
1735         struct fuse_fs_context *ctx;
1736
1737         ctx = kzalloc(sizeof(struct fuse_fs_context), GFP_KERNEL);
1738         if (!ctx)
1739                 return -ENOMEM;
1740
1741         ctx->max_read = ~0;
1742         ctx->blksize = FUSE_DEFAULT_BLKSIZE;
1743         ctx->legacy_opts_show = true;
1744
1745 #ifdef CONFIG_BLOCK
1746         if (fsc->fs_type == &fuseblk_fs_type) {
1747                 ctx->is_bdev = true;
1748                 ctx->destroy = true;
1749         }
1750 #endif
1751
1752         fsc->fs_private = ctx;
1753         fsc->ops = &fuse_context_ops;
1754         return 0;
1755 }
1756
1757 bool fuse_mount_remove(struct fuse_mount *fm)
1758 {
1759         struct fuse_conn *fc = fm->fc;
1760         bool last = false;
1761
1762         down_write(&fc->killsb);
1763         list_del_init(&fm->fc_entry);
1764         if (list_empty(&fc->mounts))
1765                 last = true;
1766         up_write(&fc->killsb);
1767
1768         return last;
1769 }
1770 EXPORT_SYMBOL_GPL(fuse_mount_remove);
1771
1772 void fuse_conn_destroy(struct fuse_mount *fm)
1773 {
1774         struct fuse_conn *fc = fm->fc;
1775
1776         if (fc->destroy)
1777                 fuse_send_destroy(fm);
1778
1779         fuse_abort_conn(fc);
1780         fuse_wait_aborted(fc);
1781
1782         if (!list_empty(&fc->entry)) {
1783                 mutex_lock(&fuse_mutex);
1784                 list_del(&fc->entry);
1785                 fuse_ctl_remove_conn(fc);
1786                 mutex_unlock(&fuse_mutex);
1787         }
1788 }
1789 EXPORT_SYMBOL_GPL(fuse_conn_destroy);
1790
1791 static void fuse_sb_destroy(struct super_block *sb)
1792 {
1793         struct fuse_mount *fm = get_fuse_mount_super(sb);
1794         bool last;
1795
1796         if (sb->s_root) {
1797                 last = fuse_mount_remove(fm);
1798                 if (last)
1799                         fuse_conn_destroy(fm);
1800         }
1801 }
1802
1803 void fuse_mount_destroy(struct fuse_mount *fm)
1804 {
1805         fuse_conn_put(fm->fc);
1806         kfree(fm);
1807 }
1808 EXPORT_SYMBOL(fuse_mount_destroy);
1809
1810 static void fuse_kill_sb_anon(struct super_block *sb)
1811 {
1812         fuse_sb_destroy(sb);
1813         kill_anon_super(sb);
1814         fuse_mount_destroy(get_fuse_mount_super(sb));
1815 }
1816
1817 static struct file_system_type fuse_fs_type = {
1818         .owner          = THIS_MODULE,
1819         .name           = "fuse",
1820         .fs_flags       = FS_HAS_SUBTYPE | FS_USERNS_MOUNT,
1821         .init_fs_context = fuse_init_fs_context,
1822         .parameters     = fuse_fs_parameters,
1823         .kill_sb        = fuse_kill_sb_anon,
1824 };
1825 MODULE_ALIAS_FS("fuse");
1826
1827 #ifdef CONFIG_BLOCK
1828 static void fuse_kill_sb_blk(struct super_block *sb)
1829 {
1830         fuse_sb_destroy(sb);
1831         kill_block_super(sb);
1832         fuse_mount_destroy(get_fuse_mount_super(sb));
1833 }
1834
1835 static struct file_system_type fuseblk_fs_type = {
1836         .owner          = THIS_MODULE,
1837         .name           = "fuseblk",
1838         .init_fs_context = fuse_init_fs_context,
1839         .parameters     = fuse_fs_parameters,
1840         .kill_sb        = fuse_kill_sb_blk,
1841         .fs_flags       = FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1842 };
1843 MODULE_ALIAS_FS("fuseblk");
1844
1845 static inline int register_fuseblk(void)
1846 {
1847         return register_filesystem(&fuseblk_fs_type);
1848 }
1849
1850 static inline void unregister_fuseblk(void)
1851 {
1852         unregister_filesystem(&fuseblk_fs_type);
1853 }
1854 #else
1855 static inline int register_fuseblk(void)
1856 {
1857         return 0;
1858 }
1859
1860 static inline void unregister_fuseblk(void)
1861 {
1862 }
1863 #endif
1864
1865 static void fuse_inode_init_once(void *foo)
1866 {
1867         struct inode *inode = foo;
1868
1869         inode_init_once(inode);
1870 }
1871
1872 static int __init fuse_fs_init(void)
1873 {
1874         int err;
1875
1876         fuse_inode_cachep = kmem_cache_create("fuse_inode",
1877                         sizeof(struct fuse_inode), 0,
1878                         SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT|SLAB_RECLAIM_ACCOUNT,
1879                         fuse_inode_init_once);
1880         err = -ENOMEM;
1881         if (!fuse_inode_cachep)
1882                 goto out;
1883
1884         err = register_fuseblk();
1885         if (err)
1886                 goto out2;
1887
1888         err = register_filesystem(&fuse_fs_type);
1889         if (err)
1890                 goto out3;
1891
1892         return 0;
1893
1894  out3:
1895         unregister_fuseblk();
1896  out2:
1897         kmem_cache_destroy(fuse_inode_cachep);
1898  out:
1899         return err;
1900 }
1901
1902 static void fuse_fs_cleanup(void)
1903 {
1904         unregister_filesystem(&fuse_fs_type);
1905         unregister_fuseblk();
1906
1907         /*
1908          * Make sure all delayed rcu free inodes are flushed before we
1909          * destroy cache.
1910          */
1911         rcu_barrier();
1912         kmem_cache_destroy(fuse_inode_cachep);
1913 }
1914
1915 static struct kobject *fuse_kobj;
1916
1917 static int fuse_sysfs_init(void)
1918 {
1919         int err;
1920
1921         fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1922         if (!fuse_kobj) {
1923                 err = -ENOMEM;
1924                 goto out_err;
1925         }
1926
1927         err = sysfs_create_mount_point(fuse_kobj, "connections");
1928         if (err)
1929                 goto out_fuse_unregister;
1930
1931         return 0;
1932
1933  out_fuse_unregister:
1934         kobject_put(fuse_kobj);
1935  out_err:
1936         return err;
1937 }
1938
1939 static void fuse_sysfs_cleanup(void)
1940 {
1941         sysfs_remove_mount_point(fuse_kobj, "connections");
1942         kobject_put(fuse_kobj);
1943 }
1944
1945 static int __init fuse_init(void)
1946 {
1947         int res;
1948
1949         pr_info("init (API version %i.%i)\n",
1950                 FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
1951
1952         INIT_LIST_HEAD(&fuse_conn_list);
1953         res = fuse_fs_init();
1954         if (res)
1955                 goto err;
1956
1957         res = fuse_dev_init();
1958         if (res)
1959                 goto err_fs_cleanup;
1960
1961         res = fuse_sysfs_init();
1962         if (res)
1963                 goto err_dev_cleanup;
1964
1965         res = fuse_ctl_init();
1966         if (res)
1967                 goto err_sysfs_cleanup;
1968
1969         sanitize_global_limit(&max_user_bgreq);
1970         sanitize_global_limit(&max_user_congthresh);
1971
1972         return 0;
1973
1974  err_sysfs_cleanup:
1975         fuse_sysfs_cleanup();
1976  err_dev_cleanup:
1977         fuse_dev_cleanup();
1978  err_fs_cleanup:
1979         fuse_fs_cleanup();
1980  err:
1981         return res;
1982 }
1983
1984 static void __exit fuse_exit(void)
1985 {
1986         pr_debug("exit\n");
1987
1988         fuse_ctl_cleanup();
1989         fuse_sysfs_cleanup();
1990         fuse_fs_cleanup();
1991         fuse_dev_cleanup();
1992 }
1993
1994 module_init(fuse_init);
1995 module_exit(fuse_exit);