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