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                         if (flags & FUSE_CREATE_SUPP_GROUP)
1211                                 fc->create_supp_group = 1;
1212                 } else {
1213                         ra_pages = fc->max_read / PAGE_SIZE;
1214                         fc->no_lock = 1;
1215                         fc->no_flock = 1;
1216                 }
1217
1218                 fm->sb->s_bdi->ra_pages =
1219                                 min(fm->sb->s_bdi->ra_pages, ra_pages);
1220                 fc->minor = arg->minor;
1221                 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
1222                 fc->max_write = max_t(unsigned, 4096, fc->max_write);
1223                 fc->conn_init = 1;
1224         }
1225         kfree(ia);
1226
1227         if (!ok) {
1228                 fc->conn_init = 0;
1229                 fc->conn_error = 1;
1230         }
1231
1232         fuse_set_initialized(fc);
1233         wake_up_all(&fc->blocked_waitq);
1234 }
1235
1236 void fuse_send_init(struct fuse_mount *fm)
1237 {
1238         struct fuse_init_args *ia;
1239         u64 flags;
1240
1241         ia = kzalloc(sizeof(*ia), GFP_KERNEL | __GFP_NOFAIL);
1242
1243         ia->in.major = FUSE_KERNEL_VERSION;
1244         ia->in.minor = FUSE_KERNEL_MINOR_VERSION;
1245         ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE;
1246         flags =
1247                 FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
1248                 FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
1249                 FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
1250                 FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
1251                 FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
1252                 FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
1253                 FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL |
1254                 FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS |
1255                 FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA |
1256                 FUSE_HANDLE_KILLPRIV_V2 | FUSE_SETXATTR_EXT | FUSE_INIT_EXT |
1257                 FUSE_SECURITY_CTX | FUSE_CREATE_SUPP_GROUP;
1258 #ifdef CONFIG_FUSE_DAX
1259         if (fm->fc->dax)
1260                 flags |= FUSE_MAP_ALIGNMENT;
1261         if (fuse_is_inode_dax_mode(fm->fc->dax_mode))
1262                 flags |= FUSE_HAS_INODE_DAX;
1263 #endif
1264         if (fm->fc->auto_submounts)
1265                 flags |= FUSE_SUBMOUNTS;
1266
1267         ia->in.flags = flags;
1268         ia->in.flags2 = flags >> 32;
1269
1270         ia->args.opcode = FUSE_INIT;
1271         ia->args.in_numargs = 1;
1272         ia->args.in_args[0].size = sizeof(ia->in);
1273         ia->args.in_args[0].value = &ia->in;
1274         ia->args.out_numargs = 1;
1275         /* Variable length argument used for backward compatibility
1276            with interface version < 7.5.  Rest of init_out is zeroed
1277            by do_get_request(), so a short reply is not a problem */
1278         ia->args.out_argvar = true;
1279         ia->args.out_args[0].size = sizeof(ia->out);
1280         ia->args.out_args[0].value = &ia->out;
1281         ia->args.force = true;
1282         ia->args.nocreds = true;
1283         ia->args.end = process_init_reply;
1284
1285         if (fuse_simple_background(fm, &ia->args, GFP_KERNEL) != 0)
1286                 process_init_reply(fm, &ia->args, -ENOTCONN);
1287 }
1288 EXPORT_SYMBOL_GPL(fuse_send_init);
1289
1290 void fuse_free_conn(struct fuse_conn *fc)
1291 {
1292         WARN_ON(!list_empty(&fc->devices));
1293         kfree_rcu(fc, rcu);
1294 }
1295 EXPORT_SYMBOL_GPL(fuse_free_conn);
1296
1297 static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
1298 {
1299         int err;
1300         char *suffix = "";
1301
1302         if (sb->s_bdev) {
1303                 suffix = "-fuseblk";
1304                 /*
1305                  * sb->s_bdi points to blkdev's bdi however we want to redirect
1306                  * it to our private bdi...
1307                  */
1308                 bdi_put(sb->s_bdi);
1309                 sb->s_bdi = &noop_backing_dev_info;
1310         }
1311         err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev),
1312                                    MINOR(fc->dev), suffix);
1313         if (err)
1314                 return err;
1315
1316         /* fuse does it's own writeback accounting */
1317         sb->s_bdi->capabilities &= ~BDI_CAP_WRITEBACK_ACCT;
1318         sb->s_bdi->capabilities |= BDI_CAP_STRICTLIMIT;
1319
1320         /*
1321          * For a single fuse filesystem use max 1% of dirty +
1322          * writeback threshold.
1323          *
1324          * This gives about 1M of write buffer for memory maps on a
1325          * machine with 1G and 10% dirty_ratio, which should be more
1326          * than enough.
1327          *
1328          * Privileged users can raise it by writing to
1329          *
1330          *    /sys/class/bdi/<bdi>/max_ratio
1331          */
1332         bdi_set_max_ratio(sb->s_bdi, 1);
1333
1334         return 0;
1335 }
1336
1337 struct fuse_dev *fuse_dev_alloc(void)
1338 {
1339         struct fuse_dev *fud;
1340         struct list_head *pq;
1341
1342         fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL);
1343         if (!fud)
1344                 return NULL;
1345
1346         pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL);
1347         if (!pq) {
1348                 kfree(fud);
1349                 return NULL;
1350         }
1351
1352         fud->pq.processing = pq;
1353         fuse_pqueue_init(&fud->pq);
1354
1355         return fud;
1356 }
1357 EXPORT_SYMBOL_GPL(fuse_dev_alloc);
1358
1359 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc)
1360 {
1361         fud->fc = fuse_conn_get(fc);
1362         spin_lock(&fc->lock);
1363         list_add_tail(&fud->entry, &fc->devices);
1364         spin_unlock(&fc->lock);
1365 }
1366 EXPORT_SYMBOL_GPL(fuse_dev_install);
1367
1368 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc)
1369 {
1370         struct fuse_dev *fud;
1371
1372         fud = fuse_dev_alloc();
1373         if (!fud)
1374                 return NULL;
1375
1376         fuse_dev_install(fud, fc);
1377         return fud;
1378 }
1379 EXPORT_SYMBOL_GPL(fuse_dev_alloc_install);
1380
1381 void fuse_dev_free(struct fuse_dev *fud)
1382 {
1383         struct fuse_conn *fc = fud->fc;
1384
1385         if (fc) {
1386                 spin_lock(&fc->lock);
1387                 list_del(&fud->entry);
1388                 spin_unlock(&fc->lock);
1389
1390                 fuse_conn_put(fc);
1391         }
1392         kfree(fud->pq.processing);
1393         kfree(fud);
1394 }
1395 EXPORT_SYMBOL_GPL(fuse_dev_free);
1396
1397 static void fuse_fill_attr_from_inode(struct fuse_attr *attr,
1398                                       const struct fuse_inode *fi)
1399 {
1400         *attr = (struct fuse_attr){
1401                 .ino            = fi->inode.i_ino,
1402                 .size           = fi->inode.i_size,
1403                 .blocks         = fi->inode.i_blocks,
1404                 .atime          = fi->inode.i_atime.tv_sec,
1405                 .mtime          = fi->inode.i_mtime.tv_sec,
1406                 .ctime          = fi->inode.i_ctime.tv_sec,
1407                 .atimensec      = fi->inode.i_atime.tv_nsec,
1408                 .mtimensec      = fi->inode.i_mtime.tv_nsec,
1409                 .ctimensec      = fi->inode.i_ctime.tv_nsec,
1410                 .mode           = fi->inode.i_mode,
1411                 .nlink          = fi->inode.i_nlink,
1412                 .uid            = fi->inode.i_uid.val,
1413                 .gid            = fi->inode.i_gid.val,
1414                 .rdev           = fi->inode.i_rdev,
1415                 .blksize        = 1u << fi->inode.i_blkbits,
1416         };
1417 }
1418
1419 static void fuse_sb_defaults(struct super_block *sb)
1420 {
1421         sb->s_magic = FUSE_SUPER_MAGIC;
1422         sb->s_op = &fuse_super_operations;
1423         sb->s_xattr = fuse_xattr_handlers;
1424         sb->s_maxbytes = MAX_LFS_FILESIZE;
1425         sb->s_time_gran = 1;
1426         sb->s_export_op = &fuse_export_operations;
1427         sb->s_iflags |= SB_I_IMA_UNVERIFIABLE_SIGNATURE;
1428         if (sb->s_user_ns != &init_user_ns)
1429                 sb->s_iflags |= SB_I_UNTRUSTED_MOUNTER;
1430         sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION);
1431 }
1432
1433 static int fuse_fill_super_submount(struct super_block *sb,
1434                                     struct fuse_inode *parent_fi)
1435 {
1436         struct fuse_mount *fm = get_fuse_mount_super(sb);
1437         struct super_block *parent_sb = parent_fi->inode.i_sb;
1438         struct fuse_attr root_attr;
1439         struct inode *root;
1440
1441         fuse_sb_defaults(sb);
1442         fm->sb = sb;
1443
1444         WARN_ON(sb->s_bdi != &noop_backing_dev_info);
1445         sb->s_bdi = bdi_get(parent_sb->s_bdi);
1446
1447         sb->s_xattr = parent_sb->s_xattr;
1448         sb->s_time_gran = parent_sb->s_time_gran;
1449         sb->s_blocksize = parent_sb->s_blocksize;
1450         sb->s_blocksize_bits = parent_sb->s_blocksize_bits;
1451         sb->s_subtype = kstrdup(parent_sb->s_subtype, GFP_KERNEL);
1452         if (parent_sb->s_subtype && !sb->s_subtype)
1453                 return -ENOMEM;
1454
1455         fuse_fill_attr_from_inode(&root_attr, parent_fi);
1456         root = fuse_iget(sb, parent_fi->nodeid, 0, &root_attr, 0, 0);
1457         /*
1458          * This inode is just a duplicate, so it is not looked up and
1459          * its nlookup should not be incremented.  fuse_iget() does
1460          * that, though, so undo it here.
1461          */
1462         get_fuse_inode(root)->nlookup--;
1463         sb->s_d_op = &fuse_dentry_operations;
1464         sb->s_root = d_make_root(root);
1465         if (!sb->s_root)
1466                 return -ENOMEM;
1467
1468         return 0;
1469 }
1470
1471 /* Filesystem context private data holds the FUSE inode of the mount point */
1472 static int fuse_get_tree_submount(struct fs_context *fsc)
1473 {
1474         struct fuse_mount *fm;
1475         struct fuse_inode *mp_fi = fsc->fs_private;
1476         struct fuse_conn *fc = get_fuse_conn(&mp_fi->inode);
1477         struct super_block *sb;
1478         int err;
1479
1480         fm = kzalloc(sizeof(struct fuse_mount), GFP_KERNEL);
1481         if (!fm)
1482                 return -ENOMEM;
1483
1484         fm->fc = fuse_conn_get(fc);
1485         fsc->s_fs_info = fm;
1486         sb = sget_fc(fsc, NULL, set_anon_super_fc);
1487         if (fsc->s_fs_info)
1488                 fuse_mount_destroy(fm);
1489         if (IS_ERR(sb))
1490                 return PTR_ERR(sb);
1491
1492         /* Initialize superblock, making @mp_fi its root */
1493         err = fuse_fill_super_submount(sb, mp_fi);
1494         if (err) {
1495                 deactivate_locked_super(sb);
1496                 return err;
1497         }
1498
1499         down_write(&fc->killsb);
1500         list_add_tail(&fm->fc_entry, &fc->mounts);
1501         up_write(&fc->killsb);
1502
1503         sb->s_flags |= SB_ACTIVE;
1504         fsc->root = dget(sb->s_root);
1505
1506         return 0;
1507 }
1508
1509 static const struct fs_context_operations fuse_context_submount_ops = {
1510         .get_tree       = fuse_get_tree_submount,
1511 };
1512
1513 int fuse_init_fs_context_submount(struct fs_context *fsc)
1514 {
1515         fsc->ops = &fuse_context_submount_ops;
1516         return 0;
1517 }
1518 EXPORT_SYMBOL_GPL(fuse_init_fs_context_submount);
1519
1520 int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
1521 {
1522         struct fuse_dev *fud = NULL;
1523         struct fuse_mount *fm = get_fuse_mount_super(sb);
1524         struct fuse_conn *fc = fm->fc;
1525         struct inode *root;
1526         struct dentry *root_dentry;
1527         int err;
1528
1529         err = -EINVAL;
1530         if (sb->s_flags & SB_MANDLOCK)
1531                 goto err;
1532
1533         rcu_assign_pointer(fc->curr_bucket, fuse_sync_bucket_alloc());
1534         fuse_sb_defaults(sb);
1535
1536         if (ctx->is_bdev) {
1537 #ifdef CONFIG_BLOCK
1538                 err = -EINVAL;
1539                 if (!sb_set_blocksize(sb, ctx->blksize))
1540                         goto err;
1541 #endif
1542         } else {
1543                 sb->s_blocksize = PAGE_SIZE;
1544                 sb->s_blocksize_bits = PAGE_SHIFT;
1545         }
1546
1547         sb->s_subtype = ctx->subtype;
1548         ctx->subtype = NULL;
1549         if (IS_ENABLED(CONFIG_FUSE_DAX)) {
1550                 err = fuse_dax_conn_alloc(fc, ctx->dax_mode, ctx->dax_dev);
1551                 if (err)
1552                         goto err;
1553         }
1554
1555         if (ctx->fudptr) {
1556                 err = -ENOMEM;
1557                 fud = fuse_dev_alloc_install(fc);
1558                 if (!fud)
1559                         goto err_free_dax;
1560         }
1561
1562         fc->dev = sb->s_dev;
1563         fm->sb = sb;
1564         err = fuse_bdi_init(fc, sb);
1565         if (err)
1566                 goto err_dev_free;
1567
1568         /* Handle umasking inside the fuse code */
1569         if (sb->s_flags & SB_POSIXACL)
1570                 fc->dont_mask = 1;
1571         sb->s_flags |= SB_POSIXACL;
1572
1573         fc->default_permissions = ctx->default_permissions;
1574         fc->allow_other = ctx->allow_other;
1575         fc->user_id = ctx->user_id;
1576         fc->group_id = ctx->group_id;
1577         fc->legacy_opts_show = ctx->legacy_opts_show;
1578         fc->max_read = max_t(unsigned int, 4096, ctx->max_read);
1579         fc->destroy = ctx->destroy;
1580         fc->no_control = ctx->no_control;
1581         fc->no_force_umount = ctx->no_force_umount;
1582
1583         err = -ENOMEM;
1584         root = fuse_get_root_inode(sb, ctx->rootmode);
1585         sb->s_d_op = &fuse_root_dentry_operations;
1586         root_dentry = d_make_root(root);
1587         if (!root_dentry)
1588                 goto err_dev_free;
1589         /* Root dentry doesn't have .d_revalidate */
1590         sb->s_d_op = &fuse_dentry_operations;
1591
1592         mutex_lock(&fuse_mutex);
1593         err = -EINVAL;
1594         if (ctx->fudptr && *ctx->fudptr)
1595                 goto err_unlock;
1596
1597         err = fuse_ctl_add_conn(fc);
1598         if (err)
1599                 goto err_unlock;
1600
1601         list_add_tail(&fc->entry, &fuse_conn_list);
1602         sb->s_root = root_dentry;
1603         if (ctx->fudptr)
1604                 *ctx->fudptr = fud;
1605         mutex_unlock(&fuse_mutex);
1606         return 0;
1607
1608  err_unlock:
1609         mutex_unlock(&fuse_mutex);
1610         dput(root_dentry);
1611  err_dev_free:
1612         if (fud)
1613                 fuse_dev_free(fud);
1614  err_free_dax:
1615         if (IS_ENABLED(CONFIG_FUSE_DAX))
1616                 fuse_dax_conn_free(fc);
1617  err:
1618         return err;
1619 }
1620 EXPORT_SYMBOL_GPL(fuse_fill_super_common);
1621
1622 static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
1623 {
1624         struct fuse_fs_context *ctx = fsc->fs_private;
1625         int err;
1626
1627         if (!ctx->file || !ctx->rootmode_present ||
1628             !ctx->user_id_present || !ctx->group_id_present)
1629                 return -EINVAL;
1630
1631         /*
1632          * Require mount to happen from the same user namespace which
1633          * opened /dev/fuse to prevent potential attacks.
1634          */
1635         if ((ctx->file->f_op != &fuse_dev_operations) ||
1636             (ctx->file->f_cred->user_ns != sb->s_user_ns))
1637                 return -EINVAL;
1638         ctx->fudptr = &ctx->file->private_data;
1639
1640         err = fuse_fill_super_common(sb, ctx);
1641         if (err)
1642                 return err;
1643         /* file->private_data shall be visible on all CPUs after this */
1644         smp_mb();
1645         fuse_send_init(get_fuse_mount_super(sb));
1646         return 0;
1647 }
1648
1649 /*
1650  * This is the path where user supplied an already initialized fuse dev.  In
1651  * this case never create a new super if the old one is gone.
1652  */
1653 static int fuse_set_no_super(struct super_block *sb, struct fs_context *fsc)
1654 {
1655         return -ENOTCONN;
1656 }
1657
1658 static int fuse_test_super(struct super_block *sb, struct fs_context *fsc)
1659 {
1660
1661         return fsc->sget_key == get_fuse_conn_super(sb);
1662 }
1663
1664 static int fuse_get_tree(struct fs_context *fsc)
1665 {
1666         struct fuse_fs_context *ctx = fsc->fs_private;
1667         struct fuse_dev *fud;
1668         struct fuse_conn *fc;
1669         struct fuse_mount *fm;
1670         struct super_block *sb;
1671         int err;
1672
1673         fc = kmalloc(sizeof(*fc), GFP_KERNEL);
1674         if (!fc)
1675                 return -ENOMEM;
1676
1677         fm = kzalloc(sizeof(*fm), GFP_KERNEL);
1678         if (!fm) {
1679                 kfree(fc);
1680                 return -ENOMEM;
1681         }
1682
1683         fuse_conn_init(fc, fm, fsc->user_ns, &fuse_dev_fiq_ops, NULL);
1684         fc->release = fuse_free_conn;
1685
1686         fsc->s_fs_info = fm;
1687
1688         if (ctx->fd_present)
1689                 ctx->file = fget(ctx->fd);
1690
1691         if (IS_ENABLED(CONFIG_BLOCK) && ctx->is_bdev) {
1692                 err = get_tree_bdev(fsc, fuse_fill_super);
1693                 goto out;
1694         }
1695         /*
1696          * While block dev mount can be initialized with a dummy device fd
1697          * (found by device name), normal fuse mounts can't
1698          */
1699         err = -EINVAL;
1700         if (!ctx->file)
1701                 goto out;
1702
1703         /*
1704          * Allow creating a fuse mount with an already initialized fuse
1705          * connection
1706          */
1707         fud = READ_ONCE(ctx->file->private_data);
1708         if (ctx->file->f_op == &fuse_dev_operations && fud) {
1709                 fsc->sget_key = fud->fc;
1710                 sb = sget_fc(fsc, fuse_test_super, fuse_set_no_super);
1711                 err = PTR_ERR_OR_ZERO(sb);
1712                 if (!IS_ERR(sb))
1713                         fsc->root = dget(sb->s_root);
1714         } else {
1715                 err = get_tree_nodev(fsc, fuse_fill_super);
1716         }
1717 out:
1718         if (fsc->s_fs_info)
1719                 fuse_mount_destroy(fm);
1720         if (ctx->file)
1721                 fput(ctx->file);
1722         return err;
1723 }
1724
1725 static const struct fs_context_operations fuse_context_ops = {
1726         .free           = fuse_free_fsc,
1727         .parse_param    = fuse_parse_param,
1728         .reconfigure    = fuse_reconfigure,
1729         .get_tree       = fuse_get_tree,
1730 };
1731
1732 /*
1733  * Set up the filesystem mount context.
1734  */
1735 static int fuse_init_fs_context(struct fs_context *fsc)
1736 {
1737         struct fuse_fs_context *ctx;
1738
1739         ctx = kzalloc(sizeof(struct fuse_fs_context), GFP_KERNEL);
1740         if (!ctx)
1741                 return -ENOMEM;
1742
1743         ctx->max_read = ~0;
1744         ctx->blksize = FUSE_DEFAULT_BLKSIZE;
1745         ctx->legacy_opts_show = true;
1746
1747 #ifdef CONFIG_BLOCK
1748         if (fsc->fs_type == &fuseblk_fs_type) {
1749                 ctx->is_bdev = true;
1750                 ctx->destroy = true;
1751         }
1752 #endif
1753
1754         fsc->fs_private = ctx;
1755         fsc->ops = &fuse_context_ops;
1756         return 0;
1757 }
1758
1759 bool fuse_mount_remove(struct fuse_mount *fm)
1760 {
1761         struct fuse_conn *fc = fm->fc;
1762         bool last = false;
1763
1764         down_write(&fc->killsb);
1765         list_del_init(&fm->fc_entry);
1766         if (list_empty(&fc->mounts))
1767                 last = true;
1768         up_write(&fc->killsb);
1769
1770         return last;
1771 }
1772 EXPORT_SYMBOL_GPL(fuse_mount_remove);
1773
1774 void fuse_conn_destroy(struct fuse_mount *fm)
1775 {
1776         struct fuse_conn *fc = fm->fc;
1777
1778         if (fc->destroy)
1779                 fuse_send_destroy(fm);
1780
1781         fuse_abort_conn(fc);
1782         fuse_wait_aborted(fc);
1783
1784         if (!list_empty(&fc->entry)) {
1785                 mutex_lock(&fuse_mutex);
1786                 list_del(&fc->entry);
1787                 fuse_ctl_remove_conn(fc);
1788                 mutex_unlock(&fuse_mutex);
1789         }
1790 }
1791 EXPORT_SYMBOL_GPL(fuse_conn_destroy);
1792
1793 static void fuse_sb_destroy(struct super_block *sb)
1794 {
1795         struct fuse_mount *fm = get_fuse_mount_super(sb);
1796         bool last;
1797
1798         if (sb->s_root) {
1799                 last = fuse_mount_remove(fm);
1800                 if (last)
1801                         fuse_conn_destroy(fm);
1802         }
1803 }
1804
1805 void fuse_mount_destroy(struct fuse_mount *fm)
1806 {
1807         fuse_conn_put(fm->fc);
1808         kfree(fm);
1809 }
1810 EXPORT_SYMBOL(fuse_mount_destroy);
1811
1812 static void fuse_kill_sb_anon(struct super_block *sb)
1813 {
1814         fuse_sb_destroy(sb);
1815         kill_anon_super(sb);
1816         fuse_mount_destroy(get_fuse_mount_super(sb));
1817 }
1818
1819 static struct file_system_type fuse_fs_type = {
1820         .owner          = THIS_MODULE,
1821         .name           = "fuse",
1822         .fs_flags       = FS_HAS_SUBTYPE | FS_USERNS_MOUNT,
1823         .init_fs_context = fuse_init_fs_context,
1824         .parameters     = fuse_fs_parameters,
1825         .kill_sb        = fuse_kill_sb_anon,
1826 };
1827 MODULE_ALIAS_FS("fuse");
1828
1829 #ifdef CONFIG_BLOCK
1830 static void fuse_kill_sb_blk(struct super_block *sb)
1831 {
1832         fuse_sb_destroy(sb);
1833         kill_block_super(sb);
1834         fuse_mount_destroy(get_fuse_mount_super(sb));
1835 }
1836
1837 static struct file_system_type fuseblk_fs_type = {
1838         .owner          = THIS_MODULE,
1839         .name           = "fuseblk",
1840         .init_fs_context = fuse_init_fs_context,
1841         .parameters     = fuse_fs_parameters,
1842         .kill_sb        = fuse_kill_sb_blk,
1843         .fs_flags       = FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1844 };
1845 MODULE_ALIAS_FS("fuseblk");
1846
1847 static inline int register_fuseblk(void)
1848 {
1849         return register_filesystem(&fuseblk_fs_type);
1850 }
1851
1852 static inline void unregister_fuseblk(void)
1853 {
1854         unregister_filesystem(&fuseblk_fs_type);
1855 }
1856 #else
1857 static inline int register_fuseblk(void)
1858 {
1859         return 0;
1860 }
1861
1862 static inline void unregister_fuseblk(void)
1863 {
1864 }
1865 #endif
1866
1867 static void fuse_inode_init_once(void *foo)
1868 {
1869         struct inode *inode = foo;
1870
1871         inode_init_once(inode);
1872 }
1873
1874 static int __init fuse_fs_init(void)
1875 {
1876         int err;
1877
1878         fuse_inode_cachep = kmem_cache_create("fuse_inode",
1879                         sizeof(struct fuse_inode), 0,
1880                         SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT|SLAB_RECLAIM_ACCOUNT,
1881                         fuse_inode_init_once);
1882         err = -ENOMEM;
1883         if (!fuse_inode_cachep)
1884                 goto out;
1885
1886         err = register_fuseblk();
1887         if (err)
1888                 goto out2;
1889
1890         err = register_filesystem(&fuse_fs_type);
1891         if (err)
1892                 goto out3;
1893
1894         return 0;
1895
1896  out3:
1897         unregister_fuseblk();
1898  out2:
1899         kmem_cache_destroy(fuse_inode_cachep);
1900  out:
1901         return err;
1902 }
1903
1904 static void fuse_fs_cleanup(void)
1905 {
1906         unregister_filesystem(&fuse_fs_type);
1907         unregister_fuseblk();
1908
1909         /*
1910          * Make sure all delayed rcu free inodes are flushed before we
1911          * destroy cache.
1912          */
1913         rcu_barrier();
1914         kmem_cache_destroy(fuse_inode_cachep);
1915 }
1916
1917 static struct kobject *fuse_kobj;
1918
1919 static int fuse_sysfs_init(void)
1920 {
1921         int err;
1922
1923         fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1924         if (!fuse_kobj) {
1925                 err = -ENOMEM;
1926                 goto out_err;
1927         }
1928
1929         err = sysfs_create_mount_point(fuse_kobj, "connections");
1930         if (err)
1931                 goto out_fuse_unregister;
1932
1933         return 0;
1934
1935  out_fuse_unregister:
1936         kobject_put(fuse_kobj);
1937  out_err:
1938         return err;
1939 }
1940
1941 static void fuse_sysfs_cleanup(void)
1942 {
1943         sysfs_remove_mount_point(fuse_kobj, "connections");
1944         kobject_put(fuse_kobj);
1945 }
1946
1947 static int __init fuse_init(void)
1948 {
1949         int res;
1950
1951         pr_info("init (API version %i.%i)\n",
1952                 FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
1953
1954         INIT_LIST_HEAD(&fuse_conn_list);
1955         res = fuse_fs_init();
1956         if (res)
1957                 goto err;
1958
1959         res = fuse_dev_init();
1960         if (res)
1961                 goto err_fs_cleanup;
1962
1963         res = fuse_sysfs_init();
1964         if (res)
1965                 goto err_dev_cleanup;
1966
1967         res = fuse_ctl_init();
1968         if (res)
1969                 goto err_sysfs_cleanup;
1970
1971         sanitize_global_limit(&max_user_bgreq);
1972         sanitize_global_limit(&max_user_congthresh);
1973
1974         return 0;
1975
1976  err_sysfs_cleanup:
1977         fuse_sysfs_cleanup();
1978  err_dev_cleanup:
1979         fuse_dev_cleanup();
1980  err_fs_cleanup:
1981         fuse_fs_cleanup();
1982  err:
1983         return res;
1984 }
1985
1986 static void __exit fuse_exit(void)
1987 {
1988         pr_debug("exit\n");
1989
1990         fuse_ctl_cleanup();
1991         fuse_sysfs_cleanup();
1992         fuse_fs_cleanup();
1993         fuse_dev_cleanup();
1994 }
1995
1996 module_init(fuse_init);
1997 module_exit(fuse_exit);