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