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 kmem_cache_free(fuse_inode_cachep, fi); 92 return NULL; 93 } 94 95 return &fi->inode; 96 } 97 98 static void fuse_free_inode(struct inode *inode) 99 { 100 struct fuse_inode *fi = get_fuse_inode(inode); 101 102 mutex_destroy(&fi->mutex); 103 kfree(fi->forget); 104 kmem_cache_free(fuse_inode_cachep, fi); 105 } 106 107 static void fuse_evict_inode(struct inode *inode) 108 { 109 struct fuse_inode *fi = get_fuse_inode(inode); 110 111 truncate_inode_pages_final(&inode->i_data); 112 clear_inode(inode); 113 if (inode->i_sb->s_flags & SB_ACTIVE) { 114 struct fuse_conn *fc = get_fuse_conn(inode); 115 fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup); 116 fi->forget = NULL; 117 } 118 if (S_ISREG(inode->i_mode) && !is_bad_inode(inode)) { 119 WARN_ON(!list_empty(&fi->write_files)); 120 WARN_ON(!list_empty(&fi->queued_writes)); 121 } 122 } 123 124 static int fuse_remount_fs(struct super_block *sb, int *flags, char *data) 125 { 126 sync_filesystem(sb); 127 if (*flags & SB_MANDLOCK) 128 return -EINVAL; 129 130 return 0; 131 } 132 133 /* 134 * ino_t is 32-bits on 32-bit arch. We have to squash the 64-bit value down 135 * so that it will fit. 136 */ 137 static ino_t fuse_squash_ino(u64 ino64) 138 { 139 ino_t ino = (ino_t) ino64; 140 if (sizeof(ino_t) < sizeof(u64)) 141 ino ^= ino64 >> (sizeof(u64) - sizeof(ino_t)) * 8; 142 return ino; 143 } 144 145 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr, 146 u64 attr_valid) 147 { 148 struct fuse_conn *fc = get_fuse_conn(inode); 149 struct fuse_inode *fi = get_fuse_inode(inode); 150 151 lockdep_assert_held(&fi->lock); 152 153 fi->attr_version = atomic64_inc_return(&fc->attr_version); 154 fi->i_time = attr_valid; 155 WRITE_ONCE(fi->inval_mask, 0); 156 157 inode->i_ino = fuse_squash_ino(attr->ino); 158 inode->i_mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777); 159 set_nlink(inode, attr->nlink); 160 inode->i_uid = make_kuid(fc->user_ns, attr->uid); 161 inode->i_gid = make_kgid(fc->user_ns, attr->gid); 162 inode->i_blocks = attr->blocks; 163 inode->i_atime.tv_sec = attr->atime; 164 inode->i_atime.tv_nsec = attr->atimensec; 165 /* mtime from server may be stale due to local buffered write */ 166 if (!fc->writeback_cache || !S_ISREG(inode->i_mode)) { 167 inode->i_mtime.tv_sec = attr->mtime; 168 inode->i_mtime.tv_nsec = attr->mtimensec; 169 inode->i_ctime.tv_sec = attr->ctime; 170 inode->i_ctime.tv_nsec = attr->ctimensec; 171 } 172 173 if (attr->blksize != 0) 174 inode->i_blkbits = ilog2(attr->blksize); 175 else 176 inode->i_blkbits = inode->i_sb->s_blocksize_bits; 177 178 /* 179 * Don't set the sticky bit in i_mode, unless we want the VFS 180 * to check permissions. This prevents failures due to the 181 * check in may_delete(). 182 */ 183 fi->orig_i_mode = inode->i_mode; 184 if (!fc->default_permissions) 185 inode->i_mode &= ~S_ISVTX; 186 187 fi->orig_ino = attr->ino; 188 } 189 190 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr, 191 u64 attr_valid, u64 attr_version) 192 { 193 struct fuse_conn *fc = get_fuse_conn(inode); 194 struct fuse_inode *fi = get_fuse_inode(inode); 195 bool is_wb = fc->writeback_cache; 196 loff_t oldsize; 197 struct timespec64 old_mtime; 198 199 spin_lock(&fi->lock); 200 if ((attr_version != 0 && fi->attr_version > attr_version) || 201 test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) { 202 spin_unlock(&fi->lock); 203 return; 204 } 205 206 old_mtime = inode->i_mtime; 207 fuse_change_attributes_common(inode, attr, attr_valid); 208 209 oldsize = inode->i_size; 210 /* 211 * In case of writeback_cache enabled, the cached writes beyond EOF 212 * extend local i_size without keeping userspace server in sync. So, 213 * attr->size coming from server can be stale. We cannot trust it. 214 */ 215 if (!is_wb || !S_ISREG(inode->i_mode)) 216 i_size_write(inode, attr->size); 217 spin_unlock(&fi->lock); 218 219 if (!is_wb && S_ISREG(inode->i_mode)) { 220 bool inval = false; 221 222 if (oldsize != attr->size) { 223 truncate_pagecache(inode, attr->size); 224 if (!fc->explicit_inval_data) 225 inval = true; 226 } else if (fc->auto_inval_data) { 227 struct timespec64 new_mtime = { 228 .tv_sec = attr->mtime, 229 .tv_nsec = attr->mtimensec, 230 }; 231 232 /* 233 * Auto inval mode also checks and invalidates if mtime 234 * has changed. 235 */ 236 if (!timespec64_equal(&old_mtime, &new_mtime)) 237 inval = true; 238 } 239 240 if (inval) 241 invalidate_inode_pages2(inode->i_mapping); 242 } 243 } 244 245 static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr) 246 { 247 inode->i_mode = attr->mode & S_IFMT; 248 inode->i_size = attr->size; 249 inode->i_mtime.tv_sec = attr->mtime; 250 inode->i_mtime.tv_nsec = attr->mtimensec; 251 inode->i_ctime.tv_sec = attr->ctime; 252 inode->i_ctime.tv_nsec = attr->ctimensec; 253 if (S_ISREG(inode->i_mode)) { 254 fuse_init_common(inode); 255 fuse_init_file_inode(inode); 256 } else if (S_ISDIR(inode->i_mode)) 257 fuse_init_dir(inode); 258 else if (S_ISLNK(inode->i_mode)) 259 fuse_init_symlink(inode); 260 else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 261 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 262 fuse_init_common(inode); 263 init_special_inode(inode, inode->i_mode, 264 new_decode_dev(attr->rdev)); 265 } else 266 BUG(); 267 } 268 269 int fuse_inode_eq(struct inode *inode, void *_nodeidp) 270 { 271 u64 nodeid = *(u64 *) _nodeidp; 272 if (get_node_id(inode) == nodeid) 273 return 1; 274 else 275 return 0; 276 } 277 278 static int fuse_inode_set(struct inode *inode, void *_nodeidp) 279 { 280 u64 nodeid = *(u64 *) _nodeidp; 281 get_fuse_inode(inode)->nodeid = nodeid; 282 return 0; 283 } 284 285 struct inode *fuse_iget(struct super_block *sb, u64 nodeid, 286 int generation, struct fuse_attr *attr, 287 u64 attr_valid, u64 attr_version) 288 { 289 struct inode *inode; 290 struct fuse_inode *fi; 291 struct fuse_conn *fc = get_fuse_conn_super(sb); 292 293 retry: 294 inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid); 295 if (!inode) 296 return NULL; 297 298 if ((inode->i_state & I_NEW)) { 299 inode->i_flags |= S_NOATIME; 300 if (!fc->writeback_cache || !S_ISREG(attr->mode)) 301 inode->i_flags |= S_NOCMTIME; 302 inode->i_generation = generation; 303 fuse_init_inode(inode, attr); 304 unlock_new_inode(inode); 305 } else if ((inode->i_mode ^ attr->mode) & S_IFMT) { 306 /* Inode has changed type, any I/O on the old should fail */ 307 make_bad_inode(inode); 308 iput(inode); 309 goto retry; 310 } 311 312 fi = get_fuse_inode(inode); 313 spin_lock(&fi->lock); 314 fi->nlookup++; 315 spin_unlock(&fi->lock); 316 fuse_change_attributes(inode, attr, attr_valid, attr_version); 317 318 return inode; 319 } 320 321 int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid, 322 loff_t offset, loff_t len) 323 { 324 struct fuse_conn *fc = get_fuse_conn_super(sb); 325 struct fuse_inode *fi; 326 struct inode *inode; 327 pgoff_t pg_start; 328 pgoff_t pg_end; 329 330 inode = ilookup5(sb, nodeid, fuse_inode_eq, &nodeid); 331 if (!inode) 332 return -ENOENT; 333 334 fi = get_fuse_inode(inode); 335 spin_lock(&fi->lock); 336 fi->attr_version = atomic64_inc_return(&fc->attr_version); 337 spin_unlock(&fi->lock); 338 339 fuse_invalidate_attr(inode); 340 forget_all_cached_acls(inode); 341 if (offset >= 0) { 342 pg_start = offset >> PAGE_SHIFT; 343 if (len <= 0) 344 pg_end = -1; 345 else 346 pg_end = (offset + len - 1) >> PAGE_SHIFT; 347 invalidate_inode_pages2_range(inode->i_mapping, 348 pg_start, pg_end); 349 } 350 iput(inode); 351 return 0; 352 } 353 354 bool fuse_lock_inode(struct inode *inode) 355 { 356 bool locked = false; 357 358 if (!get_fuse_conn(inode)->parallel_dirops) { 359 mutex_lock(&get_fuse_inode(inode)->mutex); 360 locked = true; 361 } 362 363 return locked; 364 } 365 366 void fuse_unlock_inode(struct inode *inode, bool locked) 367 { 368 if (locked) 369 mutex_unlock(&get_fuse_inode(inode)->mutex); 370 } 371 372 static void fuse_umount_begin(struct super_block *sb) 373 { 374 struct fuse_conn *fc = get_fuse_conn_super(sb); 375 376 if (!fc->no_force_umount) 377 fuse_abort_conn(fc); 378 } 379 380 static void fuse_send_destroy(struct fuse_conn *fc) 381 { 382 if (fc->conn_init) { 383 FUSE_ARGS(args); 384 385 args.opcode = FUSE_DESTROY; 386 args.force = true; 387 args.nocreds = true; 388 fuse_simple_request(fc, &args); 389 } 390 } 391 392 static void fuse_put_super(struct super_block *sb) 393 { 394 struct fuse_conn *fc = get_fuse_conn_super(sb); 395 396 mutex_lock(&fuse_mutex); 397 list_del(&fc->entry); 398 fuse_ctl_remove_conn(fc); 399 mutex_unlock(&fuse_mutex); 400 401 fuse_conn_put(fc); 402 } 403 404 static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr) 405 { 406 stbuf->f_type = FUSE_SUPER_MAGIC; 407 stbuf->f_bsize = attr->bsize; 408 stbuf->f_frsize = attr->frsize; 409 stbuf->f_blocks = attr->blocks; 410 stbuf->f_bfree = attr->bfree; 411 stbuf->f_bavail = attr->bavail; 412 stbuf->f_files = attr->files; 413 stbuf->f_ffree = attr->ffree; 414 stbuf->f_namelen = attr->namelen; 415 /* fsid is left zero */ 416 } 417 418 static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf) 419 { 420 struct super_block *sb = dentry->d_sb; 421 struct fuse_conn *fc = get_fuse_conn_super(sb); 422 FUSE_ARGS(args); 423 struct fuse_statfs_out outarg; 424 int err; 425 426 if (!fuse_allow_current_process(fc)) { 427 buf->f_type = FUSE_SUPER_MAGIC; 428 return 0; 429 } 430 431 memset(&outarg, 0, sizeof(outarg)); 432 args.in_numargs = 0; 433 args.opcode = FUSE_STATFS; 434 args.nodeid = get_node_id(d_inode(dentry)); 435 args.out_numargs = 1; 436 args.out_args[0].size = sizeof(outarg); 437 args.out_args[0].value = &outarg; 438 err = fuse_simple_request(fc, &args); 439 if (!err) 440 convert_fuse_statfs(buf, &outarg.st); 441 return err; 442 } 443 444 enum { 445 OPT_SOURCE, 446 OPT_SUBTYPE, 447 OPT_FD, 448 OPT_ROOTMODE, 449 OPT_USER_ID, 450 OPT_GROUP_ID, 451 OPT_DEFAULT_PERMISSIONS, 452 OPT_ALLOW_OTHER, 453 OPT_MAX_READ, 454 OPT_BLKSIZE, 455 OPT_ERR 456 }; 457 458 static const struct fs_parameter_spec fuse_fs_parameters[] = { 459 fsparam_string ("source", OPT_SOURCE), 460 fsparam_u32 ("fd", OPT_FD), 461 fsparam_u32oct ("rootmode", OPT_ROOTMODE), 462 fsparam_u32 ("user_id", OPT_USER_ID), 463 fsparam_u32 ("group_id", OPT_GROUP_ID), 464 fsparam_flag ("default_permissions", OPT_DEFAULT_PERMISSIONS), 465 fsparam_flag ("allow_other", OPT_ALLOW_OTHER), 466 fsparam_u32 ("max_read", OPT_MAX_READ), 467 fsparam_u32 ("blksize", OPT_BLKSIZE), 468 fsparam_string ("subtype", OPT_SUBTYPE), 469 {} 470 }; 471 472 static int fuse_parse_param(struct fs_context *fc, struct fs_parameter *param) 473 { 474 struct fs_parse_result result; 475 struct fuse_fs_context *ctx = fc->fs_private; 476 int opt; 477 478 opt = fs_parse(fc, fuse_fs_parameters, param, &result); 479 if (opt < 0) 480 return opt; 481 482 switch (opt) { 483 case OPT_SOURCE: 484 if (fc->source) 485 return invalfc(fc, "Multiple sources specified"); 486 fc->source = param->string; 487 param->string = NULL; 488 break; 489 490 case OPT_SUBTYPE: 491 if (ctx->subtype) 492 return invalfc(fc, "Multiple subtypes specified"); 493 ctx->subtype = param->string; 494 param->string = NULL; 495 return 0; 496 497 case OPT_FD: 498 ctx->fd = result.uint_32; 499 ctx->fd_present = true; 500 break; 501 502 case OPT_ROOTMODE: 503 if (!fuse_valid_type(result.uint_32)) 504 return invalfc(fc, "Invalid rootmode"); 505 ctx->rootmode = result.uint_32; 506 ctx->rootmode_present = true; 507 break; 508 509 case OPT_USER_ID: 510 ctx->user_id = make_kuid(fc->user_ns, result.uint_32); 511 if (!uid_valid(ctx->user_id)) 512 return invalfc(fc, "Invalid user_id"); 513 ctx->user_id_present = true; 514 break; 515 516 case OPT_GROUP_ID: 517 ctx->group_id = make_kgid(fc->user_ns, result.uint_32); 518 if (!gid_valid(ctx->group_id)) 519 return invalfc(fc, "Invalid group_id"); 520 ctx->group_id_present = true; 521 break; 522 523 case OPT_DEFAULT_PERMISSIONS: 524 ctx->default_permissions = true; 525 break; 526 527 case OPT_ALLOW_OTHER: 528 ctx->allow_other = true; 529 break; 530 531 case OPT_MAX_READ: 532 ctx->max_read = result.uint_32; 533 break; 534 535 case OPT_BLKSIZE: 536 if (!ctx->is_bdev) 537 return invalfc(fc, "blksize only supported for fuseblk"); 538 ctx->blksize = result.uint_32; 539 break; 540 541 default: 542 return -EINVAL; 543 } 544 545 return 0; 546 } 547 548 static void fuse_free_fc(struct fs_context *fc) 549 { 550 struct fuse_fs_context *ctx = fc->fs_private; 551 552 if (ctx) { 553 kfree(ctx->subtype); 554 kfree(ctx); 555 } 556 } 557 558 static int fuse_show_options(struct seq_file *m, struct dentry *root) 559 { 560 struct super_block *sb = root->d_sb; 561 struct fuse_conn *fc = get_fuse_conn_super(sb); 562 563 if (fc->no_mount_options) 564 return 0; 565 566 seq_printf(m, ",user_id=%u", from_kuid_munged(fc->user_ns, fc->user_id)); 567 seq_printf(m, ",group_id=%u", from_kgid_munged(fc->user_ns, fc->group_id)); 568 if (fc->default_permissions) 569 seq_puts(m, ",default_permissions"); 570 if (fc->allow_other) 571 seq_puts(m, ",allow_other"); 572 if (fc->max_read != ~0) 573 seq_printf(m, ",max_read=%u", fc->max_read); 574 if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE) 575 seq_printf(m, ",blksize=%lu", sb->s_blocksize); 576 return 0; 577 } 578 579 static void fuse_iqueue_init(struct fuse_iqueue *fiq, 580 const struct fuse_iqueue_ops *ops, 581 void *priv) 582 { 583 memset(fiq, 0, sizeof(struct fuse_iqueue)); 584 spin_lock_init(&fiq->lock); 585 init_waitqueue_head(&fiq->waitq); 586 INIT_LIST_HEAD(&fiq->pending); 587 INIT_LIST_HEAD(&fiq->interrupts); 588 fiq->forget_list_tail = &fiq->forget_list_head; 589 fiq->connected = 1; 590 fiq->ops = ops; 591 fiq->priv = priv; 592 } 593 594 static void fuse_pqueue_init(struct fuse_pqueue *fpq) 595 { 596 unsigned int i; 597 598 spin_lock_init(&fpq->lock); 599 for (i = 0; i < FUSE_PQ_HASH_SIZE; i++) 600 INIT_LIST_HEAD(&fpq->processing[i]); 601 INIT_LIST_HEAD(&fpq->io); 602 fpq->connected = 1; 603 } 604 605 void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns, 606 const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv) 607 { 608 memset(fc, 0, sizeof(*fc)); 609 spin_lock_init(&fc->lock); 610 spin_lock_init(&fc->bg_lock); 611 init_rwsem(&fc->killsb); 612 refcount_set(&fc->count, 1); 613 atomic_set(&fc->dev_count, 1); 614 init_waitqueue_head(&fc->blocked_waitq); 615 fuse_iqueue_init(&fc->iq, fiq_ops, fiq_priv); 616 INIT_LIST_HEAD(&fc->bg_queue); 617 INIT_LIST_HEAD(&fc->entry); 618 INIT_LIST_HEAD(&fc->devices); 619 atomic_set(&fc->num_waiting, 0); 620 fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND; 621 fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD; 622 atomic64_set(&fc->khctr, 0); 623 fc->polled_files = RB_ROOT; 624 fc->blocked = 0; 625 fc->initialized = 0; 626 fc->connected = 1; 627 atomic64_set(&fc->attr_version, 1); 628 get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key)); 629 fc->pid_ns = get_pid_ns(task_active_pid_ns(current)); 630 fc->user_ns = get_user_ns(user_ns); 631 fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ; 632 } 633 EXPORT_SYMBOL_GPL(fuse_conn_init); 634 635 void fuse_conn_put(struct fuse_conn *fc) 636 { 637 if (refcount_dec_and_test(&fc->count)) { 638 struct fuse_iqueue *fiq = &fc->iq; 639 640 if (fiq->ops->release) 641 fiq->ops->release(fiq); 642 put_pid_ns(fc->pid_ns); 643 put_user_ns(fc->user_ns); 644 fc->release(fc); 645 } 646 } 647 EXPORT_SYMBOL_GPL(fuse_conn_put); 648 649 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc) 650 { 651 refcount_inc(&fc->count); 652 return fc; 653 } 654 EXPORT_SYMBOL_GPL(fuse_conn_get); 655 656 static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode) 657 { 658 struct fuse_attr attr; 659 memset(&attr, 0, sizeof(attr)); 660 661 attr.mode = mode; 662 attr.ino = FUSE_ROOT_ID; 663 attr.nlink = 1; 664 return fuse_iget(sb, 1, 0, &attr, 0, 0); 665 } 666 667 struct fuse_inode_handle { 668 u64 nodeid; 669 u32 generation; 670 }; 671 672 static struct dentry *fuse_get_dentry(struct super_block *sb, 673 struct fuse_inode_handle *handle) 674 { 675 struct fuse_conn *fc = get_fuse_conn_super(sb); 676 struct inode *inode; 677 struct dentry *entry; 678 int err = -ESTALE; 679 680 if (handle->nodeid == 0) 681 goto out_err; 682 683 inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid); 684 if (!inode) { 685 struct fuse_entry_out outarg; 686 const struct qstr name = QSTR_INIT(".", 1); 687 688 if (!fc->export_support) 689 goto out_err; 690 691 err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg, 692 &inode); 693 if (err && err != -ENOENT) 694 goto out_err; 695 if (err || !inode) { 696 err = -ESTALE; 697 goto out_err; 698 } 699 err = -EIO; 700 if (get_node_id(inode) != handle->nodeid) 701 goto out_iput; 702 } 703 err = -ESTALE; 704 if (inode->i_generation != handle->generation) 705 goto out_iput; 706 707 entry = d_obtain_alias(inode); 708 if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID) 709 fuse_invalidate_entry_cache(entry); 710 711 return entry; 712 713 out_iput: 714 iput(inode); 715 out_err: 716 return ERR_PTR(err); 717 } 718 719 static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len, 720 struct inode *parent) 721 { 722 int len = parent ? 6 : 3; 723 u64 nodeid; 724 u32 generation; 725 726 if (*max_len < len) { 727 *max_len = len; 728 return FILEID_INVALID; 729 } 730 731 nodeid = get_fuse_inode(inode)->nodeid; 732 generation = inode->i_generation; 733 734 fh[0] = (u32)(nodeid >> 32); 735 fh[1] = (u32)(nodeid & 0xffffffff); 736 fh[2] = generation; 737 738 if (parent) { 739 nodeid = get_fuse_inode(parent)->nodeid; 740 generation = parent->i_generation; 741 742 fh[3] = (u32)(nodeid >> 32); 743 fh[4] = (u32)(nodeid & 0xffffffff); 744 fh[5] = generation; 745 } 746 747 *max_len = len; 748 return parent ? 0x82 : 0x81; 749 } 750 751 static struct dentry *fuse_fh_to_dentry(struct super_block *sb, 752 struct fid *fid, int fh_len, int fh_type) 753 { 754 struct fuse_inode_handle handle; 755 756 if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3) 757 return NULL; 758 759 handle.nodeid = (u64) fid->raw[0] << 32; 760 handle.nodeid |= (u64) fid->raw[1]; 761 handle.generation = fid->raw[2]; 762 return fuse_get_dentry(sb, &handle); 763 } 764 765 static struct dentry *fuse_fh_to_parent(struct super_block *sb, 766 struct fid *fid, int fh_len, int fh_type) 767 { 768 struct fuse_inode_handle parent; 769 770 if (fh_type != 0x82 || fh_len < 6) 771 return NULL; 772 773 parent.nodeid = (u64) fid->raw[3] << 32; 774 parent.nodeid |= (u64) fid->raw[4]; 775 parent.generation = fid->raw[5]; 776 return fuse_get_dentry(sb, &parent); 777 } 778 779 static struct dentry *fuse_get_parent(struct dentry *child) 780 { 781 struct inode *child_inode = d_inode(child); 782 struct fuse_conn *fc = get_fuse_conn(child_inode); 783 struct inode *inode; 784 struct dentry *parent; 785 struct fuse_entry_out outarg; 786 const struct qstr name = QSTR_INIT("..", 2); 787 int err; 788 789 if (!fc->export_support) 790 return ERR_PTR(-ESTALE); 791 792 err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode), 793 &name, &outarg, &inode); 794 if (err) { 795 if (err == -ENOENT) 796 return ERR_PTR(-ESTALE); 797 return ERR_PTR(err); 798 } 799 800 parent = d_obtain_alias(inode); 801 if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID) 802 fuse_invalidate_entry_cache(parent); 803 804 return parent; 805 } 806 807 static const struct export_operations fuse_export_operations = { 808 .fh_to_dentry = fuse_fh_to_dentry, 809 .fh_to_parent = fuse_fh_to_parent, 810 .encode_fh = fuse_encode_fh, 811 .get_parent = fuse_get_parent, 812 }; 813 814 static const struct super_operations fuse_super_operations = { 815 .alloc_inode = fuse_alloc_inode, 816 .free_inode = fuse_free_inode, 817 .evict_inode = fuse_evict_inode, 818 .write_inode = fuse_write_inode, 819 .drop_inode = generic_delete_inode, 820 .remount_fs = fuse_remount_fs, 821 .put_super = fuse_put_super, 822 .umount_begin = fuse_umount_begin, 823 .statfs = fuse_statfs, 824 .show_options = fuse_show_options, 825 }; 826 827 static void sanitize_global_limit(unsigned *limit) 828 { 829 /* 830 * The default maximum number of async requests is calculated to consume 831 * 1/2^13 of the total memory, assuming 392 bytes per request. 832 */ 833 if (*limit == 0) 834 *limit = ((totalram_pages() << PAGE_SHIFT) >> 13) / 392; 835 836 if (*limit >= 1 << 16) 837 *limit = (1 << 16) - 1; 838 } 839 840 static int set_global_limit(const char *val, const struct kernel_param *kp) 841 { 842 int rv; 843 844 rv = param_set_uint(val, kp); 845 if (rv) 846 return rv; 847 848 sanitize_global_limit((unsigned *)kp->arg); 849 850 return 0; 851 } 852 853 static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg) 854 { 855 int cap_sys_admin = capable(CAP_SYS_ADMIN); 856 857 if (arg->minor < 13) 858 return; 859 860 sanitize_global_limit(&max_user_bgreq); 861 sanitize_global_limit(&max_user_congthresh); 862 863 spin_lock(&fc->bg_lock); 864 if (arg->max_background) { 865 fc->max_background = arg->max_background; 866 867 if (!cap_sys_admin && fc->max_background > max_user_bgreq) 868 fc->max_background = max_user_bgreq; 869 } 870 if (arg->congestion_threshold) { 871 fc->congestion_threshold = arg->congestion_threshold; 872 873 if (!cap_sys_admin && 874 fc->congestion_threshold > max_user_congthresh) 875 fc->congestion_threshold = max_user_congthresh; 876 } 877 spin_unlock(&fc->bg_lock); 878 } 879 880 struct fuse_init_args { 881 struct fuse_args args; 882 struct fuse_init_in in; 883 struct fuse_init_out out; 884 }; 885 886 static void process_init_reply(struct fuse_conn *fc, struct fuse_args *args, 887 int error) 888 { 889 struct fuse_init_args *ia = container_of(args, typeof(*ia), args); 890 struct fuse_init_out *arg = &ia->out; 891 892 if (error || arg->major != FUSE_KERNEL_VERSION) 893 fc->conn_error = 1; 894 else { 895 unsigned long ra_pages; 896 897 process_init_limits(fc, arg); 898 899 if (arg->minor >= 6) { 900 ra_pages = arg->max_readahead / PAGE_SIZE; 901 if (arg->flags & FUSE_ASYNC_READ) 902 fc->async_read = 1; 903 if (!(arg->flags & FUSE_POSIX_LOCKS)) 904 fc->no_lock = 1; 905 if (arg->minor >= 17) { 906 if (!(arg->flags & FUSE_FLOCK_LOCKS)) 907 fc->no_flock = 1; 908 } else { 909 if (!(arg->flags & FUSE_POSIX_LOCKS)) 910 fc->no_flock = 1; 911 } 912 if (arg->flags & FUSE_ATOMIC_O_TRUNC) 913 fc->atomic_o_trunc = 1; 914 if (arg->minor >= 9) { 915 /* LOOKUP has dependency on proto version */ 916 if (arg->flags & FUSE_EXPORT_SUPPORT) 917 fc->export_support = 1; 918 } 919 if (arg->flags & FUSE_BIG_WRITES) 920 fc->big_writes = 1; 921 if (arg->flags & FUSE_DONT_MASK) 922 fc->dont_mask = 1; 923 if (arg->flags & FUSE_AUTO_INVAL_DATA) 924 fc->auto_inval_data = 1; 925 else if (arg->flags & FUSE_EXPLICIT_INVAL_DATA) 926 fc->explicit_inval_data = 1; 927 if (arg->flags & FUSE_DO_READDIRPLUS) { 928 fc->do_readdirplus = 1; 929 if (arg->flags & FUSE_READDIRPLUS_AUTO) 930 fc->readdirplus_auto = 1; 931 } 932 if (arg->flags & FUSE_ASYNC_DIO) 933 fc->async_dio = 1; 934 if (arg->flags & FUSE_WRITEBACK_CACHE) 935 fc->writeback_cache = 1; 936 if (arg->flags & FUSE_PARALLEL_DIROPS) 937 fc->parallel_dirops = 1; 938 if (arg->flags & FUSE_HANDLE_KILLPRIV) 939 fc->handle_killpriv = 1; 940 if (arg->time_gran && arg->time_gran <= 1000000000) 941 fc->sb->s_time_gran = arg->time_gran; 942 if ((arg->flags & FUSE_POSIX_ACL)) { 943 fc->default_permissions = 1; 944 fc->posix_acl = 1; 945 fc->sb->s_xattr = fuse_acl_xattr_handlers; 946 } 947 if (arg->flags & FUSE_CACHE_SYMLINKS) 948 fc->cache_symlinks = 1; 949 if (arg->flags & FUSE_ABORT_ERROR) 950 fc->abort_err = 1; 951 if (arg->flags & FUSE_MAX_PAGES) { 952 fc->max_pages = 953 min_t(unsigned int, FUSE_MAX_MAX_PAGES, 954 max_t(unsigned int, arg->max_pages, 1)); 955 } 956 } else { 957 ra_pages = fc->max_read / PAGE_SIZE; 958 fc->no_lock = 1; 959 fc->no_flock = 1; 960 } 961 962 fc->sb->s_bdi->ra_pages = 963 min(fc->sb->s_bdi->ra_pages, ra_pages); 964 fc->minor = arg->minor; 965 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write; 966 fc->max_write = max_t(unsigned, 4096, fc->max_write); 967 fc->conn_init = 1; 968 } 969 kfree(ia); 970 971 fuse_set_initialized(fc); 972 wake_up_all(&fc->blocked_waitq); 973 } 974 975 void fuse_send_init(struct fuse_conn *fc) 976 { 977 struct fuse_init_args *ia; 978 979 ia = kzalloc(sizeof(*ia), GFP_KERNEL | __GFP_NOFAIL); 980 981 ia->in.major = FUSE_KERNEL_VERSION; 982 ia->in.minor = FUSE_KERNEL_MINOR_VERSION; 983 ia->in.max_readahead = fc->sb->s_bdi->ra_pages * PAGE_SIZE; 984 ia->in.flags |= 985 FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC | 986 FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK | 987 FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ | 988 FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA | 989 FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO | 990 FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT | 991 FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL | 992 FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS | 993 FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA; 994 ia->args.opcode = FUSE_INIT; 995 ia->args.in_numargs = 1; 996 ia->args.in_args[0].size = sizeof(ia->in); 997 ia->args.in_args[0].value = &ia->in; 998 ia->args.out_numargs = 1; 999 /* Variable length argument used for backward compatibility 1000 with interface version < 7.5. Rest of init_out is zeroed 1001 by do_get_request(), so a short reply is not a problem */ 1002 ia->args.out_argvar = true; 1003 ia->args.out_args[0].size = sizeof(ia->out); 1004 ia->args.out_args[0].value = &ia->out; 1005 ia->args.force = true; 1006 ia->args.nocreds = true; 1007 ia->args.end = process_init_reply; 1008 1009 if (fuse_simple_background(fc, &ia->args, GFP_KERNEL) != 0) 1010 process_init_reply(fc, &ia->args, -ENOTCONN); 1011 } 1012 EXPORT_SYMBOL_GPL(fuse_send_init); 1013 1014 void fuse_free_conn(struct fuse_conn *fc) 1015 { 1016 WARN_ON(!list_empty(&fc->devices)); 1017 kfree_rcu(fc, rcu); 1018 } 1019 EXPORT_SYMBOL_GPL(fuse_free_conn); 1020 1021 static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb) 1022 { 1023 int err; 1024 char *suffix = ""; 1025 1026 if (sb->s_bdev) { 1027 suffix = "-fuseblk"; 1028 /* 1029 * sb->s_bdi points to blkdev's bdi however we want to redirect 1030 * it to our private bdi... 1031 */ 1032 bdi_put(sb->s_bdi); 1033 sb->s_bdi = &noop_backing_dev_info; 1034 } 1035 err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev), 1036 MINOR(fc->dev), suffix); 1037 if (err) 1038 return err; 1039 1040 sb->s_bdi->ra_pages = VM_READAHEAD_PAGES; 1041 /* fuse does it's own writeback accounting */ 1042 sb->s_bdi->capabilities = BDI_CAP_NO_ACCT_WB | BDI_CAP_STRICTLIMIT; 1043 1044 /* 1045 * For a single fuse filesystem use max 1% of dirty + 1046 * writeback threshold. 1047 * 1048 * This gives about 1M of write buffer for memory maps on a 1049 * machine with 1G and 10% dirty_ratio, which should be more 1050 * than enough. 1051 * 1052 * Privileged users can raise it by writing to 1053 * 1054 * /sys/class/bdi/<bdi>/max_ratio 1055 */ 1056 bdi_set_max_ratio(sb->s_bdi, 1); 1057 1058 return 0; 1059 } 1060 1061 struct fuse_dev *fuse_dev_alloc(void) 1062 { 1063 struct fuse_dev *fud; 1064 struct list_head *pq; 1065 1066 fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL); 1067 if (!fud) 1068 return NULL; 1069 1070 pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL); 1071 if (!pq) { 1072 kfree(fud); 1073 return NULL; 1074 } 1075 1076 fud->pq.processing = pq; 1077 fuse_pqueue_init(&fud->pq); 1078 1079 return fud; 1080 } 1081 EXPORT_SYMBOL_GPL(fuse_dev_alloc); 1082 1083 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc) 1084 { 1085 fud->fc = fuse_conn_get(fc); 1086 spin_lock(&fc->lock); 1087 list_add_tail(&fud->entry, &fc->devices); 1088 spin_unlock(&fc->lock); 1089 } 1090 EXPORT_SYMBOL_GPL(fuse_dev_install); 1091 1092 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc) 1093 { 1094 struct fuse_dev *fud; 1095 1096 fud = fuse_dev_alloc(); 1097 if (!fud) 1098 return NULL; 1099 1100 fuse_dev_install(fud, fc); 1101 return fud; 1102 } 1103 EXPORT_SYMBOL_GPL(fuse_dev_alloc_install); 1104 1105 void fuse_dev_free(struct fuse_dev *fud) 1106 { 1107 struct fuse_conn *fc = fud->fc; 1108 1109 if (fc) { 1110 spin_lock(&fc->lock); 1111 list_del(&fud->entry); 1112 spin_unlock(&fc->lock); 1113 1114 fuse_conn_put(fc); 1115 } 1116 kfree(fud->pq.processing); 1117 kfree(fud); 1118 } 1119 EXPORT_SYMBOL_GPL(fuse_dev_free); 1120 1121 int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx) 1122 { 1123 struct fuse_dev *fud = NULL; 1124 struct fuse_conn *fc = get_fuse_conn_super(sb); 1125 struct inode *root; 1126 struct dentry *root_dentry; 1127 int err; 1128 1129 err = -EINVAL; 1130 if (sb->s_flags & SB_MANDLOCK) 1131 goto err; 1132 1133 sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION); 1134 1135 if (ctx->is_bdev) { 1136 #ifdef CONFIG_BLOCK 1137 err = -EINVAL; 1138 if (!sb_set_blocksize(sb, ctx->blksize)) 1139 goto err; 1140 #endif 1141 } else { 1142 sb->s_blocksize = PAGE_SIZE; 1143 sb->s_blocksize_bits = PAGE_SHIFT; 1144 } 1145 1146 sb->s_subtype = ctx->subtype; 1147 ctx->subtype = NULL; 1148 sb->s_magic = FUSE_SUPER_MAGIC; 1149 sb->s_op = &fuse_super_operations; 1150 sb->s_xattr = fuse_xattr_handlers; 1151 sb->s_maxbytes = MAX_LFS_FILESIZE; 1152 sb->s_time_gran = 1; 1153 sb->s_export_op = &fuse_export_operations; 1154 sb->s_iflags |= SB_I_IMA_UNVERIFIABLE_SIGNATURE; 1155 if (sb->s_user_ns != &init_user_ns) 1156 sb->s_iflags |= SB_I_UNTRUSTED_MOUNTER; 1157 1158 /* 1159 * If we are not in the initial user namespace posix 1160 * acls must be translated. 1161 */ 1162 if (sb->s_user_ns != &init_user_ns) 1163 sb->s_xattr = fuse_no_acl_xattr_handlers; 1164 1165 if (ctx->fudptr) { 1166 err = -ENOMEM; 1167 fud = fuse_dev_alloc_install(fc); 1168 if (!fud) 1169 goto err; 1170 } 1171 1172 fc->dev = sb->s_dev; 1173 fc->sb = sb; 1174 err = fuse_bdi_init(fc, sb); 1175 if (err) 1176 goto err_dev_free; 1177 1178 /* Handle umasking inside the fuse code */ 1179 if (sb->s_flags & SB_POSIXACL) 1180 fc->dont_mask = 1; 1181 sb->s_flags |= SB_POSIXACL; 1182 1183 fc->default_permissions = ctx->default_permissions; 1184 fc->allow_other = ctx->allow_other; 1185 fc->user_id = ctx->user_id; 1186 fc->group_id = ctx->group_id; 1187 fc->max_read = max_t(unsigned, 4096, ctx->max_read); 1188 fc->destroy = ctx->destroy; 1189 fc->no_control = ctx->no_control; 1190 fc->no_force_umount = ctx->no_force_umount; 1191 fc->no_mount_options = ctx->no_mount_options; 1192 1193 err = -ENOMEM; 1194 root = fuse_get_root_inode(sb, ctx->rootmode); 1195 sb->s_d_op = &fuse_root_dentry_operations; 1196 root_dentry = d_make_root(root); 1197 if (!root_dentry) 1198 goto err_dev_free; 1199 /* Root dentry doesn't have .d_revalidate */ 1200 sb->s_d_op = &fuse_dentry_operations; 1201 1202 mutex_lock(&fuse_mutex); 1203 err = -EINVAL; 1204 if (ctx->fudptr && *ctx->fudptr) 1205 goto err_unlock; 1206 1207 err = fuse_ctl_add_conn(fc); 1208 if (err) 1209 goto err_unlock; 1210 1211 list_add_tail(&fc->entry, &fuse_conn_list); 1212 sb->s_root = root_dentry; 1213 if (ctx->fudptr) 1214 *ctx->fudptr = fud; 1215 mutex_unlock(&fuse_mutex); 1216 return 0; 1217 1218 err_unlock: 1219 mutex_unlock(&fuse_mutex); 1220 dput(root_dentry); 1221 err_dev_free: 1222 if (fud) 1223 fuse_dev_free(fud); 1224 err: 1225 return err; 1226 } 1227 EXPORT_SYMBOL_GPL(fuse_fill_super_common); 1228 1229 static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc) 1230 { 1231 struct fuse_fs_context *ctx = fsc->fs_private; 1232 struct file *file; 1233 int err; 1234 struct fuse_conn *fc; 1235 1236 err = -EINVAL; 1237 file = fget(ctx->fd); 1238 if (!file) 1239 goto err; 1240 1241 /* 1242 * Require mount to happen from the same user namespace which 1243 * opened /dev/fuse to prevent potential attacks. 1244 */ 1245 if ((file->f_op != &fuse_dev_operations) || 1246 (file->f_cred->user_ns != sb->s_user_ns)) 1247 goto err_fput; 1248 ctx->fudptr = &file->private_data; 1249 1250 fc = kmalloc(sizeof(*fc), GFP_KERNEL); 1251 err = -ENOMEM; 1252 if (!fc) 1253 goto err_fput; 1254 1255 fuse_conn_init(fc, sb->s_user_ns, &fuse_dev_fiq_ops, NULL); 1256 fc->release = fuse_free_conn; 1257 sb->s_fs_info = fc; 1258 1259 err = fuse_fill_super_common(sb, ctx); 1260 if (err) 1261 goto err_put_conn; 1262 /* 1263 * atomic_dec_and_test() in fput() provides the necessary 1264 * memory barrier for file->private_data to be visible on all 1265 * CPUs after this 1266 */ 1267 fput(file); 1268 fuse_send_init(get_fuse_conn_super(sb)); 1269 return 0; 1270 1271 err_put_conn: 1272 fuse_conn_put(fc); 1273 sb->s_fs_info = NULL; 1274 err_fput: 1275 fput(file); 1276 err: 1277 return err; 1278 } 1279 1280 static int fuse_get_tree(struct fs_context *fc) 1281 { 1282 struct fuse_fs_context *ctx = fc->fs_private; 1283 1284 if (!ctx->fd_present || !ctx->rootmode_present || 1285 !ctx->user_id_present || !ctx->group_id_present) 1286 return -EINVAL; 1287 1288 #ifdef CONFIG_BLOCK 1289 if (ctx->is_bdev) 1290 return get_tree_bdev(fc, fuse_fill_super); 1291 #endif 1292 1293 return get_tree_nodev(fc, fuse_fill_super); 1294 } 1295 1296 static const struct fs_context_operations fuse_context_ops = { 1297 .free = fuse_free_fc, 1298 .parse_param = fuse_parse_param, 1299 .get_tree = fuse_get_tree, 1300 }; 1301 1302 /* 1303 * Set up the filesystem mount context. 1304 */ 1305 static int fuse_init_fs_context(struct fs_context *fc) 1306 { 1307 struct fuse_fs_context *ctx; 1308 1309 ctx = kzalloc(sizeof(struct fuse_fs_context), GFP_KERNEL); 1310 if (!ctx) 1311 return -ENOMEM; 1312 1313 ctx->max_read = ~0; 1314 ctx->blksize = FUSE_DEFAULT_BLKSIZE; 1315 1316 #ifdef CONFIG_BLOCK 1317 if (fc->fs_type == &fuseblk_fs_type) { 1318 ctx->is_bdev = true; 1319 ctx->destroy = true; 1320 } 1321 #endif 1322 1323 fc->fs_private = ctx; 1324 fc->ops = &fuse_context_ops; 1325 return 0; 1326 } 1327 1328 static void fuse_sb_destroy(struct super_block *sb) 1329 { 1330 struct fuse_conn *fc = get_fuse_conn_super(sb); 1331 1332 if (fc) { 1333 if (fc->destroy) 1334 fuse_send_destroy(fc); 1335 1336 fuse_abort_conn(fc); 1337 fuse_wait_aborted(fc); 1338 1339 down_write(&fc->killsb); 1340 fc->sb = NULL; 1341 up_write(&fc->killsb); 1342 } 1343 } 1344 1345 void fuse_kill_sb_anon(struct super_block *sb) 1346 { 1347 fuse_sb_destroy(sb); 1348 kill_anon_super(sb); 1349 } 1350 EXPORT_SYMBOL_GPL(fuse_kill_sb_anon); 1351 1352 static struct file_system_type fuse_fs_type = { 1353 .owner = THIS_MODULE, 1354 .name = "fuse", 1355 .fs_flags = FS_HAS_SUBTYPE | FS_USERNS_MOUNT, 1356 .init_fs_context = fuse_init_fs_context, 1357 .parameters = fuse_fs_parameters, 1358 .kill_sb = fuse_kill_sb_anon, 1359 }; 1360 MODULE_ALIAS_FS("fuse"); 1361 1362 #ifdef CONFIG_BLOCK 1363 static void fuse_kill_sb_blk(struct super_block *sb) 1364 { 1365 fuse_sb_destroy(sb); 1366 kill_block_super(sb); 1367 } 1368 1369 static struct file_system_type fuseblk_fs_type = { 1370 .owner = THIS_MODULE, 1371 .name = "fuseblk", 1372 .init_fs_context = fuse_init_fs_context, 1373 .parameters = fuse_fs_parameters, 1374 .kill_sb = fuse_kill_sb_blk, 1375 .fs_flags = FS_REQUIRES_DEV | FS_HAS_SUBTYPE, 1376 }; 1377 MODULE_ALIAS_FS("fuseblk"); 1378 1379 static inline int register_fuseblk(void) 1380 { 1381 return register_filesystem(&fuseblk_fs_type); 1382 } 1383 1384 static inline void unregister_fuseblk(void) 1385 { 1386 unregister_filesystem(&fuseblk_fs_type); 1387 } 1388 #else 1389 static inline int register_fuseblk(void) 1390 { 1391 return 0; 1392 } 1393 1394 static inline void unregister_fuseblk(void) 1395 { 1396 } 1397 #endif 1398 1399 static void fuse_inode_init_once(void *foo) 1400 { 1401 struct inode *inode = foo; 1402 1403 inode_init_once(inode); 1404 } 1405 1406 static int __init fuse_fs_init(void) 1407 { 1408 int err; 1409 1410 fuse_inode_cachep = kmem_cache_create("fuse_inode", 1411 sizeof(struct fuse_inode), 0, 1412 SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT|SLAB_RECLAIM_ACCOUNT, 1413 fuse_inode_init_once); 1414 err = -ENOMEM; 1415 if (!fuse_inode_cachep) 1416 goto out; 1417 1418 err = register_fuseblk(); 1419 if (err) 1420 goto out2; 1421 1422 err = register_filesystem(&fuse_fs_type); 1423 if (err) 1424 goto out3; 1425 1426 return 0; 1427 1428 out3: 1429 unregister_fuseblk(); 1430 out2: 1431 kmem_cache_destroy(fuse_inode_cachep); 1432 out: 1433 return err; 1434 } 1435 1436 static void fuse_fs_cleanup(void) 1437 { 1438 unregister_filesystem(&fuse_fs_type); 1439 unregister_fuseblk(); 1440 1441 /* 1442 * Make sure all delayed rcu free inodes are flushed before we 1443 * destroy cache. 1444 */ 1445 rcu_barrier(); 1446 kmem_cache_destroy(fuse_inode_cachep); 1447 } 1448 1449 static struct kobject *fuse_kobj; 1450 1451 static int fuse_sysfs_init(void) 1452 { 1453 int err; 1454 1455 fuse_kobj = kobject_create_and_add("fuse", fs_kobj); 1456 if (!fuse_kobj) { 1457 err = -ENOMEM; 1458 goto out_err; 1459 } 1460 1461 err = sysfs_create_mount_point(fuse_kobj, "connections"); 1462 if (err) 1463 goto out_fuse_unregister; 1464 1465 return 0; 1466 1467 out_fuse_unregister: 1468 kobject_put(fuse_kobj); 1469 out_err: 1470 return err; 1471 } 1472 1473 static void fuse_sysfs_cleanup(void) 1474 { 1475 sysfs_remove_mount_point(fuse_kobj, "connections"); 1476 kobject_put(fuse_kobj); 1477 } 1478 1479 static int __init fuse_init(void) 1480 { 1481 int res; 1482 1483 pr_info("init (API version %i.%i)\n", 1484 FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION); 1485 1486 INIT_LIST_HEAD(&fuse_conn_list); 1487 res = fuse_fs_init(); 1488 if (res) 1489 goto err; 1490 1491 res = fuse_dev_init(); 1492 if (res) 1493 goto err_fs_cleanup; 1494 1495 res = fuse_sysfs_init(); 1496 if (res) 1497 goto err_dev_cleanup; 1498 1499 res = fuse_ctl_init(); 1500 if (res) 1501 goto err_sysfs_cleanup; 1502 1503 sanitize_global_limit(&max_user_bgreq); 1504 sanitize_global_limit(&max_user_congthresh); 1505 1506 return 0; 1507 1508 err_sysfs_cleanup: 1509 fuse_sysfs_cleanup(); 1510 err_dev_cleanup: 1511 fuse_dev_cleanup(); 1512 err_fs_cleanup: 1513 fuse_fs_cleanup(); 1514 err: 1515 return res; 1516 } 1517 1518 static void __exit fuse_exit(void) 1519 { 1520 pr_debug("exit\n"); 1521 1522 fuse_ctl_cleanup(); 1523 fuse_sysfs_cleanup(); 1524 fuse_fs_cleanup(); 1525 fuse_dev_cleanup(); 1526 } 1527 1528 module_init(fuse_init); 1529 module_exit(fuse_exit); 1530