fs/fuse/inode.c

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