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