fs/fuse/inode.c

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