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 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->i_atime.tv_sec   = attr->atime;
 227         inode->i_atime.tv_nsec  = attr->atimensec;
 228         /* mtime from server may be stale due to local buffered write */
 229         if (!(cache_mask & STATX_MTIME)) {
 230                 inode->i_mtime.tv_sec   = attr->mtime;
 231                 inode->i_mtime.tv_nsec  = attr->mtimensec;
 232         }
 233         if (!(cache_mask & STATX_CTIME)) {
 234                 inode_set_ctime(inode, attr->ctime, attr->ctimensec);
 235         }
 236         if (sx) {
 237                 /* Sanitize nsecs */
 238                 sx->btime.tv_nsec =
 239                         min_t(u32, sx->btime.tv_nsec, NSEC_PER_SEC - 1);
 240
 241                 /*
 242                  * Btime has been queried, cache is valid (whether or not btime
 243                  * is available or not) so clear STATX_BTIME from inval_mask.
 244                  *
 245                  * Availability of the btime attribute is indicated in
 246                  * FUSE_I_BTIME
 247                  */
 248                 set_mask_bits(&fi->inval_mask, STATX_BTIME, 0);
 249                 if (sx->mask & STATX_BTIME) {
 250                         set_bit(FUSE_I_BTIME, &fi->state);
 251                         fi->i_btime.tv_sec = sx->btime.tv_sec;
 252                         fi->i_btime.tv_nsec = sx->btime.tv_nsec;
 253                 }
 254         }
 255
 256         if (attr->blksize != 0)
 257                 inode->i_blkbits = ilog2(attr->blksize);
 258         else
 259                 inode->i_blkbits = inode->i_sb->s_blocksize_bits;
 260
 261         /*
 262          * Don't set the sticky bit in i_mode, unless we want the VFS
 263          * to check permissions.  This prevents failures due to the
 264          * check in may_delete().
 265          */
 266         fi->orig_i_mode = inode->i_mode;
 267         if (!fc->default_permissions)
 268                 inode->i_mode &= ~S_ISVTX;
 269
 270         fi->orig_ino = attr->ino;
 271
 272         /*
 273          * We are refreshing inode data and it is possible that another
 274          * client set suid/sgid or security.capability xattr. So clear
 275          * S_NOSEC. Ideally, we could have cleared it only if suid/sgid
 276          * was set or if security.capability xattr was set. But we don't
 277          * know if security.capability has been set or not. So clear it
 278          * anyway. Its less efficient but should be safe.
 279          */
 280         inode->i_flags &= ~S_NOSEC;
 281 }
 282
 283 u32 fuse_get_cache_mask(struct inode *inode)
 284 {
 285         struct fuse_conn *fc = get_fuse_conn(inode);
 286
 287         if (!fc->writeback_cache || !S_ISREG(inode->i_mode))
 288                 return 0;
 289
 290         return STATX_MTIME | STATX_CTIME | STATX_SIZE;
 291 }
 292
 293 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
 294                             struct fuse_statx *sx,
 295                             u64 attr_valid, u64 attr_version)
 296 {
 297         struct fuse_conn *fc = get_fuse_conn(inode);
 298         struct fuse_inode *fi = get_fuse_inode(inode);
 299         u32 cache_mask;
 300         loff_t oldsize;
 301         struct timespec64 old_mtime;
 302
 303         spin_lock(&fi->lock);
 304         /*
 305          * In case of writeback_cache enabled, writes update mtime, ctime and
 306          * may update i_size.  In these cases trust the cached value in the
 307          * inode.
 308          */
 309         cache_mask = fuse_get_cache_mask(inode);
 310         if (cache_mask & STATX_SIZE)
 311                 attr->size = i_size_read(inode);
 312
 313         if (cache_mask & STATX_MTIME) {
 314                 attr->mtime = inode->i_mtime.tv_sec;
 315                 attr->mtimensec = inode->i_mtime.tv_nsec;
 316         }
 317         if (cache_mask & STATX_CTIME) {
 318                 attr->ctime = inode_get_ctime(inode).tv_sec;
 319                 attr->ctimensec = inode_get_ctime(inode).tv_nsec;
 320         }
 321
 322         if ((attr_version != 0 && fi->attr_version > attr_version) ||
 323             test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
 324                 spin_unlock(&fi->lock);
 325                 return;
 326         }
 327
 328         old_mtime = inode->i_mtime;
 329         fuse_change_attributes_common(inode, attr, sx, attr_valid, cache_mask);
 330
 331         oldsize = inode->i_size;
 332         /*
 333          * In case of writeback_cache enabled, the cached writes beyond EOF
 334          * extend local i_size without keeping userspace server in sync. So,
 335          * attr->size coming from server can be stale. We cannot trust it.
 336          */
 337         if (!(cache_mask & STATX_SIZE))
 338                 i_size_write(inode, attr->size);
 339         spin_unlock(&fi->lock);
 340
 341         if (!cache_mask && S_ISREG(inode->i_mode)) {
 342                 bool inval = false;
 343
 344                 if (oldsize != attr->size) {
 345                         truncate_pagecache(inode, attr->size);
 346                         if (!fc->explicit_inval_data)
 347                                 inval = true;
 348                 } else if (fc->auto_inval_data) {
 349                         struct timespec64 new_mtime = {
 350                                 .tv_sec = attr->mtime,
 351                                 .tv_nsec = attr->mtimensec,
 352                         };
 353
 354                         /*
 355                          * Auto inval mode also checks and invalidates if mtime
 356                          * has changed.
 357                          */
 358                         if (!timespec64_equal(&old_mtime, &new_mtime))
 359                                 inval = true;
 360                 }
 361
 362                 if (inval)
 363                         invalidate_inode_pages2(inode->i_mapping);
 364         }
 365
 366         if (IS_ENABLED(CONFIG_FUSE_DAX))
 367                 fuse_dax_dontcache(inode, attr->flags);
 368 }
 369
 370 static void fuse_init_submount_lookup(struct fuse_submount_lookup *sl,
 371                                       u64 nodeid)
 372 {
 373         sl->nodeid = nodeid;
 374         refcount_set(&sl->count, 1);
 375 }
 376
 377 static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr,
 378                             struct fuse_conn *fc)
 379 {
 380         inode->i_mode = attr->mode & S_IFMT;
 381         inode->i_size = attr->size;
 382         inode->i_mtime.tv_sec  = attr->mtime;
 383         inode->i_mtime.tv_nsec = attr->mtimensec;
 384         inode_set_ctime(inode, attr->ctime, attr->ctimensec);
 385         if (S_ISREG(inode->i_mode)) {
 386                 fuse_init_common(inode);
 387                 fuse_init_file_inode(inode, attr->flags);
 388         } else if (S_ISDIR(inode->i_mode))
 389                 fuse_init_dir(inode);
 390         else if (S_ISLNK(inode->i_mode))
 391                 fuse_init_symlink(inode);
 392         else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
 393                  S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
 394                 fuse_init_common(inode);
 395                 init_special_inode(inode, inode->i_mode,
 396                                    new_decode_dev(attr->rdev));
 397         } else
 398                 BUG();
 399         /*
 400          * Ensure that we don't cache acls for daemons without FUSE_POSIX_ACL
 401          * so they see the exact same behavior as before.
 402          */
 403         if (!fc->posix_acl)
 404                 inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE;
 405 }
 406
 407 static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
 408 {
 409         u64 nodeid = *(u64 *) _nodeidp;
 410         if (get_node_id(inode) == nodeid)
 411                 return 1;
 412         else
 413                 return 0;
 414 }
 415
 416 static int fuse_inode_set(struct inode *inode, void *_nodeidp)
 417 {
 418         u64 nodeid = *(u64 *) _nodeidp;
 419         get_fuse_inode(inode)->nodeid = nodeid;
 420         return 0;
 421 }
 422
 423 struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
 424                         int generation, struct fuse_attr *attr,
 425                         u64 attr_valid, u64 attr_version)
 426 {
 427         struct inode *inode;
 428         struct fuse_inode *fi;
 429         struct fuse_conn *fc = get_fuse_conn_super(sb);
 430
 431         /*
 432          * Auto mount points get their node id from the submount root, which is
 433          * not a unique identifier within this filesystem.
 434          *
 435          * To avoid conflicts, do not place submount points into the inode hash
 436          * table.
 437          */
 438         if (fc->auto_submounts && (attr->flags & FUSE_ATTR_SUBMOUNT) &&
 439             S_ISDIR(attr->mode)) {
 440                 struct fuse_inode *fi;
 441
 442                 inode = new_inode(sb);
 443                 if (!inode)
 444                         return NULL;
 445
 446                 fuse_init_inode(inode, attr, fc);
 447                 fi = get_fuse_inode(inode);
 448                 fi->nodeid = nodeid;
 449                 fi->submount_lookup = fuse_alloc_submount_lookup();
 450                 if (!fi->submount_lookup) {
 451                         iput(inode);
 452                         return NULL;
 453                 }
 454                 /* Sets nlookup = 1 on fi->submount_lookup->nlookup */
 455                 fuse_init_submount_lookup(fi->submount_lookup, nodeid);
 456                 inode->i_flags |= S_AUTOMOUNT;
 457                 goto done;
 458         }
 459
 460 retry:
 461         inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
 462         if (!inode)
 463                 return NULL;
 464
 465         if ((inode->i_state & I_NEW)) {
 466                 inode->i_flags |= S_NOATIME;
 467                 if (!fc->writeback_cache || !S_ISREG(attr->mode))
 468                         inode->i_flags |= S_NOCMTIME;
 469                 inode->i_generation = generation;
 470                 fuse_init_inode(inode, attr, fc);
 471                 unlock_new_inode(inode);
 472         } else if (fuse_stale_inode(inode, generation, attr)) {
 473                 /* nodeid was reused, any I/O on the old inode should fail */
 474                 fuse_make_bad(inode);
 475                 iput(inode);
 476                 goto retry;
 477         }
 478         fi = get_fuse_inode(inode);
 479         spin_lock(&fi->lock);
 480         fi->nlookup++;
 481         spin_unlock(&fi->lock);
 482 done:
 483         fuse_change_attributes(inode, attr, NULL, attr_valid, attr_version);
 484
 485         return inode;
 486 }
 487
 488 struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
 489                            struct fuse_mount **fm)
 490 {
 491         struct fuse_mount *fm_iter;
 492         struct inode *inode;
 493
 494         WARN_ON(!rwsem_is_locked(&fc->killsb));
 495         list_for_each_entry(fm_iter, &fc->mounts, fc_entry) {
 496                 if (!fm_iter->sb)
 497                         continue;
 498
 499                 inode = ilookup5(fm_iter->sb, nodeid, fuse_inode_eq, &nodeid);
 500                 if (inode) {
 501                         if (fm)
 502                                 *fm = fm_iter;
 503                         return inode;
 504                 }
 505         }
 506
 507         return NULL;
 508 }
 509
 510 int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
 511                              loff_t offset, loff_t len)
 512 {
 513         struct fuse_inode *fi;
 514         struct inode *inode;
 515         pgoff_t pg_start;
 516         pgoff_t pg_end;
 517
 518         inode = fuse_ilookup(fc, nodeid, NULL);
 519         if (!inode)
 520                 return -ENOENT;
 521
 522         fi = get_fuse_inode(inode);
 523         spin_lock(&fi->lock);
 524         fi->attr_version = atomic64_inc_return(&fc->attr_version);
 525         spin_unlock(&fi->lock);
 526
 527         fuse_invalidate_attr(inode);
 528         forget_all_cached_acls(inode);
 529         if (offset >= 0) {
 530                 pg_start = offset >> PAGE_SHIFT;
 531                 if (len <= 0)
 532                         pg_end = -1;
 533                 else
 534                         pg_end = (offset + len - 1) >> PAGE_SHIFT;
 535                 invalidate_inode_pages2_range(inode->i_mapping,
 536                                               pg_start, pg_end);
 537         }
 538         iput(inode);
 539         return 0;
 540 }
 541
 542 bool fuse_lock_inode(struct inode *inode)
 543 {
 544         bool locked = false;
 545
 546         if (!get_fuse_conn(inode)->parallel_dirops) {
 547                 mutex_lock(&get_fuse_inode(inode)->mutex);
 548                 locked = true;
 549         }
 550
 551         return locked;
 552 }
 553
 554 void fuse_unlock_inode(struct inode *inode, bool locked)
 555 {
 556         if (locked)
 557                 mutex_unlock(&get_fuse_inode(inode)->mutex);
 558 }
 559
 560 static void fuse_umount_begin(struct super_block *sb)
 561 {
 562         struct fuse_conn *fc = get_fuse_conn_super(sb);
 563
 564         if (fc->no_force_umount)
 565                 return;
 566
 567         fuse_abort_conn(fc);
 568
 569         // Only retire block-device-based superblocks.
 570         if (sb->s_bdev != NULL)
 571                 retire_super(sb);
 572 }
 573
 574 static void fuse_send_destroy(struct fuse_mount *fm)
 575 {
 576         if (fm->fc->conn_init) {
 577                 FUSE_ARGS(args);
 578
 579                 args.opcode = FUSE_DESTROY;
 580                 args.force = true;
 581                 args.nocreds = true;
 582                 fuse_simple_request(fm, &args);
 583         }
 584 }
 585
 586 static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
 587 {
 588         stbuf->f_type    = FUSE_SUPER_MAGIC;
 589         stbuf->f_bsize   = attr->bsize;
 590         stbuf->f_frsize  = attr->frsize;
 591         stbuf->f_blocks  = attr->blocks;
 592         stbuf->f_bfree   = attr->bfree;
 593         stbuf->f_bavail  = attr->bavail;
 594         stbuf->f_files   = attr->files;
 595         stbuf->f_ffree   = attr->ffree;
 596         stbuf->f_namelen = attr->namelen;
 597         /* fsid is left zero */
 598 }
 599
 600 static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
 601 {
 602         struct super_block *sb = dentry->d_sb;
 603         struct fuse_mount *fm = get_fuse_mount_super(sb);
 604         FUSE_ARGS(args);
 605         struct fuse_statfs_out outarg;
 606         int err;
 607
 608         if (!fuse_allow_current_process(fm->fc)) {
 609                 buf->f_type = FUSE_SUPER_MAGIC;
 610                 return 0;
 611         }
 612
 613         memset(&outarg, 0, sizeof(outarg));
 614         args.in_numargs = 0;
 615         args.opcode = FUSE_STATFS;
 616         args.nodeid = get_node_id(d_inode(dentry));
 617         args.out_numargs = 1;
 618         args.out_args[0].size = sizeof(outarg);
 619         args.out_args[0].value = &outarg;
 620         err = fuse_simple_request(fm, &args);
 621         if (!err)
 622                 convert_fuse_statfs(buf, &outarg.st);
 623         return err;
 624 }
 625
 626 static struct fuse_sync_bucket *fuse_sync_bucket_alloc(void)
 627 {
 628         struct fuse_sync_bucket *bucket;
 629
 630         bucket = kzalloc(sizeof(*bucket), GFP_KERNEL | __GFP_NOFAIL);
 631         if (bucket) {
 632                 init_waitqueue_head(&bucket->waitq);
 633                 /* Initial active count */
 634                 atomic_set(&bucket->count, 1);
 635         }
 636         return bucket;
 637 }
 638
 639 static void fuse_sync_fs_writes(struct fuse_conn *fc)
 640 {
 641         struct fuse_sync_bucket *bucket, *new_bucket;
 642         int count;
 643
 644         new_bucket = fuse_sync_bucket_alloc();
 645         spin_lock(&fc->lock);
 646         bucket = rcu_dereference_protected(fc->curr_bucket, 1);
 647         count = atomic_read(&bucket->count);
 648         WARN_ON(count < 1);
 649         /* No outstanding writes? */
 650         if (count == 1) {
 651                 spin_unlock(&fc->lock);
 652                 kfree(new_bucket);
 653                 return;
 654         }
 655
 656         /*
 657          * Completion of new bucket depends on completion of this bucket, so add
 658          * one more count.
 659          */
 660         atomic_inc(&new_bucket->count);
 661         rcu_assign_pointer(fc->curr_bucket, new_bucket);
 662         spin_unlock(&fc->lock);
 663         /*
 664          * Drop initial active count.  At this point if all writes in this and
 665          * ancestor buckets complete, the count will go to zero and this task
 666          * will be woken up.
 667          */
 668         atomic_dec(&bucket->count);
 669
 670         wait_event(bucket->waitq, atomic_read(&bucket->count) == 0);
 671
 672         /* Drop temp count on descendant bucket */
 673         fuse_sync_bucket_dec(new_bucket);
 674         kfree_rcu(bucket, rcu);
 675 }
 676
 677 static int fuse_sync_fs(struct super_block *sb, int wait)
 678 {
 679         struct fuse_mount *fm = get_fuse_mount_super(sb);
 680         struct fuse_conn *fc = fm->fc;
 681         struct fuse_syncfs_in inarg;
 682         FUSE_ARGS(args);
 683         int err;
 684
 685         /*
 686          * Userspace cannot handle the wait == 0 case.  Avoid a
 687          * gratuitous roundtrip.
 688          */
 689         if (!wait)
 690                 return 0;
 691
 692         /* The filesystem is being unmounted.  Nothing to do. */
 693         if (!sb->s_root)
 694                 return 0;
 695
 696         if (!fc->sync_fs)
 697                 return 0;
 698
 699         fuse_sync_fs_writes(fc);
 700
 701         memset(&inarg, 0, sizeof(inarg));
 702         args.in_numargs = 1;
 703         args.in_args[0].size = sizeof(inarg);
 704         args.in_args[0].value = &inarg;
 705         args.opcode = FUSE_SYNCFS;
 706         args.nodeid = get_node_id(sb->s_root->d_inode);
 707         args.out_numargs = 0;
 708
 709         err = fuse_simple_request(fm, &args);
 710         if (err == -ENOSYS) {
 711                 fc->sync_fs = 0;
 712                 err = 0;
 713         }
 714
 715         return err;
 716 }
 717
 718 enum {
 719         OPT_SOURCE,
 720         OPT_SUBTYPE,
 721         OPT_FD,
 722         OPT_ROOTMODE,
 723         OPT_USER_ID,
 724         OPT_GROUP_ID,
 725         OPT_DEFAULT_PERMISSIONS,
 726         OPT_ALLOW_OTHER,
 727         OPT_MAX_READ,
 728         OPT_BLKSIZE,
 729         OPT_ERR
 730 };
 731
 732 static const struct fs_parameter_spec fuse_fs_parameters[] = {
 733         fsparam_string  ("source",              OPT_SOURCE),
 734         fsparam_u32     ("fd",                  OPT_FD),
 735         fsparam_u32oct  ("rootmode",            OPT_ROOTMODE),
 736         fsparam_u32     ("user_id",             OPT_USER_ID),
 737         fsparam_u32     ("group_id",            OPT_GROUP_ID),
 738         fsparam_flag    ("default_permissions", OPT_DEFAULT_PERMISSIONS),
 739         fsparam_flag    ("allow_other",         OPT_ALLOW_OTHER),
 740         fsparam_u32     ("max_read",            OPT_MAX_READ),
 741         fsparam_u32     ("blksize",             OPT_BLKSIZE),
 742         fsparam_string  ("subtype",             OPT_SUBTYPE),
 743         {}
 744 };
 745
 746 static int fuse_parse_param(struct fs_context *fsc, struct fs_parameter *param)
 747 {
 748         struct fs_parse_result result;
 749         struct fuse_fs_context *ctx = fsc->fs_private;
 750         int opt;
 751
 752         if (fsc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
 753                 /*
 754                  * Ignore options coming from mount(MS_REMOUNT) for backward
 755                  * compatibility.
 756                  */
 757                 if (fsc->oldapi)
 758                         return 0;
 759
 760                 return invalfc(fsc, "No changes allowed in reconfigure");
 761         }
 762
 763         opt = fs_parse(fsc, fuse_fs_parameters, param, &result);
 764         if (opt < 0)
 765                 return opt;
 766
 767         switch (opt) {
 768         case OPT_SOURCE:
 769                 if (fsc->source)
 770                         return invalfc(fsc, "Multiple sources specified");
 771                 fsc->source = param->string;
 772                 param->string = NULL;
 773                 break;
 774
 775         case OPT_SUBTYPE:
 776                 if (ctx->subtype)
 777                         return invalfc(fsc, "Multiple subtypes specified");
 778                 ctx->subtype = param->string;
 779                 param->string = NULL;
 780                 return 0;
 781
 782         case OPT_FD:
 783                 ctx->fd = result.uint_32;
 784                 ctx->fd_present = true;
 785                 break;
 786
 787         case OPT_ROOTMODE:
 788                 if (!fuse_valid_type(result.uint_32))
 789                         return invalfc(fsc, "Invalid rootmode");
 790                 ctx->rootmode = result.uint_32;
 791                 ctx->rootmode_present = true;
 792                 break;
 793
 794         case OPT_USER_ID:
 795                 ctx->user_id = make_kuid(fsc->user_ns, result.uint_32);
 796                 if (!uid_valid(ctx->user_id))
 797                         return invalfc(fsc, "Invalid user_id");
 798                 ctx->user_id_present = true;
 799                 break;
 800
 801         case OPT_GROUP_ID:
 802                 ctx->group_id = make_kgid(fsc->user_ns, result.uint_32);
 803                 if (!gid_valid(ctx->group_id))
 804                         return invalfc(fsc, "Invalid group_id");
 805                 ctx->group_id_present = true;
 806                 break;
 807
 808         case OPT_DEFAULT_PERMISSIONS:
 809                 ctx->default_permissions = true;
 810                 break;
 811
 812         case OPT_ALLOW_OTHER:
 813                 ctx->allow_other = true;
 814                 break;
 815
 816         case OPT_MAX_READ:
 817                 ctx->max_read = result.uint_32;
 818                 break;
 819
 820         case OPT_BLKSIZE:
 821                 if (!ctx->is_bdev)
 822                         return invalfc(fsc, "blksize only supported for fuseblk");
 823                 ctx->blksize = result.uint_32;
 824                 break;
 825
 826         default:
 827                 return -EINVAL;
 828         }
 829
 830         return 0;
 831 }
 832
 833 static void fuse_free_fsc(struct fs_context *fsc)
 834 {
 835         struct fuse_fs_context *ctx = fsc->fs_private;
 836
 837         if (ctx) {
 838                 kfree(ctx->subtype);
 839                 kfree(ctx);
 840         }
 841 }
 842
 843 static int fuse_show_options(struct seq_file *m, struct dentry *root)
 844 {
 845         struct super_block *sb = root->d_sb;
 846         struct fuse_conn *fc = get_fuse_conn_super(sb);
 847
 848         if (fc->legacy_opts_show) {
 849                 seq_printf(m, ",user_id=%u",
 850                            from_kuid_munged(fc->user_ns, fc->user_id));
 851                 seq_printf(m, ",group_id=%u",
 852                            from_kgid_munged(fc->user_ns, fc->group_id));
 853                 if (fc->default_permissions)
 854                         seq_puts(m, ",default_permissions");
 855                 if (fc->allow_other)
 856                         seq_puts(m, ",allow_other");
 857                 if (fc->max_read != ~0)
 858                         seq_printf(m, ",max_read=%u", fc->max_read);
 859                 if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
 860                         seq_printf(m, ",blksize=%lu", sb->s_blocksize);
 861         }
 862 #ifdef CONFIG_FUSE_DAX
 863         if (fc->dax_mode == FUSE_DAX_ALWAYS)
 864                 seq_puts(m, ",dax=always");
 865         else if (fc->dax_mode == FUSE_DAX_NEVER)
 866                 seq_puts(m, ",dax=never");
 867         else if (fc->dax_mode == FUSE_DAX_INODE_USER)
 868                 seq_puts(m, ",dax=inode");
 869 #endif
 870
 871         return 0;
 872 }
 873
 874 static void fuse_iqueue_init(struct fuse_iqueue *fiq,
 875                              const struct fuse_iqueue_ops *ops,
 876                              void *priv)
 877 {
 878         memset(fiq, 0, sizeof(struct fuse_iqueue));
 879         spin_lock_init(&fiq->lock);
 880         init_waitqueue_head(&fiq->waitq);
 881         INIT_LIST_HEAD(&fiq->pending);
 882         INIT_LIST_HEAD(&fiq->interrupts);
 883         fiq->forget_list_tail = &fiq->forget_list_head;
 884         fiq->connected = 1;
 885         fiq->ops = ops;
 886         fiq->priv = priv;
 887 }
 888
 889 static void fuse_pqueue_init(struct fuse_pqueue *fpq)
 890 {
 891         unsigned int i;
 892
 893         spin_lock_init(&fpq->lock);
 894         for (i = 0; i < FUSE_PQ_HASH_SIZE; i++)
 895                 INIT_LIST_HEAD(&fpq->processing[i]);
 896         INIT_LIST_HEAD(&fpq->io);
 897         fpq->connected = 1;
 898 }
 899
 900 void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
 901                     struct user_namespace *user_ns,
 902                     const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv)
 903 {
 904         memset(fc, 0, sizeof(*fc));
 905         spin_lock_init(&fc->lock);
 906         spin_lock_init(&fc->bg_lock);
 907         init_rwsem(&fc->killsb);
 908         refcount_set(&fc->count, 1);
 909         atomic_set(&fc->dev_count, 1);
 910         init_waitqueue_head(&fc->blocked_waitq);
 911         fuse_iqueue_init(&fc->iq, fiq_ops, fiq_priv);
 912         INIT_LIST_HEAD(&fc->bg_queue);
 913         INIT_LIST_HEAD(&fc->entry);
 914         INIT_LIST_HEAD(&fc->devices);
 915         atomic_set(&fc->num_waiting, 0);
 916         fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
 917         fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
 918         atomic64_set(&fc->khctr, 0);
 919         fc->polled_files = RB_ROOT;
 920         fc->blocked = 0;
 921         fc->initialized = 0;
 922         fc->connected = 1;
 923         atomic64_set(&fc->attr_version, 1);
 924         get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
 925         fc->pid_ns = get_pid_ns(task_active_pid_ns(current));
 926         fc->user_ns = get_user_ns(user_ns);
 927         fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ;
 928         fc->max_pages_limit = FUSE_MAX_MAX_PAGES;
 929
 930         INIT_LIST_HEAD(&fc->mounts);
 931         list_add(&fm->fc_entry, &fc->mounts);
 932         fm->fc = fc;
 933 }
 934 EXPORT_SYMBOL_GPL(fuse_conn_init);
 935
 936 void fuse_conn_put(struct fuse_conn *fc)
 937 {
 938         if (refcount_dec_and_test(&fc->count)) {
 939                 struct fuse_iqueue *fiq = &fc->iq;
 940                 struct fuse_sync_bucket *bucket;
 941
 942                 if (IS_ENABLED(CONFIG_FUSE_DAX))
 943                         fuse_dax_conn_free(fc);
 944                 if (fiq->ops->release)
 945                         fiq->ops->release(fiq);
 946                 put_pid_ns(fc->pid_ns);
 947                 put_user_ns(fc->user_ns);
 948                 bucket = rcu_dereference_protected(fc->curr_bucket, 1);
 949                 if (bucket) {
 950                         WARN_ON(atomic_read(&bucket->count) != 1);
 951                         kfree(bucket);
 952                 }
 953                 fc->release(fc);
 954         }
 955 }
 956 EXPORT_SYMBOL_GPL(fuse_conn_put);
 957
 958 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
 959 {
 960         refcount_inc(&fc->count);
 961         return fc;
 962 }
 963 EXPORT_SYMBOL_GPL(fuse_conn_get);
 964
 965 static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
 966 {
 967         struct fuse_attr attr;
 968         memset(&attr, 0, sizeof(attr));
 969
 970         attr.mode = mode;
 971         attr.ino = FUSE_ROOT_ID;
 972         attr.nlink = 1;
 973         return fuse_iget(sb, 1, 0, &attr, 0, 0);
 974 }
 975
 976 struct fuse_inode_handle {
 977         u64 nodeid;
 978         u32 generation;
 979 };
 980
 981 static struct dentry *fuse_get_dentry(struct super_block *sb,
 982                                       struct fuse_inode_handle *handle)
 983 {
 984         struct fuse_conn *fc = get_fuse_conn_super(sb);
 985         struct inode *inode;
 986         struct dentry *entry;
 987         int err = -ESTALE;
 988
 989         if (handle->nodeid == 0)
 990                 goto out_err;
 991
 992         inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid);
 993         if (!inode) {
 994                 struct fuse_entry_out outarg;
 995                 const struct qstr name = QSTR_INIT(".", 1);
 996
 997                 if (!fc->export_support)
 998                         goto out_err;
 999
1000                 err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg,
1001                                        &inode);
1002                 if (err && err != -ENOENT)
1003                         goto out_err;
1004                 if (err || !inode) {
1005                         err = -ESTALE;
1006                         goto out_err;
1007                 }
1008                 err = -EIO;
1009                 if (get_node_id(inode) != handle->nodeid)
1010                         goto out_iput;
1011         }
1012         err = -ESTALE;
1013         if (inode->i_generation != handle->generation)
1014                 goto out_iput;
1015
1016         entry = d_obtain_alias(inode);
1017         if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
1018                 fuse_invalidate_entry_cache(entry);
1019
1020         return entry;
1021
1022  out_iput:
1023         iput(inode);
1024  out_err:
1025         return ERR_PTR(err);
1026 }
1027
1028 static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
1029                            struct inode *parent)
1030 {
1031         int len = parent ? 6 : 3;
1032         u64 nodeid;
1033         u32 generation;
1034
1035         if (*max_len < len) {
1036                 *max_len = len;
1037                 return  FILEID_INVALID;
1038         }
1039
1040         nodeid = get_fuse_inode(inode)->nodeid;
1041         generation = inode->i_generation;
1042
1043         fh[0] = (u32)(nodeid >> 32);
1044         fh[1] = (u32)(nodeid & 0xffffffff);
1045         fh[2] = generation;
1046
1047         if (parent) {
1048                 nodeid = get_fuse_inode(parent)->nodeid;
1049                 generation = parent->i_generation;
1050
1051                 fh[3] = (u32)(nodeid >> 32);
1052                 fh[4] = (u32)(nodeid & 0xffffffff);
1053                 fh[5] = generation;
1054         }
1055
1056         *max_len = len;
1057         return parent ? 0x82 : 0x81;
1058 }
1059
1060 static struct dentry *fuse_fh_to_dentry(struct super_block *sb,
1061                 struct fid *fid, int fh_len, int fh_type)
1062 {
1063         struct fuse_inode_handle handle;
1064
1065         if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3)
1066                 return NULL;
1067
1068         handle.nodeid = (u64) fid->raw[0] << 32;
1069         handle.nodeid |= (u64) fid->raw[1];
1070         handle.generation = fid->raw[2];
1071         return fuse_get_dentry(sb, &handle);
1072 }
1073
1074 static struct dentry *fuse_fh_to_parent(struct super_block *sb,
1075                 struct fid *fid, int fh_len, int fh_type)
1076 {
1077         struct fuse_inode_handle parent;
1078
1079         if (fh_type != 0x82 || fh_len < 6)
1080                 return NULL;
1081
1082         parent.nodeid = (u64) fid->raw[3] << 32;
1083         parent.nodeid |= (u64) fid->raw[4];
1084         parent.generation = fid->raw[5];
1085         return fuse_get_dentry(sb, &parent);
1086 }
1087
1088 static struct dentry *fuse_get_parent(struct dentry *child)
1089 {
1090         struct inode *child_inode = d_inode(child);
1091         struct fuse_conn *fc = get_fuse_conn(child_inode);
1092         struct inode *inode;
1093         struct dentry *parent;
1094         struct fuse_entry_out outarg;
1095         int err;
1096
1097         if (!fc->export_support)
1098                 return ERR_PTR(-ESTALE);
1099
1100         err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
1101                                &dotdot_name, &outarg, &inode);
1102         if (err) {
1103                 if (err == -ENOENT)
1104                         return ERR_PTR(-ESTALE);
1105                 return ERR_PTR(err);
1106         }
1107
1108         parent = d_obtain_alias(inode);
1109         if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
1110                 fuse_invalidate_entry_cache(parent);
1111
1112         return parent;
1113 }
1114
1115 static const struct export_operations fuse_export_operations = {
1116         .fh_to_dentry   = fuse_fh_to_dentry,
1117         .fh_to_parent   = fuse_fh_to_parent,
1118         .encode_fh      = fuse_encode_fh,
1119         .get_parent     = fuse_get_parent,
1120 };
1121
1122 static const struct super_operations fuse_super_operations = {
1123         .alloc_inode    = fuse_alloc_inode,
1124         .free_inode     = fuse_free_inode,
1125         .evict_inode    = fuse_evict_inode,
1126         .write_inode    = fuse_write_inode,
1127         .drop_inode     = generic_delete_inode,
1128         .umount_begin   = fuse_umount_begin,
1129         .statfs         = fuse_statfs,
1130         .sync_fs        = fuse_sync_fs,
1131         .show_options   = fuse_show_options,
1132 };
1133
1134 static void sanitize_global_limit(unsigned *limit)
1135 {
1136         /*
1137          * The default maximum number of async requests is calculated to consume
1138          * 1/2^13 of the total memory, assuming 392 bytes per request.
1139          */
1140         if (*limit == 0)
1141                 *limit = ((totalram_pages() << PAGE_SHIFT) >> 13) / 392;
1142
1143         if (*limit >= 1 << 16)
1144                 *limit = (1 << 16) - 1;
1145 }
1146
1147 static int set_global_limit(const char *val, const struct kernel_param *kp)
1148 {
1149         int rv;
1150
1151         rv = param_set_uint(val, kp);
1152         if (rv)
1153                 return rv;
1154
1155         sanitize_global_limit((unsigned *)kp->arg);
1156
1157         return 0;
1158 }
1159
1160 static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg)
1161 {
1162         int cap_sys_admin = capable(CAP_SYS_ADMIN);
1163
1164         if (arg->minor < 13)
1165                 return;
1166
1167         sanitize_global_limit(&max_user_bgreq);
1168         sanitize_global_limit(&max_user_congthresh);
1169
1170         spin_lock(&fc->bg_lock);
1171         if (arg->max_background) {
1172                 fc->max_background = arg->max_background;
1173
1174                 if (!cap_sys_admin && fc->max_background > max_user_bgreq)
1175                         fc->max_background = max_user_bgreq;
1176         }
1177         if (arg->congestion_threshold) {
1178                 fc->congestion_threshold = arg->congestion_threshold;
1179
1180                 if (!cap_sys_admin &&
1181                     fc->congestion_threshold > max_user_congthresh)
1182                         fc->congestion_threshold = max_user_congthresh;
1183         }
1184         spin_unlock(&fc->bg_lock);
1185 }
1186
1187 struct fuse_init_args {
1188         struct fuse_args args;
1189         struct fuse_init_in in;
1190         struct fuse_init_out out;
1191 };
1192
1193 static void process_init_reply(struct fuse_mount *fm, struct fuse_args *args,
1194                                int error)
1195 {
1196         struct fuse_conn *fc = fm->fc;
1197         struct fuse_init_args *ia = container_of(args, typeof(*ia), args);
1198         struct fuse_init_out *arg = &ia->out;
1199         bool ok = true;
1200
1201         if (error || arg->major != FUSE_KERNEL_VERSION)
1202                 ok = false;
1203         else {
1204                 unsigned long ra_pages;
1205
1206                 process_init_limits(fc, arg);
1207
1208                 if (arg->minor >= 6) {
1209                         u64 flags = arg->flags;
1210
1211                         if (flags & FUSE_INIT_EXT)
1212                                 flags |= (u64) arg->flags2 << 32;
1213
1214                         ra_pages = arg->max_readahead / PAGE_SIZE;
1215                         if (flags & FUSE_ASYNC_READ)
1216                                 fc->async_read = 1;
1217                         if (!(flags & FUSE_POSIX_LOCKS))
1218                                 fc->no_lock = 1;
1219                         if (arg->minor >= 17) {
1220                                 if (!(flags & FUSE_FLOCK_LOCKS))
1221                                         fc->no_flock = 1;
1222                         } else {
1223                                 if (!(flags & FUSE_POSIX_LOCKS))
1224                                         fc->no_flock = 1;
1225                         }
1226                         if (flags & FUSE_ATOMIC_O_TRUNC)
1227                                 fc->atomic_o_trunc = 1;
1228                         if (arg->minor >= 9) {
1229                                 /* LOOKUP has dependency on proto version */
1230                                 if (flags & FUSE_EXPORT_SUPPORT)
1231                                         fc->export_support = 1;
1232                         }
1233                         if (flags & FUSE_BIG_WRITES)
1234                                 fc->big_writes = 1;
1235                         if (flags & FUSE_DONT_MASK)
1236                                 fc->dont_mask = 1;
1237                         if (flags & FUSE_AUTO_INVAL_DATA)
1238                                 fc->auto_inval_data = 1;
1239                         else if (flags & FUSE_EXPLICIT_INVAL_DATA)
1240                                 fc->explicit_inval_data = 1;
1241                         if (flags & FUSE_DO_READDIRPLUS) {
1242                                 fc->do_readdirplus = 1;
1243                                 if (flags & FUSE_READDIRPLUS_AUTO)
1244                                         fc->readdirplus_auto = 1;
1245                         }
1246                         if (flags & FUSE_ASYNC_DIO)
1247                                 fc->async_dio = 1;
1248                         if (flags & FUSE_WRITEBACK_CACHE)
1249                                 fc->writeback_cache = 1;
1250                         if (flags & FUSE_PARALLEL_DIROPS)
1251                                 fc->parallel_dirops = 1;
1252                         if (flags & FUSE_HANDLE_KILLPRIV)
1253                                 fc->handle_killpriv = 1;
1254                         if (arg->time_gran && arg->time_gran <= 1000000000)
1255                                 fm->sb->s_time_gran = arg->time_gran;
1256                         if ((flags & FUSE_POSIX_ACL)) {
1257                                 fc->default_permissions = 1;
1258                                 fc->posix_acl = 1;
1259                         }
1260                         if (flags & FUSE_CACHE_SYMLINKS)
1261                                 fc->cache_symlinks = 1;
1262                         if (flags & FUSE_ABORT_ERROR)
1263                                 fc->abort_err = 1;
1264                         if (flags & FUSE_MAX_PAGES) {
1265                                 fc->max_pages =
1266                                         min_t(unsigned int, fc->max_pages_limit,
1267                                         max_t(unsigned int, arg->max_pages, 1));
1268                         }
1269                         if (IS_ENABLED(CONFIG_FUSE_DAX)) {
1270                                 if (flags & FUSE_MAP_ALIGNMENT &&
1271                                     !fuse_dax_check_alignment(fc, arg->map_alignment)) {
1272                                         ok = false;
1273                                 }
1274                                 if (flags & FUSE_HAS_INODE_DAX)
1275                                         fc->inode_dax = 1;
1276                         }
1277                         if (flags & FUSE_HANDLE_KILLPRIV_V2) {
1278                                 fc->handle_killpriv_v2 = 1;
1279                                 fm->sb->s_flags |= SB_NOSEC;
1280                         }
1281                         if (flags & FUSE_SETXATTR_EXT)
1282                                 fc->setxattr_ext = 1;
1283                         if (flags & FUSE_SECURITY_CTX)
1284                                 fc->init_security = 1;
1285                         if (flags & FUSE_CREATE_SUPP_GROUP)
1286                                 fc->create_supp_group = 1;
1287                         if (flags & FUSE_DIRECT_IO_ALLOW_MMAP)
1288                                 fc->direct_io_allow_mmap = 1;
1289                 } else {
1290                         ra_pages = fc->max_read / PAGE_SIZE;
1291                         fc->no_lock = 1;
1292                         fc->no_flock = 1;
1293                 }
1294
1295                 fm->sb->s_bdi->ra_pages =
1296                                 min(fm->sb->s_bdi->ra_pages, ra_pages);
1297                 fc->minor = arg->minor;
1298                 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
1299                 fc->max_write = max_t(unsigned, 4096, fc->max_write);
1300                 fc->conn_init = 1;
1301         }
1302         kfree(ia);
1303
1304         if (!ok) {
1305                 fc->conn_init = 0;
1306                 fc->conn_error = 1;
1307         }
1308
1309         fuse_set_initialized(fc);
1310         wake_up_all(&fc->blocked_waitq);
1311 }
1312
1313 void fuse_send_init(struct fuse_mount *fm)
1314 {
1315         struct fuse_init_args *ia;
1316         u64 flags;
1317
1318         ia = kzalloc(sizeof(*ia), GFP_KERNEL | __GFP_NOFAIL);
1319
1320         ia->in.major = FUSE_KERNEL_VERSION;
1321         ia->in.minor = FUSE_KERNEL_MINOR_VERSION;
1322         ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE;
1323         flags =
1324                 FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
1325                 FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
1326                 FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
1327                 FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
1328                 FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
1329                 FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
1330                 FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL |
1331                 FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS |
1332                 FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA |
1333                 FUSE_HANDLE_KILLPRIV_V2 | FUSE_SETXATTR_EXT | FUSE_INIT_EXT |
1334                 FUSE_SECURITY_CTX | FUSE_CREATE_SUPP_GROUP |
1335                 FUSE_HAS_EXPIRE_ONLY | FUSE_DIRECT_IO_ALLOW_MMAP;
1336 #ifdef CONFIG_FUSE_DAX
1337         if (fm->fc->dax)
1338                 flags |= FUSE_MAP_ALIGNMENT;
1339         if (fuse_is_inode_dax_mode(fm->fc->dax_mode))
1340                 flags |= FUSE_HAS_INODE_DAX;
1341 #endif
1342         if (fm->fc->auto_submounts)
1343                 flags |= FUSE_SUBMOUNTS;
1344
1345         ia->in.flags = flags;
1346         ia->in.flags2 = flags >> 32;
1347
1348         ia->args.opcode = FUSE_INIT;
1349         ia->args.in_numargs = 1;
1350         ia->args.in_args[0].size = sizeof(ia->in);
1351         ia->args.in_args[0].value = &ia->in;
1352         ia->args.out_numargs = 1;
1353         /* Variable length argument used for backward compatibility
1354            with interface version < 7.5.  Rest of init_out is zeroed
1355            by do_get_request(), so a short reply is not a problem */
1356         ia->args.out_argvar = true;
1357         ia->args.out_args[0].size = sizeof(ia->out);
1358         ia->args.out_args[0].value = &ia->out;
1359         ia->args.force = true;
1360         ia->args.nocreds = true;
1361         ia->args.end = process_init_reply;
1362
1363         if (fuse_simple_background(fm, &ia->args, GFP_KERNEL) != 0)
1364                 process_init_reply(fm, &ia->args, -ENOTCONN);
1365 }
1366 EXPORT_SYMBOL_GPL(fuse_send_init);
1367
1368 void fuse_free_conn(struct fuse_conn *fc)
1369 {
1370         WARN_ON(!list_empty(&fc->devices));
1371         kfree_rcu(fc, rcu);
1372 }
1373 EXPORT_SYMBOL_GPL(fuse_free_conn);
1374
1375 static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
1376 {
1377         int err;
1378         char *suffix = "";
1379
1380         if (sb->s_bdev) {
1381                 suffix = "-fuseblk";
1382                 /*
1383                  * sb->s_bdi points to blkdev's bdi however we want to redirect
1384                  * it to our private bdi...
1385                  */
1386                 bdi_put(sb->s_bdi);
1387                 sb->s_bdi = &noop_backing_dev_info;
1388         }
1389         err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev),
1390                                    MINOR(fc->dev), suffix);
1391         if (err)
1392                 return err;
1393
1394         /* fuse does it's own writeback accounting */
1395         sb->s_bdi->capabilities &= ~BDI_CAP_WRITEBACK_ACCT;
1396         sb->s_bdi->capabilities |= BDI_CAP_STRICTLIMIT;
1397
1398         /*
1399          * For a single fuse filesystem use max 1% of dirty +
1400          * writeback threshold.
1401          *
1402          * This gives about 1M of write buffer for memory maps on a
1403          * machine with 1G and 10% dirty_ratio, which should be more
1404          * than enough.
1405          *
1406          * Privileged users can raise it by writing to
1407          *
1408          *    /sys/class/bdi/<bdi>/max_ratio
1409          */
1410         bdi_set_max_ratio(sb->s_bdi, 1);
1411
1412         return 0;
1413 }
1414
1415 struct fuse_dev *fuse_dev_alloc(void)
1416 {
1417         struct fuse_dev *fud;
1418         struct list_head *pq;
1419
1420         fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL);
1421         if (!fud)
1422                 return NULL;
1423
1424         pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL);
1425         if (!pq) {
1426                 kfree(fud);
1427                 return NULL;
1428         }
1429
1430         fud->pq.processing = pq;
1431         fuse_pqueue_init(&fud->pq);
1432
1433         return fud;
1434 }
1435 EXPORT_SYMBOL_GPL(fuse_dev_alloc);
1436
1437 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc)
1438 {
1439         fud->fc = fuse_conn_get(fc);
1440         spin_lock(&fc->lock);
1441         list_add_tail(&fud->entry, &fc->devices);
1442         spin_unlock(&fc->lock);
1443 }
1444 EXPORT_SYMBOL_GPL(fuse_dev_install);
1445
1446 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc)
1447 {
1448         struct fuse_dev *fud;
1449
1450         fud = fuse_dev_alloc();
1451         if (!fud)
1452                 return NULL;
1453
1454         fuse_dev_install(fud, fc);
1455         return fud;
1456 }
1457 EXPORT_SYMBOL_GPL(fuse_dev_alloc_install);
1458
1459 void fuse_dev_free(struct fuse_dev *fud)
1460 {
1461         struct fuse_conn *fc = fud->fc;
1462
1463         if (fc) {
1464                 spin_lock(&fc->lock);
1465                 list_del(&fud->entry);
1466                 spin_unlock(&fc->lock);
1467
1468                 fuse_conn_put(fc);
1469         }
1470         kfree(fud->pq.processing);
1471         kfree(fud);
1472 }
1473 EXPORT_SYMBOL_GPL(fuse_dev_free);
1474
1475 static void fuse_fill_attr_from_inode(struct fuse_attr *attr,
1476                                       const struct fuse_inode *fi)
1477 {
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          = fi->inode.i_atime.tv_sec,
1485                 .mtime          = fi->inode.i_mtime.tv_sec,
1486                 .ctime          = ctime.tv_sec,
1487                 .atimensec      = fi->inode.i_atime.tv_nsec,
1488                 .mtimensec      = fi->inode.i_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);