1d8a5ba45SMiklos Szeredi /* 2d8a5ba45SMiklos Szeredi FUSE: Filesystem in Userspace 31729a16cSMiklos Szeredi Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu> 4d8a5ba45SMiklos Szeredi 5d8a5ba45SMiklos Szeredi This program can be distributed under the terms of the GNU GPL. 6d8a5ba45SMiklos Szeredi See the file COPYING. 7d8a5ba45SMiklos Szeredi */ 8d8a5ba45SMiklos Szeredi 9d8a5ba45SMiklos Szeredi #include "fuse_i.h" 10d8a5ba45SMiklos Szeredi 11d8a5ba45SMiklos Szeredi #include <linux/pagemap.h> 12d8a5ba45SMiklos Szeredi #include <linux/slab.h> 13d8a5ba45SMiklos Szeredi #include <linux/file.h> 14d8a5ba45SMiklos Szeredi #include <linux/seq_file.h> 15d8a5ba45SMiklos Szeredi #include <linux/init.h> 16d8a5ba45SMiklos Szeredi #include <linux/module.h> 17487ea5afSCsaba Henk #include <linux/moduleparam.h> 18c30da2e9SDavid Howells #include <linux/fs_context.h> 19c30da2e9SDavid Howells #include <linux/fs_parser.h> 20d8a5ba45SMiklos Szeredi #include <linux/statfs.h> 219c8ef561SMiklos Szeredi #include <linux/random.h> 22e8edc6e0SAlexey Dobriyan #include <linux/sched.h> 23dbd561d2SMiklos Szeredi #include <linux/exportfs.h> 2460bcc88aSSeth Forshee #include <linux/posix_acl.h> 250b6e9ea0SSeth Forshee #include <linux/pid_namespace.h> 26d8a5ba45SMiklos Szeredi 27d8a5ba45SMiklos Szeredi MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 28d8a5ba45SMiklos Szeredi MODULE_DESCRIPTION("Filesystem in Userspace"); 29d8a5ba45SMiklos Szeredi MODULE_LICENSE("GPL"); 30d8a5ba45SMiklos Szeredi 31e18b890bSChristoph Lameter static struct kmem_cache *fuse_inode_cachep; 32bafa9654SMiklos Szeredi struct list_head fuse_conn_list; 33bafa9654SMiklos Szeredi DEFINE_MUTEX(fuse_mutex); 34d8a5ba45SMiklos Szeredi 35e4dca7b7SKees Cook static int set_global_limit(const char *val, const struct kernel_param *kp); 36487ea5afSCsaba Henk 3779a9d994SCsaba Henk unsigned max_user_bgreq; 38487ea5afSCsaba Henk module_param_call(max_user_bgreq, set_global_limit, param_get_uint, 39487ea5afSCsaba Henk &max_user_bgreq, 0644); 40487ea5afSCsaba Henk __MODULE_PARM_TYPE(max_user_bgreq, "uint"); 41487ea5afSCsaba Henk MODULE_PARM_DESC(max_user_bgreq, 42487ea5afSCsaba Henk "Global limit for the maximum number of backgrounded requests an " 43487ea5afSCsaba Henk "unprivileged user can set"); 44487ea5afSCsaba Henk 4579a9d994SCsaba Henk unsigned max_user_congthresh; 46487ea5afSCsaba Henk module_param_call(max_user_congthresh, set_global_limit, param_get_uint, 47487ea5afSCsaba Henk &max_user_congthresh, 0644); 48487ea5afSCsaba Henk __MODULE_PARM_TYPE(max_user_congthresh, "uint"); 49487ea5afSCsaba Henk MODULE_PARM_DESC(max_user_congthresh, 50487ea5afSCsaba Henk "Global limit for the maximum congestion threshold an " 51487ea5afSCsaba Henk "unprivileged user can set"); 52487ea5afSCsaba Henk 53d8a5ba45SMiklos Szeredi #define FUSE_SUPER_MAGIC 0x65735546 54d8a5ba45SMiklos Szeredi 55d1875dbaSMiklos Szeredi #define FUSE_DEFAULT_BLKSIZE 512 56d1875dbaSMiklos Szeredi 577a6d3c8bSCsaba Henk /** Maximum number of outstanding background requests */ 587a6d3c8bSCsaba Henk #define FUSE_DEFAULT_MAX_BACKGROUND 12 597a6d3c8bSCsaba Henk 607a6d3c8bSCsaba Henk /** Congestion starts at 75% of maximum */ 617a6d3c8bSCsaba Henk #define FUSE_DEFAULT_CONGESTION_THRESHOLD (FUSE_DEFAULT_MAX_BACKGROUND * 3 / 4) 627a6d3c8bSCsaba Henk 63c30da2e9SDavid Howells #ifdef CONFIG_BLOCK 64c30da2e9SDavid Howells static struct file_system_type fuseblk_fs_type; 65c30da2e9SDavid Howells #endif 66c30da2e9SDavid Howells 67a2daff68SRandy Dunlap struct fuse_forget_link *fuse_alloc_forget(void) 6807e77dcaSMiklos Szeredi { 69dc69e98cSKhazhismel Kumykov return kzalloc(sizeof(struct fuse_forget_link), GFP_KERNEL_ACCOUNT); 7007e77dcaSMiklos Szeredi } 7107e77dcaSMiklos Szeredi 72d8a5ba45SMiklos Szeredi static struct inode *fuse_alloc_inode(struct super_block *sb) 73d8a5ba45SMiklos Szeredi { 74d8a5ba45SMiklos Szeredi struct fuse_inode *fi; 75d8a5ba45SMiklos Szeredi 769031a69cSzhangliguang fi = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL); 779031a69cSzhangliguang if (!fi) 78d8a5ba45SMiklos Szeredi return NULL; 79d8a5ba45SMiklos Szeredi 800a0898cfSMiklos Szeredi fi->i_time = 0; 812f1e8196SMiklos Szeredi fi->inval_mask = 0; 82d8a5ba45SMiklos Szeredi fi->nodeid = 0; 839e6268dbSMiklos Szeredi fi->nlookup = 0; 84fbee36b9SJohn Muir fi->attr_version = 0; 8545c72cd7SPavel Shilovsky fi->orig_ino = 0; 864582a4abSFeng Shuo fi->state = 0; 875c672ab3SMiklos Szeredi mutex_init(&fi->mutex); 88f15ecfefSKirill Tkhai spin_lock_init(&fi->lock); 8907e77dcaSMiklos Szeredi fi->forget = fuse_alloc_forget(); 90c2d0ad00SVivek Goyal if (!fi->forget) 91c2d0ad00SVivek Goyal goto out_free; 92c2d0ad00SVivek Goyal 93c2d0ad00SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX) && !fuse_dax_inode_alloc(sb, fi)) 94c2d0ad00SVivek Goyal goto out_free_forget; 95d8a5ba45SMiklos Szeredi 969031a69cSzhangliguang return &fi->inode; 97c2d0ad00SVivek Goyal 98c2d0ad00SVivek Goyal out_free_forget: 99c2d0ad00SVivek Goyal kfree(fi->forget); 100c2d0ad00SVivek Goyal out_free: 101c2d0ad00SVivek Goyal kmem_cache_free(fuse_inode_cachep, fi); 102c2d0ad00SVivek Goyal return NULL; 103d8a5ba45SMiklos Szeredi } 104d8a5ba45SMiklos Szeredi 1059baf28bbSAl Viro static void fuse_free_inode(struct inode *inode) 106d8a5ba45SMiklos Szeredi { 107e5e5558eSMiklos Szeredi struct fuse_inode *fi = get_fuse_inode(inode); 1089baf28bbSAl Viro 1095c672ab3SMiklos Szeredi mutex_destroy(&fi->mutex); 11007e77dcaSMiklos Szeredi kfree(fi->forget); 111c2d0ad00SVivek Goyal #ifdef CONFIG_FUSE_DAX 112c2d0ad00SVivek Goyal kfree(fi->dax); 113c2d0ad00SVivek Goyal #endif 1149baf28bbSAl Viro kmem_cache_free(fuse_inode_cachep, fi); 115d8a5ba45SMiklos Szeredi } 116d8a5ba45SMiklos Szeredi 117b57922d9SAl Viro static void fuse_evict_inode(struct inode *inode) 118d8a5ba45SMiklos Szeredi { 1199baf28bbSAl Viro struct fuse_inode *fi = get_fuse_inode(inode); 1209baf28bbSAl Viro 1215c791fe1SMiklos Szeredi /* Will write inode on close/munmap and in all other dirtiers */ 1225c791fe1SMiklos Szeredi WARN_ON(inode->i_state & I_DIRTY_INODE); 1235c791fe1SMiklos Szeredi 12491b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 125dbd5768fSJan Kara clear_inode(inode); 1261751e8a6SLinus Torvalds if (inode->i_sb->s_flags & SB_ACTIVE) { 127e5e5558eSMiklos Szeredi struct fuse_conn *fc = get_fuse_conn(inode); 128c2d0ad00SVivek Goyal 129c2d0ad00SVivek Goyal if (FUSE_IS_DAX(inode)) 130c2d0ad00SVivek Goyal fuse_dax_inode_cleanup(inode); 1311866d779SMax Reitz if (fi->nlookup) { 1321866d779SMax Reitz fuse_queue_forget(fc, fi->forget, fi->nodeid, 1331866d779SMax Reitz fi->nlookup); 13407e77dcaSMiklos Szeredi fi->forget = NULL; 135e5e5558eSMiklos Szeredi } 1361866d779SMax Reitz } 1375d069dbeSMiklos Szeredi if (S_ISREG(inode->i_mode) && !fuse_is_bad(inode)) { 1389baf28bbSAl Viro WARN_ON(!list_empty(&fi->write_files)); 1399baf28bbSAl Viro WARN_ON(!list_empty(&fi->queued_writes)); 1409baf28bbSAl Viro } 141d8a5ba45SMiklos Szeredi } 142d8a5ba45SMiklos Szeredi 14384c21507SMiklos Szeredi static int fuse_reconfigure(struct fs_context *fsc) 14471421259SMiklos Szeredi { 14584c21507SMiklos Szeredi struct super_block *sb = fsc->root->d_sb; 1460189a2d3SMiklos Szeredi 14702b9984dSTheodore Ts'o sync_filesystem(sb); 14884c21507SMiklos Szeredi if (fsc->sb_flags & SB_MANDLOCK) 14971421259SMiklos Szeredi return -EINVAL; 15071421259SMiklos Szeredi 15171421259SMiklos Szeredi return 0; 15271421259SMiklos Szeredi } 15371421259SMiklos Szeredi 15445c72cd7SPavel Shilovsky /* 15545c72cd7SPavel Shilovsky * ino_t is 32-bits on 32-bit arch. We have to squash the 64-bit value down 15645c72cd7SPavel Shilovsky * so that it will fit. 15745c72cd7SPavel Shilovsky */ 15845c72cd7SPavel Shilovsky static ino_t fuse_squash_ino(u64 ino64) 15945c72cd7SPavel Shilovsky { 16045c72cd7SPavel Shilovsky ino_t ino = (ino_t) ino64; 16145c72cd7SPavel Shilovsky if (sizeof(ino_t) < sizeof(u64)) 16245c72cd7SPavel Shilovsky ino ^= ino64 >> (sizeof(u64) - sizeof(ino_t)) * 8; 16345c72cd7SPavel Shilovsky return ino; 16445c72cd7SPavel Shilovsky } 16545c72cd7SPavel Shilovsky 1663be5a52bSMiklos Szeredi void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr, 1674b52f059SMiklos Szeredi u64 attr_valid, u32 cache_mask) 168d8a5ba45SMiklos Szeredi { 1699ffbb916SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn(inode); 170ebc14c4dSMiklos Szeredi struct fuse_inode *fi = get_fuse_inode(inode); 171d8a5ba45SMiklos Szeredi 172f15ecfefSKirill Tkhai lockdep_assert_held(&fi->lock); 173f15ecfefSKirill Tkhai 1744510d86fSKirill Tkhai fi->attr_version = atomic64_inc_return(&fc->attr_version); 1751fb69e78SMiklos Szeredi fi->i_time = attr_valid; 1762f1e8196SMiklos Szeredi WRITE_ONCE(fi->inval_mask, 0); 1771fb69e78SMiklos Szeredi 17845c72cd7SPavel Shilovsky inode->i_ino = fuse_squash_ino(attr->ino); 179ebc14c4dSMiklos Szeredi inode->i_mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777); 180bfe86848SMiklos Szeredi set_nlink(inode, attr->nlink); 1818cb08329SEric W. Biederman inode->i_uid = make_kuid(fc->user_ns, attr->uid); 1828cb08329SEric W. Biederman inode->i_gid = make_kgid(fc->user_ns, attr->gid); 183d8a5ba45SMiklos Szeredi inode->i_blocks = attr->blocks; 184d8a5ba45SMiklos Szeredi inode->i_atime.tv_sec = attr->atime; 185d8a5ba45SMiklos Szeredi inode->i_atime.tv_nsec = attr->atimensec; 186b0aa7606SMaxim Patlasov /* mtime from server may be stale due to local buffered write */ 1874b52f059SMiklos Szeredi if (!(cache_mask & STATX_MTIME)) { 188d8a5ba45SMiklos Szeredi inode->i_mtime.tv_sec = attr->mtime; 189d8a5ba45SMiklos Szeredi inode->i_mtime.tv_nsec = attr->mtimensec; 1904b52f059SMiklos Szeredi } 1914b52f059SMiklos Szeredi if (!(cache_mask & STATX_CTIME)) { 192d8a5ba45SMiklos Szeredi inode->i_ctime.tv_sec = attr->ctime; 193d8a5ba45SMiklos Szeredi inode->i_ctime.tv_nsec = attr->ctimensec; 19431f3267bSMaxim Patlasov } 195e00d2c2dSMiklos Szeredi 1960e9663eeSMiklos Szeredi if (attr->blksize != 0) 1970e9663eeSMiklos Szeredi inode->i_blkbits = ilog2(attr->blksize); 1980e9663eeSMiklos Szeredi else 1990e9663eeSMiklos Szeredi inode->i_blkbits = inode->i_sb->s_blocksize_bits; 2000e9663eeSMiklos Szeredi 201ebc14c4dSMiklos Szeredi /* 202ebc14c4dSMiklos Szeredi * Don't set the sticky bit in i_mode, unless we want the VFS 203ebc14c4dSMiklos Szeredi * to check permissions. This prevents failures due to the 204ebc14c4dSMiklos Szeredi * check in may_delete(). 205ebc14c4dSMiklos Szeredi */ 206ebc14c4dSMiklos Szeredi fi->orig_i_mode = inode->i_mode; 20729433a29SMiklos Szeredi if (!fc->default_permissions) 208ebc14c4dSMiklos Szeredi inode->i_mode &= ~S_ISVTX; 20945c72cd7SPavel Shilovsky 21045c72cd7SPavel Shilovsky fi->orig_ino = attr->ino; 2119d769e6aSVivek Goyal 2129d769e6aSVivek Goyal /* 2139d769e6aSVivek Goyal * We are refreshing inode data and it is possible that another 2149d769e6aSVivek Goyal * client set suid/sgid or security.capability xattr. So clear 2159d769e6aSVivek Goyal * S_NOSEC. Ideally, we could have cleared it only if suid/sgid 2169d769e6aSVivek Goyal * was set or if security.capability xattr was set. But we don't 2179d769e6aSVivek Goyal * know if security.capability has been set or not. So clear it 2189d769e6aSVivek Goyal * anyway. Its less efficient but should be safe. 2199d769e6aSVivek Goyal */ 2209d769e6aSVivek Goyal inode->i_flags &= ~S_NOSEC; 2213be5a52bSMiklos Szeredi } 2223be5a52bSMiklos Szeredi 2234b52f059SMiklos Szeredi u32 fuse_get_cache_mask(struct inode *inode) 2244b52f059SMiklos Szeredi { 2254b52f059SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn(inode); 2264b52f059SMiklos Szeredi 2274b52f059SMiklos Szeredi if (!fc->writeback_cache || !S_ISREG(inode->i_mode)) 2284b52f059SMiklos Szeredi return 0; 2294b52f059SMiklos Szeredi 2304b52f059SMiklos Szeredi return STATX_MTIME | STATX_CTIME | STATX_SIZE; 2314b52f059SMiklos Szeredi } 2324b52f059SMiklos Szeredi 2333be5a52bSMiklos Szeredi void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr, 2343be5a52bSMiklos Szeredi u64 attr_valid, u64 attr_version) 2353be5a52bSMiklos Szeredi { 2363be5a52bSMiklos Szeredi struct fuse_conn *fc = get_fuse_conn(inode); 2373be5a52bSMiklos Szeredi struct fuse_inode *fi = get_fuse_inode(inode); 2384b52f059SMiklos Szeredi u32 cache_mask; 2393be5a52bSMiklos Szeredi loff_t oldsize; 240a64ba10fSArnd Bergmann struct timespec64 old_mtime; 2413be5a52bSMiklos Szeredi 242f15ecfefSKirill Tkhai spin_lock(&fi->lock); 24304d82db0SMiklos Szeredi /* 24404d82db0SMiklos Szeredi * In case of writeback_cache enabled, writes update mtime, ctime and 24504d82db0SMiklos Szeredi * may update i_size. In these cases trust the cached value in the 24604d82db0SMiklos Szeredi * inode. 24704d82db0SMiklos Szeredi */ 2484b52f059SMiklos Szeredi cache_mask = fuse_get_cache_mask(inode); 2494b52f059SMiklos Szeredi if (cache_mask & STATX_SIZE) 25004d82db0SMiklos Szeredi attr->size = i_size_read(inode); 2514b52f059SMiklos Szeredi 2524b52f059SMiklos Szeredi if (cache_mask & STATX_MTIME) { 25304d82db0SMiklos Szeredi attr->mtime = inode->i_mtime.tv_sec; 25404d82db0SMiklos Szeredi attr->mtimensec = inode->i_mtime.tv_nsec; 2554b52f059SMiklos Szeredi } 2564b52f059SMiklos Szeredi if (cache_mask & STATX_CTIME) { 25704d82db0SMiklos Szeredi attr->ctime = inode->i_ctime.tv_sec; 25804d82db0SMiklos Szeredi attr->ctimensec = inode->i_ctime.tv_nsec; 25904d82db0SMiklos Szeredi } 26004d82db0SMiklos Szeredi 26106a7c3c2SMaxim Patlasov if ((attr_version != 0 && fi->attr_version > attr_version) || 26206a7c3c2SMaxim Patlasov test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) { 263f15ecfefSKirill Tkhai spin_unlock(&fi->lock); 2643be5a52bSMiklos Szeredi return; 2653be5a52bSMiklos Szeredi } 2663be5a52bSMiklos Szeredi 267a64ba10fSArnd Bergmann old_mtime = inode->i_mtime; 2684b52f059SMiklos Szeredi fuse_change_attributes_common(inode, attr, attr_valid, cache_mask); 269ebc14c4dSMiklos Szeredi 270e00d2c2dSMiklos Szeredi oldsize = inode->i_size; 2718373200bSPavel Emelyanov /* 2728373200bSPavel Emelyanov * In case of writeback_cache enabled, the cached writes beyond EOF 2738373200bSPavel Emelyanov * extend local i_size without keeping userspace server in sync. So, 2748373200bSPavel Emelyanov * attr->size coming from server can be stale. We cannot trust it. 2758373200bSPavel Emelyanov */ 2764b52f059SMiklos Szeredi if (!(cache_mask & STATX_SIZE)) 277e00d2c2dSMiklos Szeredi i_size_write(inode, attr->size); 278f15ecfefSKirill Tkhai spin_unlock(&fi->lock); 279e00d2c2dSMiklos Szeredi 2804b52f059SMiklos Szeredi if (!cache_mask && S_ISREG(inode->i_mode)) { 281eed2179eSBrian Foster bool inval = false; 282eed2179eSBrian Foster 283eed2179eSBrian Foster if (oldsize != attr->size) { 2847caef267SKirill A. Shutemov truncate_pagecache(inode, attr->size); 285ad2ba64dSKirill Smelkov if (!fc->explicit_inval_data) 286eed2179eSBrian Foster inval = true; 287eed2179eSBrian Foster } else if (fc->auto_inval_data) { 288a64ba10fSArnd Bergmann struct timespec64 new_mtime = { 289eed2179eSBrian Foster .tv_sec = attr->mtime, 290eed2179eSBrian Foster .tv_nsec = attr->mtimensec, 291eed2179eSBrian Foster }; 292eed2179eSBrian Foster 293eed2179eSBrian Foster /* 294eed2179eSBrian Foster * Auto inval mode also checks and invalidates if mtime 295eed2179eSBrian Foster * has changed. 296eed2179eSBrian Foster */ 297a64ba10fSArnd Bergmann if (!timespec64_equal(&old_mtime, &new_mtime)) 298eed2179eSBrian Foster inval = true; 299eed2179eSBrian Foster } 300eed2179eSBrian Foster 301eed2179eSBrian Foster if (inval) 302b1009979SMiklos Szeredi invalidate_inode_pages2(inode->i_mapping); 303e00d2c2dSMiklos Szeredi } 304d8a5ba45SMiklos Szeredi } 305d8a5ba45SMiklos Szeredi 306d8a5ba45SMiklos Szeredi static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr) 307d8a5ba45SMiklos Szeredi { 308d8a5ba45SMiklos Szeredi inode->i_mode = attr->mode & S_IFMT; 3099ffbb916SMiklos Szeredi inode->i_size = attr->size; 310b0aa7606SMaxim Patlasov inode->i_mtime.tv_sec = attr->mtime; 311b0aa7606SMaxim Patlasov inode->i_mtime.tv_nsec = attr->mtimensec; 31231f3267bSMaxim Patlasov inode->i_ctime.tv_sec = attr->ctime; 31331f3267bSMaxim Patlasov inode->i_ctime.tv_nsec = attr->ctimensec; 314e5e5558eSMiklos Szeredi if (S_ISREG(inode->i_mode)) { 315e5e5558eSMiklos Szeredi fuse_init_common(inode); 316b6aeadedSMiklos Szeredi fuse_init_file_inode(inode); 317e5e5558eSMiklos Szeredi } else if (S_ISDIR(inode->i_mode)) 318e5e5558eSMiklos Szeredi fuse_init_dir(inode); 319e5e5558eSMiklos Szeredi else if (S_ISLNK(inode->i_mode)) 320e5e5558eSMiklos Szeredi fuse_init_symlink(inode); 321e5e5558eSMiklos Szeredi else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 322e5e5558eSMiklos Szeredi S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 323e5e5558eSMiklos Szeredi fuse_init_common(inode); 324e5e5558eSMiklos Szeredi init_special_inode(inode, inode->i_mode, 325e5e5558eSMiklos Szeredi new_decode_dev(attr->rdev)); 32639ee059aSMiklos Szeredi } else 32739ee059aSMiklos Szeredi BUG(); 328d8a5ba45SMiklos Szeredi } 329d8a5ba45SMiklos Szeredi 330fcee216bSMax Reitz static int fuse_inode_eq(struct inode *inode, void *_nodeidp) 331d8a5ba45SMiklos Szeredi { 332b48badf0SMiklos Szeredi u64 nodeid = *(u64 *) _nodeidp; 333d8a5ba45SMiklos Szeredi if (get_node_id(inode) == nodeid) 334d8a5ba45SMiklos Szeredi return 1; 335d8a5ba45SMiklos Szeredi else 336d8a5ba45SMiklos Szeredi return 0; 337d8a5ba45SMiklos Szeredi } 338d8a5ba45SMiklos Szeredi 339d8a5ba45SMiklos Szeredi static int fuse_inode_set(struct inode *inode, void *_nodeidp) 340d8a5ba45SMiklos Szeredi { 341b48badf0SMiklos Szeredi u64 nodeid = *(u64 *) _nodeidp; 342d8a5ba45SMiklos Szeredi get_fuse_inode(inode)->nodeid = nodeid; 343d8a5ba45SMiklos Szeredi return 0; 344d8a5ba45SMiklos Szeredi } 345d8a5ba45SMiklos Szeredi 346b48badf0SMiklos Szeredi struct inode *fuse_iget(struct super_block *sb, u64 nodeid, 3471fb69e78SMiklos Szeredi int generation, struct fuse_attr *attr, 3481fb69e78SMiklos Szeredi u64 attr_valid, u64 attr_version) 349d8a5ba45SMiklos Szeredi { 350d8a5ba45SMiklos Szeredi struct inode *inode; 3519e6268dbSMiklos Szeredi struct fuse_inode *fi; 352d8a5ba45SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn_super(sb); 353d8a5ba45SMiklos Szeredi 354bf109c64SMax Reitz /* 355bf109c64SMax Reitz * Auto mount points get their node id from the submount root, which is 356bf109c64SMax Reitz * not a unique identifier within this filesystem. 357bf109c64SMax Reitz * 358bf109c64SMax Reitz * To avoid conflicts, do not place submount points into the inode hash 359bf109c64SMax Reitz * table. 360bf109c64SMax Reitz */ 361bf109c64SMax Reitz if (fc->auto_submounts && (attr->flags & FUSE_ATTR_SUBMOUNT) && 362bf109c64SMax Reitz S_ISDIR(attr->mode)) { 363bf109c64SMax Reitz inode = new_inode(sb); 364bf109c64SMax Reitz if (!inode) 365bf109c64SMax Reitz return NULL; 366bf109c64SMax Reitz 367bf109c64SMax Reitz fuse_init_inode(inode, attr); 368bf109c64SMax Reitz get_fuse_inode(inode)->nodeid = nodeid; 369bf109c64SMax Reitz inode->i_flags |= S_AUTOMOUNT; 370bf109c64SMax Reitz goto done; 371bf109c64SMax Reitz } 372bf109c64SMax Reitz 373d8a5ba45SMiklos Szeredi retry: 374d8a5ba45SMiklos Szeredi inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid); 375d8a5ba45SMiklos Szeredi if (!inode) 376d8a5ba45SMiklos Szeredi return NULL; 377d8a5ba45SMiklos Szeredi 378d8a5ba45SMiklos Szeredi if ((inode->i_state & I_NEW)) { 379b0aa7606SMaxim Patlasov inode->i_flags |= S_NOATIME; 380d31433c8SMaxim Patlasov if (!fc->writeback_cache || !S_ISREG(attr->mode)) 381b0aa7606SMaxim Patlasov inode->i_flags |= S_NOCMTIME; 382d8a5ba45SMiklos Szeredi inode->i_generation = generation; 383d8a5ba45SMiklos Szeredi fuse_init_inode(inode, attr); 384d8a5ba45SMiklos Szeredi unlock_new_inode(inode); 38515db1683SAmir Goldstein } else if (fuse_stale_inode(inode, generation, attr)) { 38615db1683SAmir Goldstein /* nodeid was reused, any I/O on the old inode should fail */ 3875d069dbeSMiklos Szeredi fuse_make_bad(inode); 388d8a5ba45SMiklos Szeredi iput(inode); 389d8a5ba45SMiklos Szeredi goto retry; 390d8a5ba45SMiklos Szeredi } 391bf109c64SMax Reitz done: 3929e6268dbSMiklos Szeredi fi = get_fuse_inode(inode); 393c9d8f5f0SKirill Tkhai spin_lock(&fi->lock); 3949e6268dbSMiklos Szeredi fi->nlookup++; 395c9d8f5f0SKirill Tkhai spin_unlock(&fi->lock); 3961fb69e78SMiklos Szeredi fuse_change_attributes(inode, attr, attr_valid, attr_version); 3971fb69e78SMiklos Szeredi 398d8a5ba45SMiklos Szeredi return inode; 399d8a5ba45SMiklos Szeredi } 400d8a5ba45SMiklos Szeredi 401fcee216bSMax Reitz struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid, 402fcee216bSMax Reitz struct fuse_mount **fm) 403fcee216bSMax Reitz { 404fcee216bSMax Reitz struct fuse_mount *fm_iter; 405fcee216bSMax Reitz struct inode *inode; 406fcee216bSMax Reitz 407fcee216bSMax Reitz WARN_ON(!rwsem_is_locked(&fc->killsb)); 408fcee216bSMax Reitz list_for_each_entry(fm_iter, &fc->mounts, fc_entry) { 409fcee216bSMax Reitz if (!fm_iter->sb) 410fcee216bSMax Reitz continue; 411fcee216bSMax Reitz 412fcee216bSMax Reitz inode = ilookup5(fm_iter->sb, nodeid, fuse_inode_eq, &nodeid); 413fcee216bSMax Reitz if (inode) { 414fcee216bSMax Reitz if (fm) 415fcee216bSMax Reitz *fm = fm_iter; 416fcee216bSMax Reitz return inode; 417fcee216bSMax Reitz } 418fcee216bSMax Reitz } 419fcee216bSMax Reitz 420fcee216bSMax Reitz return NULL; 421fcee216bSMax Reitz } 422fcee216bSMax Reitz 423fcee216bSMax Reitz int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid, 4243b463ae0SJohn Muir loff_t offset, loff_t len) 4253b463ae0SJohn Muir { 4265ddd9cedSMiklos Szeredi struct fuse_inode *fi; 4273b463ae0SJohn Muir struct inode *inode; 4283b463ae0SJohn Muir pgoff_t pg_start; 4293b463ae0SJohn Muir pgoff_t pg_end; 4303b463ae0SJohn Muir 431fcee216bSMax Reitz inode = fuse_ilookup(fc, nodeid, NULL); 4323b463ae0SJohn Muir if (!inode) 4333b463ae0SJohn Muir return -ENOENT; 4343b463ae0SJohn Muir 4355ddd9cedSMiklos Szeredi fi = get_fuse_inode(inode); 4365ddd9cedSMiklos Szeredi spin_lock(&fi->lock); 4375ddd9cedSMiklos Szeredi fi->attr_version = atomic64_inc_return(&fc->attr_version); 4385ddd9cedSMiklos Szeredi spin_unlock(&fi->lock); 4395ddd9cedSMiklos Szeredi 4403b463ae0SJohn Muir fuse_invalidate_attr(inode); 44160bcc88aSSeth Forshee forget_all_cached_acls(inode); 4423b463ae0SJohn Muir if (offset >= 0) { 44309cbfeafSKirill A. Shutemov pg_start = offset >> PAGE_SHIFT; 4443b463ae0SJohn Muir if (len <= 0) 4453b463ae0SJohn Muir pg_end = -1; 4463b463ae0SJohn Muir else 44709cbfeafSKirill A. Shutemov pg_end = (offset + len - 1) >> PAGE_SHIFT; 4483b463ae0SJohn Muir invalidate_inode_pages2_range(inode->i_mapping, 4493b463ae0SJohn Muir pg_start, pg_end); 4503b463ae0SJohn Muir } 4513b463ae0SJohn Muir iput(inode); 4523b463ae0SJohn Muir return 0; 4533b463ae0SJohn Muir } 4543b463ae0SJohn Muir 45563576c13SMiklos Szeredi bool fuse_lock_inode(struct inode *inode) 4565c672ab3SMiklos Szeredi { 45763576c13SMiklos Szeredi bool locked = false; 45863576c13SMiklos Szeredi 45963576c13SMiklos Szeredi if (!get_fuse_conn(inode)->parallel_dirops) { 4605c672ab3SMiklos Szeredi mutex_lock(&get_fuse_inode(inode)->mutex); 46163576c13SMiklos Szeredi locked = true; 4625c672ab3SMiklos Szeredi } 4635c672ab3SMiklos Szeredi 46463576c13SMiklos Szeredi return locked; 46563576c13SMiklos Szeredi } 46663576c13SMiklos Szeredi 46763576c13SMiklos Szeredi void fuse_unlock_inode(struct inode *inode, bool locked) 4685c672ab3SMiklos Szeredi { 46963576c13SMiklos Szeredi if (locked) 4705c672ab3SMiklos Szeredi mutex_unlock(&get_fuse_inode(inode)->mutex); 4715c672ab3SMiklos Szeredi } 4725c672ab3SMiklos Szeredi 47342faad99SAl Viro static void fuse_umount_begin(struct super_block *sb) 47469a53bf2SMiklos Szeredi { 47515c8e72eSVivek Goyal struct fuse_conn *fc = get_fuse_conn_super(sb); 47615c8e72eSVivek Goyal 47715c8e72eSVivek Goyal if (!fc->no_force_umount) 47815c8e72eSVivek Goyal fuse_abort_conn(fc); 47969a53bf2SMiklos Szeredi } 48069a53bf2SMiklos Szeredi 481fcee216bSMax Reitz static void fuse_send_destroy(struct fuse_mount *fm) 4820ec7ca41SMiklos Szeredi { 483fcee216bSMax Reitz if (fm->fc->conn_init) { 4841ccd1ea2SMiklos Szeredi FUSE_ARGS(args); 4851ccd1ea2SMiklos Szeredi 4861ccd1ea2SMiklos Szeredi args.opcode = FUSE_DESTROY; 4871ccd1ea2SMiklos Szeredi args.force = true; 4881ccd1ea2SMiklos Szeredi args.nocreds = true; 489fcee216bSMax Reitz fuse_simple_request(fm, &args); 4900ec7ca41SMiklos Szeredi } 4910ec7ca41SMiklos Szeredi } 4920ec7ca41SMiklos Szeredi 493e5e5558eSMiklos Szeredi static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr) 494e5e5558eSMiklos Szeredi { 495e5e5558eSMiklos Szeredi stbuf->f_type = FUSE_SUPER_MAGIC; 496e5e5558eSMiklos Szeredi stbuf->f_bsize = attr->bsize; 497de5f1202SMiklos Szeredi stbuf->f_frsize = attr->frsize; 498e5e5558eSMiklos Szeredi stbuf->f_blocks = attr->blocks; 499e5e5558eSMiklos Szeredi stbuf->f_bfree = attr->bfree; 500e5e5558eSMiklos Szeredi stbuf->f_bavail = attr->bavail; 501e5e5558eSMiklos Szeredi stbuf->f_files = attr->files; 502e5e5558eSMiklos Szeredi stbuf->f_ffree = attr->ffree; 503e5e5558eSMiklos Szeredi stbuf->f_namelen = attr->namelen; 504e5e5558eSMiklos Szeredi /* fsid is left zero */ 505e5e5558eSMiklos Szeredi } 506e5e5558eSMiklos Szeredi 507726c3342SDavid Howells static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf) 508e5e5558eSMiklos Szeredi { 509726c3342SDavid Howells struct super_block *sb = dentry->d_sb; 510fcee216bSMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 5117078187aSMiklos Szeredi FUSE_ARGS(args); 512e5e5558eSMiklos Szeredi struct fuse_statfs_out outarg; 513e5e5558eSMiklos Szeredi int err; 514e5e5558eSMiklos Szeredi 515fcee216bSMax Reitz if (!fuse_allow_current_process(fm->fc)) { 516e57ac683SMiklos Szeredi buf->f_type = FUSE_SUPER_MAGIC; 517e57ac683SMiklos Szeredi return 0; 518e57ac683SMiklos Szeredi } 519e57ac683SMiklos Szeredi 520de5f1202SMiklos Szeredi memset(&outarg, 0, sizeof(outarg)); 521d5b48543SMiklos Szeredi args.in_numargs = 0; 522d5b48543SMiklos Szeredi args.opcode = FUSE_STATFS; 523d5b48543SMiklos Szeredi args.nodeid = get_node_id(d_inode(dentry)); 524d5b48543SMiklos Szeredi args.out_numargs = 1; 525d5b48543SMiklos Szeredi args.out_args[0].size = sizeof(outarg); 526d5b48543SMiklos Szeredi args.out_args[0].value = &outarg; 527fcee216bSMax Reitz err = fuse_simple_request(fm, &args); 528e5e5558eSMiklos Szeredi if (!err) 529e5e5558eSMiklos Szeredi convert_fuse_statfs(buf, &outarg.st); 530e5e5558eSMiklos Szeredi return err; 531e5e5558eSMiklos Szeredi } 532e5e5558eSMiklos Szeredi 533660585b5SMiklos Szeredi static struct fuse_sync_bucket *fuse_sync_bucket_alloc(void) 534660585b5SMiklos Szeredi { 535660585b5SMiklos Szeredi struct fuse_sync_bucket *bucket; 536660585b5SMiklos Szeredi 537660585b5SMiklos Szeredi bucket = kzalloc(sizeof(*bucket), GFP_KERNEL | __GFP_NOFAIL); 538660585b5SMiklos Szeredi if (bucket) { 539660585b5SMiklos Szeredi init_waitqueue_head(&bucket->waitq); 540660585b5SMiklos Szeredi /* Initial active count */ 541660585b5SMiklos Szeredi atomic_set(&bucket->count, 1); 542660585b5SMiklos Szeredi } 543660585b5SMiklos Szeredi return bucket; 544660585b5SMiklos Szeredi } 545660585b5SMiklos Szeredi 546660585b5SMiklos Szeredi static void fuse_sync_fs_writes(struct fuse_conn *fc) 547660585b5SMiklos Szeredi { 548660585b5SMiklos Szeredi struct fuse_sync_bucket *bucket, *new_bucket; 549660585b5SMiklos Szeredi int count; 550660585b5SMiklos Szeredi 551660585b5SMiklos Szeredi new_bucket = fuse_sync_bucket_alloc(); 552660585b5SMiklos Szeredi spin_lock(&fc->lock); 553660585b5SMiklos Szeredi bucket = rcu_dereference_protected(fc->curr_bucket, 1); 554660585b5SMiklos Szeredi count = atomic_read(&bucket->count); 555660585b5SMiklos Szeredi WARN_ON(count < 1); 556660585b5SMiklos Szeredi /* No outstanding writes? */ 557660585b5SMiklos Szeredi if (count == 1) { 558660585b5SMiklos Szeredi spin_unlock(&fc->lock); 559660585b5SMiklos Szeredi kfree(new_bucket); 560660585b5SMiklos Szeredi return; 561660585b5SMiklos Szeredi } 562660585b5SMiklos Szeredi 563660585b5SMiklos Szeredi /* 564660585b5SMiklos Szeredi * Completion of new bucket depends on completion of this bucket, so add 565660585b5SMiklos Szeredi * one more count. 566660585b5SMiklos Szeredi */ 567660585b5SMiklos Szeredi atomic_inc(&new_bucket->count); 568660585b5SMiklos Szeredi rcu_assign_pointer(fc->curr_bucket, new_bucket); 569660585b5SMiklos Szeredi spin_unlock(&fc->lock); 570660585b5SMiklos Szeredi /* 571660585b5SMiklos Szeredi * Drop initial active count. At this point if all writes in this and 572660585b5SMiklos Szeredi * ancestor buckets complete, the count will go to zero and this task 573660585b5SMiklos Szeredi * will be woken up. 574660585b5SMiklos Szeredi */ 575660585b5SMiklos Szeredi atomic_dec(&bucket->count); 576660585b5SMiklos Szeredi 577660585b5SMiklos Szeredi wait_event(bucket->waitq, atomic_read(&bucket->count) == 0); 578660585b5SMiklos Szeredi 579660585b5SMiklos Szeredi /* Drop temp count on descendant bucket */ 580660585b5SMiklos Szeredi fuse_sync_bucket_dec(new_bucket); 581660585b5SMiklos Szeredi kfree_rcu(bucket, rcu); 582660585b5SMiklos Szeredi } 583660585b5SMiklos Szeredi 5842d82ab25SGreg Kurz static int fuse_sync_fs(struct super_block *sb, int wait) 5852d82ab25SGreg Kurz { 5862d82ab25SGreg Kurz struct fuse_mount *fm = get_fuse_mount_super(sb); 5872d82ab25SGreg Kurz struct fuse_conn *fc = fm->fc; 5882d82ab25SGreg Kurz struct fuse_syncfs_in inarg; 5892d82ab25SGreg Kurz FUSE_ARGS(args); 5902d82ab25SGreg Kurz int err; 5912d82ab25SGreg Kurz 5922d82ab25SGreg Kurz /* 5932d82ab25SGreg Kurz * Userspace cannot handle the wait == 0 case. Avoid a 5942d82ab25SGreg Kurz * gratuitous roundtrip. 5952d82ab25SGreg Kurz */ 5962d82ab25SGreg Kurz if (!wait) 5972d82ab25SGreg Kurz return 0; 5982d82ab25SGreg Kurz 5992d82ab25SGreg Kurz /* The filesystem is being unmounted. Nothing to do. */ 6002d82ab25SGreg Kurz if (!sb->s_root) 6012d82ab25SGreg Kurz return 0; 6022d82ab25SGreg Kurz 6032d82ab25SGreg Kurz if (!fc->sync_fs) 6042d82ab25SGreg Kurz return 0; 6052d82ab25SGreg Kurz 606660585b5SMiklos Szeredi fuse_sync_fs_writes(fc); 607660585b5SMiklos Szeredi 6082d82ab25SGreg Kurz memset(&inarg, 0, sizeof(inarg)); 6092d82ab25SGreg Kurz args.in_numargs = 1; 6102d82ab25SGreg Kurz args.in_args[0].size = sizeof(inarg); 6112d82ab25SGreg Kurz args.in_args[0].value = &inarg; 6122d82ab25SGreg Kurz args.opcode = FUSE_SYNCFS; 6132d82ab25SGreg Kurz args.nodeid = get_node_id(sb->s_root->d_inode); 6142d82ab25SGreg Kurz args.out_numargs = 0; 6152d82ab25SGreg Kurz 6162d82ab25SGreg Kurz err = fuse_simple_request(fm, &args); 6172d82ab25SGreg Kurz if (err == -ENOSYS) { 6182d82ab25SGreg Kurz fc->sync_fs = 0; 6192d82ab25SGreg Kurz err = 0; 6202d82ab25SGreg Kurz } 6212d82ab25SGreg Kurz 6222d82ab25SGreg Kurz return err; 6232d82ab25SGreg Kurz } 6242d82ab25SGreg Kurz 625d8a5ba45SMiklos Szeredi enum { 626c30da2e9SDavid Howells OPT_SOURCE, 627c30da2e9SDavid Howells OPT_SUBTYPE, 628d8a5ba45SMiklos Szeredi OPT_FD, 629d8a5ba45SMiklos Szeredi OPT_ROOTMODE, 630d8a5ba45SMiklos Szeredi OPT_USER_ID, 63187729a55SMiklos Szeredi OPT_GROUP_ID, 632d8a5ba45SMiklos Szeredi OPT_DEFAULT_PERMISSIONS, 633d8a5ba45SMiklos Szeredi OPT_ALLOW_OTHER, 634db50b96cSMiklos Szeredi OPT_MAX_READ, 635d8091614SMiklos Szeredi OPT_BLKSIZE, 636d8a5ba45SMiklos Szeredi OPT_ERR 637d8a5ba45SMiklos Szeredi }; 638d8a5ba45SMiklos Szeredi 639d7167b14SAl Viro static const struct fs_parameter_spec fuse_fs_parameters[] = { 640c30da2e9SDavid Howells fsparam_string ("source", OPT_SOURCE), 641c30da2e9SDavid Howells fsparam_u32 ("fd", OPT_FD), 642c30da2e9SDavid Howells fsparam_u32oct ("rootmode", OPT_ROOTMODE), 643c30da2e9SDavid Howells fsparam_u32 ("user_id", OPT_USER_ID), 644c30da2e9SDavid Howells fsparam_u32 ("group_id", OPT_GROUP_ID), 645c30da2e9SDavid Howells fsparam_flag ("default_permissions", OPT_DEFAULT_PERMISSIONS), 646c30da2e9SDavid Howells fsparam_flag ("allow_other", OPT_ALLOW_OTHER), 647c30da2e9SDavid Howells fsparam_u32 ("max_read", OPT_MAX_READ), 648c30da2e9SDavid Howells fsparam_u32 ("blksize", OPT_BLKSIZE), 649c7eb6869SDavid Howells fsparam_string ("subtype", OPT_SUBTYPE), 650c30da2e9SDavid Howells {} 651d8a5ba45SMiklos Szeredi }; 652d8a5ba45SMiklos Szeredi 65384c21507SMiklos Szeredi static int fuse_parse_param(struct fs_context *fsc, struct fs_parameter *param) 654233a01faSMiklos Szeredi { 655c30da2e9SDavid Howells struct fs_parse_result result; 65684c21507SMiklos Szeredi struct fuse_fs_context *ctx = fsc->fs_private; 657c30da2e9SDavid Howells int opt; 658233a01faSMiklos Szeredi 65984c21507SMiklos Szeredi if (fsc->purpose == FS_CONTEXT_FOR_RECONFIGURE) { 660e8b20a47SMiklos Szeredi /* 661e8b20a47SMiklos Szeredi * Ignore options coming from mount(MS_REMOUNT) for backward 662e8b20a47SMiklos Szeredi * compatibility. 663e8b20a47SMiklos Szeredi */ 66484c21507SMiklos Szeredi if (fsc->oldapi) 665e8b20a47SMiklos Szeredi return 0; 666e8b20a47SMiklos Szeredi 66784c21507SMiklos Szeredi return invalfc(fsc, "No changes allowed in reconfigure"); 668b330966fSMiklos Szeredi } 669b330966fSMiklos Szeredi 67084c21507SMiklos Szeredi opt = fs_parse(fsc, fuse_fs_parameters, param, &result); 671c30da2e9SDavid Howells if (opt < 0) 672c30da2e9SDavid Howells return opt; 673d8a5ba45SMiklos Szeredi 674c30da2e9SDavid Howells switch (opt) { 675c30da2e9SDavid Howells case OPT_SOURCE: 67684c21507SMiklos Szeredi if (fsc->source) 67784c21507SMiklos Szeredi return invalfc(fsc, "Multiple sources specified"); 67884c21507SMiklos Szeredi fsc->source = param->string; 679c30da2e9SDavid Howells param->string = NULL; 680c30da2e9SDavid Howells break; 681d8a5ba45SMiklos Szeredi 682c30da2e9SDavid Howells case OPT_SUBTYPE: 683c30da2e9SDavid Howells if (ctx->subtype) 68484c21507SMiklos Szeredi return invalfc(fsc, "Multiple subtypes specified"); 685c30da2e9SDavid Howells ctx->subtype = param->string; 686c30da2e9SDavid Howells param->string = NULL; 687d8a5ba45SMiklos Szeredi return 0; 688c30da2e9SDavid Howells 689c30da2e9SDavid Howells case OPT_FD: 690c30da2e9SDavid Howells ctx->fd = result.uint_32; 691cabdb4faSzhengbin ctx->fd_present = true; 692d8a5ba45SMiklos Szeredi break; 693d8a5ba45SMiklos Szeredi 694d8a5ba45SMiklos Szeredi case OPT_ROOTMODE: 695c30da2e9SDavid Howells if (!fuse_valid_type(result.uint_32)) 69684c21507SMiklos Szeredi return invalfc(fsc, "Invalid rootmode"); 697c30da2e9SDavid Howells ctx->rootmode = result.uint_32; 698cabdb4faSzhengbin ctx->rootmode_present = true; 699d8a5ba45SMiklos Szeredi break; 700d8a5ba45SMiklos Szeredi 701d8a5ba45SMiklos Szeredi case OPT_USER_ID: 70284c21507SMiklos Szeredi ctx->user_id = make_kuid(fsc->user_ns, result.uint_32); 703c30da2e9SDavid Howells if (!uid_valid(ctx->user_id)) 70484c21507SMiklos Szeredi return invalfc(fsc, "Invalid user_id"); 705cabdb4faSzhengbin ctx->user_id_present = true; 706d8a5ba45SMiklos Szeredi break; 707d8a5ba45SMiklos Szeredi 70887729a55SMiklos Szeredi case OPT_GROUP_ID: 70984c21507SMiklos Szeredi ctx->group_id = make_kgid(fsc->user_ns, result.uint_32); 710c30da2e9SDavid Howells if (!gid_valid(ctx->group_id)) 71184c21507SMiklos Szeredi return invalfc(fsc, "Invalid group_id"); 712cabdb4faSzhengbin ctx->group_id_present = true; 71387729a55SMiklos Szeredi break; 71487729a55SMiklos Szeredi 7151e9a4ed9SMiklos Szeredi case OPT_DEFAULT_PERMISSIONS: 716cabdb4faSzhengbin ctx->default_permissions = true; 7171e9a4ed9SMiklos Szeredi break; 7181e9a4ed9SMiklos Szeredi 7191e9a4ed9SMiklos Szeredi case OPT_ALLOW_OTHER: 720cabdb4faSzhengbin ctx->allow_other = true; 7211e9a4ed9SMiklos Szeredi break; 7221e9a4ed9SMiklos Szeredi 723db50b96cSMiklos Szeredi case OPT_MAX_READ: 724c30da2e9SDavid Howells ctx->max_read = result.uint_32; 725db50b96cSMiklos Szeredi break; 726db50b96cSMiklos Szeredi 727d8091614SMiklos Szeredi case OPT_BLKSIZE: 728c30da2e9SDavid Howells if (!ctx->is_bdev) 72984c21507SMiklos Szeredi return invalfc(fsc, "blksize only supported for fuseblk"); 730c30da2e9SDavid Howells ctx->blksize = result.uint_32; 731d8091614SMiklos Szeredi break; 732d8091614SMiklos Szeredi 733d8a5ba45SMiklos Szeredi default: 734c30da2e9SDavid Howells return -EINVAL; 735d8a5ba45SMiklos Szeredi } 7365a533682SMiklos Szeredi 737d8a5ba45SMiklos Szeredi return 0; 738c30da2e9SDavid Howells } 739d8a5ba45SMiklos Szeredi 74084c21507SMiklos Szeredi static void fuse_free_fsc(struct fs_context *fsc) 741c30da2e9SDavid Howells { 74284c21507SMiklos Szeredi struct fuse_fs_context *ctx = fsc->fs_private; 743c30da2e9SDavid Howells 744c30da2e9SDavid Howells if (ctx) { 745c30da2e9SDavid Howells kfree(ctx->subtype); 746c30da2e9SDavid Howells kfree(ctx); 747c30da2e9SDavid Howells } 748d8a5ba45SMiklos Szeredi } 749d8a5ba45SMiklos Szeredi 75034c80b1dSAl Viro static int fuse_show_options(struct seq_file *m, struct dentry *root) 751d8a5ba45SMiklos Szeredi { 75234c80b1dSAl Viro struct super_block *sb = root->d_sb; 75334c80b1dSAl Viro struct fuse_conn *fc = get_fuse_conn_super(sb); 754d8a5ba45SMiklos Szeredi 755f4fd4ae3SVivek Goyal if (fc->legacy_opts_show) { 756f4fd4ae3SVivek Goyal seq_printf(m, ",user_id=%u", 757f4fd4ae3SVivek Goyal from_kuid_munged(fc->user_ns, fc->user_id)); 758f4fd4ae3SVivek Goyal seq_printf(m, ",group_id=%u", 759f4fd4ae3SVivek Goyal from_kgid_munged(fc->user_ns, fc->group_id)); 76029433a29SMiklos Szeredi if (fc->default_permissions) 7611e9a4ed9SMiklos Szeredi seq_puts(m, ",default_permissions"); 76229433a29SMiklos Szeredi if (fc->allow_other) 7631e9a4ed9SMiklos Szeredi seq_puts(m, ",allow_other"); 764db50b96cSMiklos Szeredi if (fc->max_read != ~0) 765db50b96cSMiklos Szeredi seq_printf(m, ",max_read=%u", fc->max_read); 76634c80b1dSAl Viro if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE) 76734c80b1dSAl Viro seq_printf(m, ",blksize=%lu", sb->s_blocksize); 768f4fd4ae3SVivek Goyal } 7691dd53957SVivek Goyal #ifdef CONFIG_FUSE_DAX 7701dd53957SVivek Goyal if (fc->dax) 7711dd53957SVivek Goyal seq_puts(m, ",dax"); 7721dd53957SVivek Goyal #endif 7731dd53957SVivek Goyal 774d8a5ba45SMiklos Szeredi return 0; 775d8a5ba45SMiklos Szeredi } 776d8a5ba45SMiklos Szeredi 777ae3aad77SStefan Hajnoczi static void fuse_iqueue_init(struct fuse_iqueue *fiq, 778ae3aad77SStefan Hajnoczi const struct fuse_iqueue_ops *ops, 779ae3aad77SStefan Hajnoczi void *priv) 780f88996a9SMiklos Szeredi { 781f88996a9SMiklos Szeredi memset(fiq, 0, sizeof(struct fuse_iqueue)); 78276e43c8cSEric Biggers spin_lock_init(&fiq->lock); 783f88996a9SMiklos Szeredi init_waitqueue_head(&fiq->waitq); 784f88996a9SMiklos Szeredi INIT_LIST_HEAD(&fiq->pending); 785f88996a9SMiklos Szeredi INIT_LIST_HEAD(&fiq->interrupts); 786f88996a9SMiklos Szeredi fiq->forget_list_tail = &fiq->forget_list_head; 787e16714d8SMiklos Szeredi fiq->connected = 1; 788ae3aad77SStefan Hajnoczi fiq->ops = ops; 789ae3aad77SStefan Hajnoczi fiq->priv = priv; 790f88996a9SMiklos Szeredi } 791f88996a9SMiklos Szeredi 7923a2b5b9cSMiklos Szeredi static void fuse_pqueue_init(struct fuse_pqueue *fpq) 7933a2b5b9cSMiklos Szeredi { 794be2ff42cSKirill Tkhai unsigned int i; 795be2ff42cSKirill Tkhai 79645a91cb1SMiklos Szeredi spin_lock_init(&fpq->lock); 797be2ff42cSKirill Tkhai for (i = 0; i < FUSE_PQ_HASH_SIZE; i++) 798be2ff42cSKirill Tkhai INIT_LIST_HEAD(&fpq->processing[i]); 7993a2b5b9cSMiklos Szeredi INIT_LIST_HEAD(&fpq->io); 800e96edd94SMiklos Szeredi fpq->connected = 1; 8013a2b5b9cSMiklos Szeredi } 8023a2b5b9cSMiklos Szeredi 803fcee216bSMax Reitz void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm, 804fcee216bSMax Reitz struct user_namespace *user_ns, 805ae3aad77SStefan Hajnoczi const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv) 806d8a5ba45SMiklos Szeredi { 8070d179aa5STejun Heo memset(fc, 0, sizeof(*fc)); 808d7133114SMiklos Szeredi spin_lock_init(&fc->lock); 809ae2dffa3SKirill Tkhai spin_lock_init(&fc->bg_lock); 8103b463ae0SJohn Muir init_rwsem(&fc->killsb); 811095fc40aSElena Reshetova refcount_set(&fc->count, 1); 812c3696046SMiklos Szeredi atomic_set(&fc->dev_count, 1); 81308a53cdcSMiklos Szeredi init_waitqueue_head(&fc->blocked_waitq); 814ae3aad77SStefan Hajnoczi fuse_iqueue_init(&fc->iq, fiq_ops, fiq_priv); 815d12def1bSMiklos Szeredi INIT_LIST_HEAD(&fc->bg_queue); 8160d179aa5STejun Heo INIT_LIST_HEAD(&fc->entry); 817cc080e9eSMiklos Szeredi INIT_LIST_HEAD(&fc->devices); 818095da6cbSMiklos Szeredi atomic_set(&fc->num_waiting, 0); 8197a6d3c8bSCsaba Henk fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND; 8207a6d3c8bSCsaba Henk fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD; 82175126f55SMiklos Szeredi atomic64_set(&fc->khctr, 0); 82295668a69STejun Heo fc->polled_files = RB_ROOT; 8230aada884SMaxim Patlasov fc->blocked = 0; 824796523fbSMaxim Patlasov fc->initialized = 0; 825e16714d8SMiklos Szeredi fc->connected = 1; 8264510d86fSKirill Tkhai atomic64_set(&fc->attr_version, 1); 8279c8ef561SMiklos Szeredi get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key)); 8280b6e9ea0SSeth Forshee fc->pid_ns = get_pid_ns(task_active_pid_ns(current)); 8298cb08329SEric W. Biederman fc->user_ns = get_user_ns(user_ns); 8308a3177dbSMiklos Szeredi fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ; 831a7f0d7aaSConnor Kuehl fc->max_pages_limit = FUSE_MAX_MAX_PAGES; 832fcee216bSMax Reitz 833fcee216bSMax Reitz INIT_LIST_HEAD(&fc->mounts); 834fcee216bSMax Reitz list_add(&fm->fc_entry, &fc->mounts); 835fcee216bSMax Reitz fm->fc = fc; 836d8a5ba45SMiklos Szeredi } 8370d179aa5STejun Heo EXPORT_SYMBOL_GPL(fuse_conn_init); 838d8a5ba45SMiklos Szeredi 839bafa9654SMiklos Szeredi void fuse_conn_put(struct fuse_conn *fc) 840bafa9654SMiklos Szeredi { 841095fc40aSElena Reshetova if (refcount_dec_and_test(&fc->count)) { 842a62a8ef9SStefan Hajnoczi struct fuse_iqueue *fiq = &fc->iq; 843660585b5SMiklos Szeredi struct fuse_sync_bucket *bucket; 844a62a8ef9SStefan Hajnoczi 8451dd53957SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX)) 8461dd53957SVivek Goyal fuse_dax_conn_free(fc); 847a62a8ef9SStefan Hajnoczi if (fiq->ops->release) 848a62a8ef9SStefan Hajnoczi fiq->ops->release(fiq); 8490b6e9ea0SSeth Forshee put_pid_ns(fc->pid_ns); 8508cb08329SEric W. Biederman put_user_ns(fc->user_ns); 851660585b5SMiklos Szeredi bucket = rcu_dereference_protected(fc->curr_bucket, 1); 852660585b5SMiklos Szeredi if (bucket) { 853660585b5SMiklos Szeredi WARN_ON(atomic_read(&bucket->count) != 1); 854660585b5SMiklos Szeredi kfree(bucket); 855660585b5SMiklos Szeredi } 85643901aabSTejun Heo fc->release(fc); 857bafa9654SMiklos Szeredi } 858d2a85164SMiklos Szeredi } 85908cbf542STejun Heo EXPORT_SYMBOL_GPL(fuse_conn_put); 860bafa9654SMiklos Szeredi 861bafa9654SMiklos Szeredi struct fuse_conn *fuse_conn_get(struct fuse_conn *fc) 862bafa9654SMiklos Szeredi { 863095fc40aSElena Reshetova refcount_inc(&fc->count); 864bafa9654SMiklos Szeredi return fc; 865bafa9654SMiklos Szeredi } 86608cbf542STejun Heo EXPORT_SYMBOL_GPL(fuse_conn_get); 867bafa9654SMiklos Szeredi 868b93f858aSTejun Heo static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode) 869d8a5ba45SMiklos Szeredi { 870d8a5ba45SMiklos Szeredi struct fuse_attr attr; 871d8a5ba45SMiklos Szeredi memset(&attr, 0, sizeof(attr)); 872d8a5ba45SMiklos Szeredi 873d8a5ba45SMiklos Szeredi attr.mode = mode; 874d8a5ba45SMiklos Szeredi attr.ino = FUSE_ROOT_ID; 875074406faSMiklos Szeredi attr.nlink = 1; 8761fb69e78SMiklos Szeredi return fuse_iget(sb, 1, 0, &attr, 0, 0); 877d8a5ba45SMiklos Szeredi } 878d8a5ba45SMiklos Szeredi 8791729a16cSMiklos Szeredi struct fuse_inode_handle { 880dbd561d2SMiklos Szeredi u64 nodeid; 881dbd561d2SMiklos Szeredi u32 generation; 882dbd561d2SMiklos Szeredi }; 883dbd561d2SMiklos Szeredi 884dbd561d2SMiklos Szeredi static struct dentry *fuse_get_dentry(struct super_block *sb, 885dbd561d2SMiklos Szeredi struct fuse_inode_handle *handle) 886dbd561d2SMiklos Szeredi { 88733670fa2SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn_super(sb); 888dbd561d2SMiklos Szeredi struct inode *inode; 889dbd561d2SMiklos Szeredi struct dentry *entry; 890dbd561d2SMiklos Szeredi int err = -ESTALE; 891dbd561d2SMiklos Szeredi 892dbd561d2SMiklos Szeredi if (handle->nodeid == 0) 893dbd561d2SMiklos Szeredi goto out_err; 894dbd561d2SMiklos Szeredi 895dbd561d2SMiklos Szeredi inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid); 89633670fa2SMiklos Szeredi if (!inode) { 89733670fa2SMiklos Szeredi struct fuse_entry_out outarg; 89813983d06SAl Viro const struct qstr name = QSTR_INIT(".", 1); 89933670fa2SMiklos Szeredi 90033670fa2SMiklos Szeredi if (!fc->export_support) 901dbd561d2SMiklos Szeredi goto out_err; 90233670fa2SMiklos Szeredi 90333670fa2SMiklos Szeredi err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg, 90433670fa2SMiklos Szeredi &inode); 90533670fa2SMiklos Szeredi if (err && err != -ENOENT) 90633670fa2SMiklos Szeredi goto out_err; 90733670fa2SMiklos Szeredi if (err || !inode) { 90833670fa2SMiklos Szeredi err = -ESTALE; 90933670fa2SMiklos Szeredi goto out_err; 91033670fa2SMiklos Szeredi } 91133670fa2SMiklos Szeredi err = -EIO; 91233670fa2SMiklos Szeredi if (get_node_id(inode) != handle->nodeid) 91333670fa2SMiklos Szeredi goto out_iput; 91433670fa2SMiklos Szeredi } 915dbd561d2SMiklos Szeredi err = -ESTALE; 916dbd561d2SMiklos Szeredi if (inode->i_generation != handle->generation) 917dbd561d2SMiklos Szeredi goto out_iput; 918dbd561d2SMiklos Szeredi 91944003728SChristoph Hellwig entry = d_obtain_alias(inode); 920c35eebe9SAl Viro if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID) 921dbd561d2SMiklos Szeredi fuse_invalidate_entry_cache(entry); 922dbd561d2SMiklos Szeredi 923dbd561d2SMiklos Szeredi return entry; 924dbd561d2SMiklos Szeredi 925dbd561d2SMiklos Szeredi out_iput: 926dbd561d2SMiklos Szeredi iput(inode); 927dbd561d2SMiklos Szeredi out_err: 928dbd561d2SMiklos Szeredi return ERR_PTR(err); 929dbd561d2SMiklos Szeredi } 930dbd561d2SMiklos Szeredi 931b0b0382bSAl Viro static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len, 932b0b0382bSAl Viro struct inode *parent) 933dbd561d2SMiklos Szeredi { 934b0b0382bSAl Viro int len = parent ? 6 : 3; 935dbd561d2SMiklos Szeredi u64 nodeid; 936dbd561d2SMiklos Szeredi u32 generation; 937dbd561d2SMiklos Szeredi 9385fe0c237SAneesh Kumar K.V if (*max_len < len) { 9395fe0c237SAneesh Kumar K.V *max_len = len; 94094e07a75SNamjae Jeon return FILEID_INVALID; 9415fe0c237SAneesh Kumar K.V } 942dbd561d2SMiklos Szeredi 943dbd561d2SMiklos Szeredi nodeid = get_fuse_inode(inode)->nodeid; 944dbd561d2SMiklos Szeredi generation = inode->i_generation; 945dbd561d2SMiklos Szeredi 946dbd561d2SMiklos Szeredi fh[0] = (u32)(nodeid >> 32); 947dbd561d2SMiklos Szeredi fh[1] = (u32)(nodeid & 0xffffffff); 948dbd561d2SMiklos Szeredi fh[2] = generation; 949dbd561d2SMiklos Szeredi 950b0b0382bSAl Viro if (parent) { 951dbd561d2SMiklos Szeredi nodeid = get_fuse_inode(parent)->nodeid; 952dbd561d2SMiklos Szeredi generation = parent->i_generation; 953dbd561d2SMiklos Szeredi 954dbd561d2SMiklos Szeredi fh[3] = (u32)(nodeid >> 32); 955dbd561d2SMiklos Szeredi fh[4] = (u32)(nodeid & 0xffffffff); 956dbd561d2SMiklos Szeredi fh[5] = generation; 957dbd561d2SMiklos Szeredi } 958dbd561d2SMiklos Szeredi 959dbd561d2SMiklos Szeredi *max_len = len; 960b0b0382bSAl Viro return parent ? 0x82 : 0x81; 961dbd561d2SMiklos Szeredi } 962dbd561d2SMiklos Szeredi 963dbd561d2SMiklos Szeredi static struct dentry *fuse_fh_to_dentry(struct super_block *sb, 964dbd561d2SMiklos Szeredi struct fid *fid, int fh_len, int fh_type) 965dbd561d2SMiklos Szeredi { 966dbd561d2SMiklos Szeredi struct fuse_inode_handle handle; 967dbd561d2SMiklos Szeredi 968dbd561d2SMiklos Szeredi if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3) 969dbd561d2SMiklos Szeredi return NULL; 970dbd561d2SMiklos Szeredi 971dbd561d2SMiklos Szeredi handle.nodeid = (u64) fid->raw[0] << 32; 972dbd561d2SMiklos Szeredi handle.nodeid |= (u64) fid->raw[1]; 973dbd561d2SMiklos Szeredi handle.generation = fid->raw[2]; 974dbd561d2SMiklos Szeredi return fuse_get_dentry(sb, &handle); 975dbd561d2SMiklos Szeredi } 976dbd561d2SMiklos Szeredi 977dbd561d2SMiklos Szeredi static struct dentry *fuse_fh_to_parent(struct super_block *sb, 978dbd561d2SMiklos Szeredi struct fid *fid, int fh_len, int fh_type) 979dbd561d2SMiklos Szeredi { 980dbd561d2SMiklos Szeredi struct fuse_inode_handle parent; 981dbd561d2SMiklos Szeredi 982dbd561d2SMiklos Szeredi if (fh_type != 0x82 || fh_len < 6) 983dbd561d2SMiklos Szeredi return NULL; 984dbd561d2SMiklos Szeredi 985dbd561d2SMiklos Szeredi parent.nodeid = (u64) fid->raw[3] << 32; 986dbd561d2SMiklos Szeredi parent.nodeid |= (u64) fid->raw[4]; 987dbd561d2SMiklos Szeredi parent.generation = fid->raw[5]; 988dbd561d2SMiklos Szeredi return fuse_get_dentry(sb, &parent); 989dbd561d2SMiklos Szeredi } 990dbd561d2SMiklos Szeredi 99133670fa2SMiklos Szeredi static struct dentry *fuse_get_parent(struct dentry *child) 99233670fa2SMiklos Szeredi { 9932b0143b5SDavid Howells struct inode *child_inode = d_inode(child); 99433670fa2SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn(child_inode); 99533670fa2SMiklos Szeredi struct inode *inode; 99633670fa2SMiklos Szeredi struct dentry *parent; 99733670fa2SMiklos Szeredi struct fuse_entry_out outarg; 99833670fa2SMiklos Szeredi int err; 99933670fa2SMiklos Szeredi 100033670fa2SMiklos Szeredi if (!fc->export_support) 100133670fa2SMiklos Szeredi return ERR_PTR(-ESTALE); 100233670fa2SMiklos Szeredi 100333670fa2SMiklos Szeredi err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode), 100480e5d1ffSAl Viro &dotdot_name, &outarg, &inode); 100544003728SChristoph Hellwig if (err) { 100644003728SChristoph Hellwig if (err == -ENOENT) 100733670fa2SMiklos Szeredi return ERR_PTR(-ESTALE); 100844003728SChristoph Hellwig return ERR_PTR(err); 100933670fa2SMiklos Szeredi } 101044003728SChristoph Hellwig 101144003728SChristoph Hellwig parent = d_obtain_alias(inode); 1012c35eebe9SAl Viro if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID) 101333670fa2SMiklos Szeredi fuse_invalidate_entry_cache(parent); 101433670fa2SMiklos Szeredi 101533670fa2SMiklos Szeredi return parent; 101633670fa2SMiklos Szeredi } 1017dbd561d2SMiklos Szeredi 1018dbd561d2SMiklos Szeredi static const struct export_operations fuse_export_operations = { 1019dbd561d2SMiklos Szeredi .fh_to_dentry = fuse_fh_to_dentry, 1020dbd561d2SMiklos Szeredi .fh_to_parent = fuse_fh_to_parent, 1021dbd561d2SMiklos Szeredi .encode_fh = fuse_encode_fh, 102233670fa2SMiklos Szeredi .get_parent = fuse_get_parent, 1023dbd561d2SMiklos Szeredi }; 1024dbd561d2SMiklos Szeredi 1025ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations fuse_super_operations = { 1026d8a5ba45SMiklos Szeredi .alloc_inode = fuse_alloc_inode, 10279baf28bbSAl Viro .free_inode = fuse_free_inode, 1028b57922d9SAl Viro .evict_inode = fuse_evict_inode, 10291e18bda8SMiklos Szeredi .write_inode = fuse_write_inode, 1030ead5f0b5SMiklos Szeredi .drop_inode = generic_delete_inode, 103169a53bf2SMiklos Szeredi .umount_begin = fuse_umount_begin, 1032e5e5558eSMiklos Szeredi .statfs = fuse_statfs, 10332d82ab25SGreg Kurz .sync_fs = fuse_sync_fs, 1034d8a5ba45SMiklos Szeredi .show_options = fuse_show_options, 1035d8a5ba45SMiklos Szeredi }; 1036d8a5ba45SMiklos Szeredi 1037487ea5afSCsaba Henk static void sanitize_global_limit(unsigned *limit) 1038487ea5afSCsaba Henk { 1039f22f812dSMiklos Szeredi /* 1040f22f812dSMiklos Szeredi * The default maximum number of async requests is calculated to consume 1041f22f812dSMiklos Szeredi * 1/2^13 of the total memory, assuming 392 bytes per request. 1042f22f812dSMiklos Szeredi */ 1043487ea5afSCsaba Henk if (*limit == 0) 1044f22f812dSMiklos Szeredi *limit = ((totalram_pages() << PAGE_SHIFT) >> 13) / 392; 1045487ea5afSCsaba Henk 1046487ea5afSCsaba Henk if (*limit >= 1 << 16) 1047487ea5afSCsaba Henk *limit = (1 << 16) - 1; 1048487ea5afSCsaba Henk } 1049487ea5afSCsaba Henk 1050e4dca7b7SKees Cook static int set_global_limit(const char *val, const struct kernel_param *kp) 1051487ea5afSCsaba Henk { 1052487ea5afSCsaba Henk int rv; 1053487ea5afSCsaba Henk 1054487ea5afSCsaba Henk rv = param_set_uint(val, kp); 1055487ea5afSCsaba Henk if (rv) 1056487ea5afSCsaba Henk return rv; 1057487ea5afSCsaba Henk 1058487ea5afSCsaba Henk sanitize_global_limit((unsigned *)kp->arg); 1059487ea5afSCsaba Henk 1060487ea5afSCsaba Henk return 0; 1061487ea5afSCsaba Henk } 1062487ea5afSCsaba Henk 1063487ea5afSCsaba Henk static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg) 1064487ea5afSCsaba Henk { 1065487ea5afSCsaba Henk int cap_sys_admin = capable(CAP_SYS_ADMIN); 1066487ea5afSCsaba Henk 1067487ea5afSCsaba Henk if (arg->minor < 13) 1068487ea5afSCsaba Henk return; 1069487ea5afSCsaba Henk 1070487ea5afSCsaba Henk sanitize_global_limit(&max_user_bgreq); 1071487ea5afSCsaba Henk sanitize_global_limit(&max_user_congthresh); 1072487ea5afSCsaba Henk 1073ae2dffa3SKirill Tkhai spin_lock(&fc->bg_lock); 1074487ea5afSCsaba Henk if (arg->max_background) { 1075487ea5afSCsaba Henk fc->max_background = arg->max_background; 1076487ea5afSCsaba Henk 1077487ea5afSCsaba Henk if (!cap_sys_admin && fc->max_background > max_user_bgreq) 1078487ea5afSCsaba Henk fc->max_background = max_user_bgreq; 1079487ea5afSCsaba Henk } 1080487ea5afSCsaba Henk if (arg->congestion_threshold) { 1081487ea5afSCsaba Henk fc->congestion_threshold = arg->congestion_threshold; 1082487ea5afSCsaba Henk 1083487ea5afSCsaba Henk if (!cap_sys_admin && 1084487ea5afSCsaba Henk fc->congestion_threshold > max_user_congthresh) 1085487ea5afSCsaba Henk fc->congestion_threshold = max_user_congthresh; 1086487ea5afSCsaba Henk } 1087ae2dffa3SKirill Tkhai spin_unlock(&fc->bg_lock); 1088487ea5afSCsaba Henk } 1089487ea5afSCsaba Henk 1090615047efSMiklos Szeredi struct fuse_init_args { 1091615047efSMiklos Szeredi struct fuse_args args; 1092615047efSMiklos Szeredi struct fuse_init_in in; 1093615047efSMiklos Szeredi struct fuse_init_out out; 1094615047efSMiklos Szeredi }; 10959b9a0469SMiklos Szeredi 1096fcee216bSMax Reitz static void process_init_reply(struct fuse_mount *fm, struct fuse_args *args, 1097615047efSMiklos Szeredi int error) 1098615047efSMiklos Szeredi { 1099fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1100615047efSMiklos Szeredi struct fuse_init_args *ia = container_of(args, typeof(*ia), args); 1101615047efSMiklos Szeredi struct fuse_init_out *arg = &ia->out; 1102fd1a1dc6SStefan Hajnoczi bool ok = true; 1103615047efSMiklos Szeredi 1104615047efSMiklos Szeredi if (error || arg->major != FUSE_KERNEL_VERSION) 1105fd1a1dc6SStefan Hajnoczi ok = false; 11069b9a0469SMiklos Szeredi else { 11079cd68455SMiklos Szeredi unsigned long ra_pages; 11089cd68455SMiklos Szeredi 1109487ea5afSCsaba Henk process_init_limits(fc, arg); 1110487ea5afSCsaba Henk 11119cd68455SMiklos Szeredi if (arg->minor >= 6) { 1112*53db2893SMiklos Szeredi u64 flags = arg->flags | (u64) arg->flags2 << 32; 1113*53db2893SMiklos Szeredi 111409cbfeafSKirill A. Shutemov ra_pages = arg->max_readahead / PAGE_SIZE; 1115*53db2893SMiklos Szeredi if (flags & FUSE_ASYNC_READ) 11169cd68455SMiklos Szeredi fc->async_read = 1; 1117*53db2893SMiklos Szeredi if (!(flags & FUSE_POSIX_LOCKS)) 111871421259SMiklos Szeredi fc->no_lock = 1; 111937fb3a30SMiklos Szeredi if (arg->minor >= 17) { 1120*53db2893SMiklos Szeredi if (!(flags & FUSE_FLOCK_LOCKS)) 112137fb3a30SMiklos Szeredi fc->no_flock = 1; 112224114504SMiklos Szeredi } else { 1123*53db2893SMiklos Szeredi if (!(flags & FUSE_POSIX_LOCKS)) 112424114504SMiklos Szeredi fc->no_flock = 1; 112537fb3a30SMiklos Szeredi } 1126*53db2893SMiklos Szeredi if (flags & FUSE_ATOMIC_O_TRUNC) 11276ff958edSMiklos Szeredi fc->atomic_o_trunc = 1; 112833670fa2SMiklos Szeredi if (arg->minor >= 9) { 112933670fa2SMiklos Szeredi /* LOOKUP has dependency on proto version */ 1130*53db2893SMiklos Szeredi if (flags & FUSE_EXPORT_SUPPORT) 113133670fa2SMiklos Szeredi fc->export_support = 1; 113233670fa2SMiklos Szeredi } 1133*53db2893SMiklos Szeredi if (flags & FUSE_BIG_WRITES) 113478bb6cb9SMiklos Szeredi fc->big_writes = 1; 1135*53db2893SMiklos Szeredi if (flags & FUSE_DONT_MASK) 1136e0a43ddcSMiklos Szeredi fc->dont_mask = 1; 1137*53db2893SMiklos Szeredi if (flags & FUSE_AUTO_INVAL_DATA) 113872d0d248SBrian Foster fc->auto_inval_data = 1; 1139*53db2893SMiklos Szeredi else if (flags & FUSE_EXPLICIT_INVAL_DATA) 1140ad2ba64dSKirill Smelkov fc->explicit_inval_data = 1; 1141*53db2893SMiklos Szeredi if (flags & FUSE_DO_READDIRPLUS) { 11420b05b183SAnand V. Avati fc->do_readdirplus = 1; 1143*53db2893SMiklos Szeredi if (flags & FUSE_READDIRPLUS_AUTO) 1144634734b6SEric Wong fc->readdirplus_auto = 1; 114528420dadSMiklos Szeredi } 1146*53db2893SMiklos Szeredi if (flags & FUSE_ASYNC_DIO) 114760b9df7aSMiklos Szeredi fc->async_dio = 1; 1148*53db2893SMiklos Szeredi if (flags & FUSE_WRITEBACK_CACHE) 11494d99ff8fSPavel Emelyanov fc->writeback_cache = 1; 1150*53db2893SMiklos Szeredi if (flags & FUSE_PARALLEL_DIROPS) 11515c672ab3SMiklos Szeredi fc->parallel_dirops = 1; 1152*53db2893SMiklos Szeredi if (flags & FUSE_HANDLE_KILLPRIV) 11535e940c1dSMiklos Szeredi fc->handle_killpriv = 1; 1154e27c9d38SMiklos Szeredi if (arg->time_gran && arg->time_gran <= 1000000000) 1155fcee216bSMax Reitz fm->sb->s_time_gran = arg->time_gran; 1156*53db2893SMiklos Szeredi if ((flags & FUSE_POSIX_ACL)) { 115729433a29SMiklos Szeredi fc->default_permissions = 1; 115860bcc88aSSeth Forshee fc->posix_acl = 1; 1159fcee216bSMax Reitz fm->sb->s_xattr = fuse_acl_xattr_handlers; 116060bcc88aSSeth Forshee } 1161*53db2893SMiklos Szeredi if (flags & FUSE_CACHE_SYMLINKS) 11625571f1e6SDan Schatzberg fc->cache_symlinks = 1; 1163*53db2893SMiklos Szeredi if (flags & FUSE_ABORT_ERROR) 11643b7008b2SSzymon Lukasz fc->abort_err = 1; 1165*53db2893SMiklos Szeredi if (flags & FUSE_MAX_PAGES) { 11665da784ccSConstantine Shulyupin fc->max_pages = 1167a7f0d7aaSConnor Kuehl min_t(unsigned int, fc->max_pages_limit, 11685da784ccSConstantine Shulyupin max_t(unsigned int, arg->max_pages, 1)); 11695da784ccSConstantine Shulyupin } 1170fd1a1dc6SStefan Hajnoczi if (IS_ENABLED(CONFIG_FUSE_DAX) && 1171*53db2893SMiklos Szeredi flags & FUSE_MAP_ALIGNMENT && 1172fd1a1dc6SStefan Hajnoczi !fuse_dax_check_alignment(fc, arg->map_alignment)) { 1173fd1a1dc6SStefan Hajnoczi ok = false; 1174fd1a1dc6SStefan Hajnoczi } 1175*53db2893SMiklos Szeredi if (flags & FUSE_HANDLE_KILLPRIV_V2) { 117663f9909fSVivek Goyal fc->handle_killpriv_v2 = 1; 11779d769e6aSVivek Goyal fm->sb->s_flags |= SB_NOSEC; 11789d769e6aSVivek Goyal } 1179*53db2893SMiklos Szeredi if (flags & FUSE_SETXATTR_EXT) 118052a4c95fSVivek Goyal fc->setxattr_ext = 1; 118171421259SMiklos Szeredi } else { 118209cbfeafSKirill A. Shutemov ra_pages = fc->max_read / PAGE_SIZE; 118371421259SMiklos Szeredi fc->no_lock = 1; 118437fb3a30SMiklos Szeredi fc->no_flock = 1; 118571421259SMiklos Szeredi } 11869cd68455SMiklos Szeredi 1187fcee216bSMax Reitz fm->sb->s_bdi->ra_pages = 1188fcee216bSMax Reitz min(fm->sb->s_bdi->ra_pages, ra_pages); 11899b9a0469SMiklos Szeredi fc->minor = arg->minor; 11909b9a0469SMiklos Szeredi fc->max_write = arg->minor < 5 ? 4096 : arg->max_write; 1191f948d564SMiklos Szeredi fc->max_write = max_t(unsigned, 4096, fc->max_write); 11920ec7ca41SMiklos Szeredi fc->conn_init = 1; 11939b9a0469SMiklos Szeredi } 1194615047efSMiklos Szeredi kfree(ia); 1195615047efSMiklos Szeredi 1196fd1a1dc6SStefan Hajnoczi if (!ok) { 1197fd1a1dc6SStefan Hajnoczi fc->conn_init = 0; 1198fd1a1dc6SStefan Hajnoczi fc->conn_error = 1; 1199fd1a1dc6SStefan Hajnoczi } 1200fd1a1dc6SStefan Hajnoczi 12019759bd51SMiklos Szeredi fuse_set_initialized(fc); 120208a53cdcSMiklos Szeredi wake_up_all(&fc->blocked_waitq); 12039b9a0469SMiklos Szeredi } 12049b9a0469SMiklos Szeredi 1205fcee216bSMax Reitz void fuse_send_init(struct fuse_mount *fm) 12069b9a0469SMiklos Szeredi { 1207615047efSMiklos Szeredi struct fuse_init_args *ia; 1208*53db2893SMiklos Szeredi u64 flags; 1209095da6cbSMiklos Szeredi 1210615047efSMiklos Szeredi ia = kzalloc(sizeof(*ia), GFP_KERNEL | __GFP_NOFAIL); 1211615047efSMiklos Szeredi 1212615047efSMiklos Szeredi ia->in.major = FUSE_KERNEL_VERSION; 1213615047efSMiklos Szeredi ia->in.minor = FUSE_KERNEL_MINOR_VERSION; 1214fcee216bSMax Reitz ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE; 1215*53db2893SMiklos Szeredi flags = 1216615047efSMiklos Szeredi FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC | 121737fb3a30SMiklos Szeredi FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK | 121869fe05c9SMiklos Szeredi FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ | 12199446385fSWei Fang FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA | 12204d99ff8fSPavel Emelyanov FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO | 12215c672ab3SMiklos Szeredi FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT | 12223b7008b2SSzymon Lukasz FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL | 1223d9a9ea94SChad Austin FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS | 122463f9909fSVivek Goyal FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA | 1225*53db2893SMiklos Szeredi FUSE_HANDLE_KILLPRIV_V2 | FUSE_SETXATTR_EXT | FUSE_INIT_EXT; 1226fd1a1dc6SStefan Hajnoczi #ifdef CONFIG_FUSE_DAX 1227fcee216bSMax Reitz if (fm->fc->dax) 1228*53db2893SMiklos Szeredi flags |= FUSE_MAP_ALIGNMENT; 1229fd1a1dc6SStefan Hajnoczi #endif 1230bf109c64SMax Reitz if (fm->fc->auto_submounts) 1231*53db2893SMiklos Szeredi flags |= FUSE_SUBMOUNTS; 1232*53db2893SMiklos Szeredi 1233*53db2893SMiklos Szeredi ia->in.flags = flags; 1234*53db2893SMiklos Szeredi ia->in.flags2 = flags >> 32; 1235bf109c64SMax Reitz 1236615047efSMiklos Szeredi ia->args.opcode = FUSE_INIT; 1237615047efSMiklos Szeredi ia->args.in_numargs = 1; 1238615047efSMiklos Szeredi ia->args.in_args[0].size = sizeof(ia->in); 1239615047efSMiklos Szeredi ia->args.in_args[0].value = &ia->in; 1240615047efSMiklos Szeredi ia->args.out_numargs = 1; 12413ad2f3fbSDaniel Mack /* Variable length argument used for backward compatibility 12429b9a0469SMiklos Szeredi with interface version < 7.5. Rest of init_out is zeroed 12439b9a0469SMiklos Szeredi by do_get_request(), so a short reply is not a problem */ 1244cabdb4faSzhengbin ia->args.out_argvar = true; 1245615047efSMiklos Szeredi ia->args.out_args[0].size = sizeof(ia->out); 1246615047efSMiklos Szeredi ia->args.out_args[0].value = &ia->out; 1247615047efSMiklos Szeredi ia->args.force = true; 1248615047efSMiklos Szeredi ia->args.nocreds = true; 1249615047efSMiklos Szeredi ia->args.end = process_init_reply; 1250615047efSMiklos Szeredi 1251fcee216bSMax Reitz if (fuse_simple_background(fm, &ia->args, GFP_KERNEL) != 0) 1252fcee216bSMax Reitz process_init_reply(fm, &ia->args, -ENOTCONN); 12539b9a0469SMiklos Szeredi } 125495a84cdbSVivek Goyal EXPORT_SYMBOL_GPL(fuse_send_init); 12559b9a0469SMiklos Szeredi 1256783863d6SMiklos Szeredi void fuse_free_conn(struct fuse_conn *fc) 125743901aabSTejun Heo { 1258cc080e9eSMiklos Szeredi WARN_ON(!list_empty(&fc->devices)); 1259dd3e2c55SAl Viro kfree_rcu(fc, rcu); 126043901aabSTejun Heo } 1261783863d6SMiklos Szeredi EXPORT_SYMBOL_GPL(fuse_free_conn); 126243901aabSTejun Heo 1263a325f9b9STejun Heo static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb) 1264a325f9b9STejun Heo { 1265a325f9b9STejun Heo int err; 12665f7f7543SJan Kara char *suffix = ""; 1267a325f9b9STejun Heo 126869c8ebf8SJan Kara if (sb->s_bdev) { 12695f7f7543SJan Kara suffix = "-fuseblk"; 127069c8ebf8SJan Kara /* 127169c8ebf8SJan Kara * sb->s_bdi points to blkdev's bdi however we want to redirect 127269c8ebf8SJan Kara * it to our private bdi... 127369c8ebf8SJan Kara */ 127469c8ebf8SJan Kara bdi_put(sb->s_bdi); 127569c8ebf8SJan Kara sb->s_bdi = &noop_backing_dev_info; 127669c8ebf8SJan Kara } 12775f7f7543SJan Kara err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev), 12785f7f7543SJan Kara MINOR(fc->dev), suffix); 1279a325f9b9STejun Heo if (err) 1280a325f9b9STejun Heo return err; 1281a325f9b9STejun Heo 12825f7f7543SJan Kara /* fuse does it's own writeback accounting */ 1283823423efSChristoph Hellwig sb->s_bdi->capabilities &= ~BDI_CAP_WRITEBACK_ACCT; 1284823423efSChristoph Hellwig sb->s_bdi->capabilities |= BDI_CAP_STRICTLIMIT; 12855f7f7543SJan Kara 1286a325f9b9STejun Heo /* 1287a325f9b9STejun Heo * For a single fuse filesystem use max 1% of dirty + 1288a325f9b9STejun Heo * writeback threshold. 1289a325f9b9STejun Heo * 1290a325f9b9STejun Heo * This gives about 1M of write buffer for memory maps on a 1291a325f9b9STejun Heo * machine with 1G and 10% dirty_ratio, which should be more 1292a325f9b9STejun Heo * than enough. 1293a325f9b9STejun Heo * 1294a325f9b9STejun Heo * Privileged users can raise it by writing to 1295a325f9b9STejun Heo * 1296a325f9b9STejun Heo * /sys/class/bdi/<bdi>/max_ratio 1297a325f9b9STejun Heo */ 12985f7f7543SJan Kara bdi_set_max_ratio(sb->s_bdi, 1); 1299a325f9b9STejun Heo 1300a325f9b9STejun Heo return 0; 1301a325f9b9STejun Heo } 1302a325f9b9STejun Heo 13030cd1eb9aSVivek Goyal struct fuse_dev *fuse_dev_alloc(void) 1304cc080e9eSMiklos Szeredi { 1305cc080e9eSMiklos Szeredi struct fuse_dev *fud; 1306be2ff42cSKirill Tkhai struct list_head *pq; 1307cc080e9eSMiklos Szeredi 1308cc080e9eSMiklos Szeredi fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL); 1309be2ff42cSKirill Tkhai if (!fud) 1310be2ff42cSKirill Tkhai return NULL; 1311be2ff42cSKirill Tkhai 1312be2ff42cSKirill Tkhai pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL); 1313be2ff42cSKirill Tkhai if (!pq) { 1314be2ff42cSKirill Tkhai kfree(fud); 1315be2ff42cSKirill Tkhai return NULL; 1316be2ff42cSKirill Tkhai } 1317be2ff42cSKirill Tkhai 1318be2ff42cSKirill Tkhai fud->pq.processing = pq; 1319c3696046SMiklos Szeredi fuse_pqueue_init(&fud->pq); 1320cc080e9eSMiklos Szeredi 1321cc080e9eSMiklos Szeredi return fud; 1322cc080e9eSMiklos Szeredi } 1323cc080e9eSMiklos Szeredi EXPORT_SYMBOL_GPL(fuse_dev_alloc); 1324cc080e9eSMiklos Szeredi 13250cd1eb9aSVivek Goyal void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc) 13260cd1eb9aSVivek Goyal { 13270cd1eb9aSVivek Goyal fud->fc = fuse_conn_get(fc); 13280cd1eb9aSVivek Goyal spin_lock(&fc->lock); 13290cd1eb9aSVivek Goyal list_add_tail(&fud->entry, &fc->devices); 13300cd1eb9aSVivek Goyal spin_unlock(&fc->lock); 13310cd1eb9aSVivek Goyal } 13320cd1eb9aSVivek Goyal EXPORT_SYMBOL_GPL(fuse_dev_install); 13330cd1eb9aSVivek Goyal 13340cd1eb9aSVivek Goyal struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc) 13350cd1eb9aSVivek Goyal { 13360cd1eb9aSVivek Goyal struct fuse_dev *fud; 13370cd1eb9aSVivek Goyal 13380cd1eb9aSVivek Goyal fud = fuse_dev_alloc(); 13390cd1eb9aSVivek Goyal if (!fud) 13400cd1eb9aSVivek Goyal return NULL; 13410cd1eb9aSVivek Goyal 13420cd1eb9aSVivek Goyal fuse_dev_install(fud, fc); 13430cd1eb9aSVivek Goyal return fud; 13440cd1eb9aSVivek Goyal } 13450cd1eb9aSVivek Goyal EXPORT_SYMBOL_GPL(fuse_dev_alloc_install); 13460cd1eb9aSVivek Goyal 1347cc080e9eSMiklos Szeredi void fuse_dev_free(struct fuse_dev *fud) 1348cc080e9eSMiklos Szeredi { 1349cc080e9eSMiklos Szeredi struct fuse_conn *fc = fud->fc; 1350cc080e9eSMiklos Szeredi 1351cc080e9eSMiklos Szeredi if (fc) { 1352cc080e9eSMiklos Szeredi spin_lock(&fc->lock); 1353cc080e9eSMiklos Szeredi list_del(&fud->entry); 1354cc080e9eSMiklos Szeredi spin_unlock(&fc->lock); 1355cc080e9eSMiklos Szeredi 1356cc080e9eSMiklos Szeredi fuse_conn_put(fc); 1357cc080e9eSMiklos Szeredi } 1358d72f70daSTakeshi Misawa kfree(fud->pq.processing); 1359cc080e9eSMiklos Szeredi kfree(fud); 1360cc080e9eSMiklos Szeredi } 1361cc080e9eSMiklos Szeredi EXPORT_SYMBOL_GPL(fuse_dev_free); 1362cc080e9eSMiklos Szeredi 13631866d779SMax Reitz static void fuse_fill_attr_from_inode(struct fuse_attr *attr, 13641866d779SMax Reitz const struct fuse_inode *fi) 13651866d779SMax Reitz { 13661866d779SMax Reitz *attr = (struct fuse_attr){ 13671866d779SMax Reitz .ino = fi->inode.i_ino, 13681866d779SMax Reitz .size = fi->inode.i_size, 13691866d779SMax Reitz .blocks = fi->inode.i_blocks, 13701866d779SMax Reitz .atime = fi->inode.i_atime.tv_sec, 13711866d779SMax Reitz .mtime = fi->inode.i_mtime.tv_sec, 13721866d779SMax Reitz .ctime = fi->inode.i_ctime.tv_sec, 13731866d779SMax Reitz .atimensec = fi->inode.i_atime.tv_nsec, 13741866d779SMax Reitz .mtimensec = fi->inode.i_mtime.tv_nsec, 13751866d779SMax Reitz .ctimensec = fi->inode.i_ctime.tv_nsec, 13761866d779SMax Reitz .mode = fi->inode.i_mode, 13771866d779SMax Reitz .nlink = fi->inode.i_nlink, 13781866d779SMax Reitz .uid = fi->inode.i_uid.val, 13791866d779SMax Reitz .gid = fi->inode.i_gid.val, 13801866d779SMax Reitz .rdev = fi->inode.i_rdev, 13811866d779SMax Reitz .blksize = 1u << fi->inode.i_blkbits, 13821866d779SMax Reitz }; 13831866d779SMax Reitz } 13841866d779SMax Reitz 13851866d779SMax Reitz static void fuse_sb_defaults(struct super_block *sb) 13861866d779SMax Reitz { 13871866d779SMax Reitz sb->s_magic = FUSE_SUPER_MAGIC; 13881866d779SMax Reitz sb->s_op = &fuse_super_operations; 13891866d779SMax Reitz sb->s_xattr = fuse_xattr_handlers; 13901866d779SMax Reitz sb->s_maxbytes = MAX_LFS_FILESIZE; 13911866d779SMax Reitz sb->s_time_gran = 1; 13921866d779SMax Reitz sb->s_export_op = &fuse_export_operations; 13931866d779SMax Reitz sb->s_iflags |= SB_I_IMA_UNVERIFIABLE_SIGNATURE; 13941866d779SMax Reitz if (sb->s_user_ns != &init_user_ns) 13951866d779SMax Reitz sb->s_iflags |= SB_I_UNTRUSTED_MOUNTER; 13961866d779SMax Reitz sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION); 13971866d779SMax Reitz 13981866d779SMax Reitz /* 13991866d779SMax Reitz * If we are not in the initial user namespace posix 14001866d779SMax Reitz * acls must be translated. 14011866d779SMax Reitz */ 14021866d779SMax Reitz if (sb->s_user_ns != &init_user_ns) 14031866d779SMax Reitz sb->s_xattr = fuse_no_acl_xattr_handlers; 14041866d779SMax Reitz } 14051866d779SMax Reitz 14061b539917SGreg Kurz static int fuse_fill_super_submount(struct super_block *sb, 14071866d779SMax Reitz struct fuse_inode *parent_fi) 14081866d779SMax Reitz { 14091866d779SMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 14101866d779SMax Reitz struct super_block *parent_sb = parent_fi->inode.i_sb; 14111866d779SMax Reitz struct fuse_attr root_attr; 14121866d779SMax Reitz struct inode *root; 14131866d779SMax Reitz 14141866d779SMax Reitz fuse_sb_defaults(sb); 14151866d779SMax Reitz fm->sb = sb; 14161866d779SMax Reitz 14171866d779SMax Reitz WARN_ON(sb->s_bdi != &noop_backing_dev_info); 14181866d779SMax Reitz sb->s_bdi = bdi_get(parent_sb->s_bdi); 14191866d779SMax Reitz 14201866d779SMax Reitz sb->s_xattr = parent_sb->s_xattr; 14211866d779SMax Reitz sb->s_time_gran = parent_sb->s_time_gran; 14221866d779SMax Reitz sb->s_blocksize = parent_sb->s_blocksize; 14231866d779SMax Reitz sb->s_blocksize_bits = parent_sb->s_blocksize_bits; 14241866d779SMax Reitz sb->s_subtype = kstrdup(parent_sb->s_subtype, GFP_KERNEL); 14251866d779SMax Reitz if (parent_sb->s_subtype && !sb->s_subtype) 14261866d779SMax Reitz return -ENOMEM; 14271866d779SMax Reitz 14281866d779SMax Reitz fuse_fill_attr_from_inode(&root_attr, parent_fi); 14291866d779SMax Reitz root = fuse_iget(sb, parent_fi->nodeid, 0, &root_attr, 0, 0); 14301866d779SMax Reitz /* 14311866d779SMax Reitz * This inode is just a duplicate, so it is not looked up and 14321866d779SMax Reitz * its nlookup should not be incremented. fuse_iget() does 14331866d779SMax Reitz * that, though, so undo it here. 14341866d779SMax Reitz */ 14351866d779SMax Reitz get_fuse_inode(root)->nlookup--; 14361866d779SMax Reitz sb->s_d_op = &fuse_dentry_operations; 14371866d779SMax Reitz sb->s_root = d_make_root(root); 14381866d779SMax Reitz if (!sb->s_root) 14391866d779SMax Reitz return -ENOMEM; 14401866d779SMax Reitz 14411866d779SMax Reitz return 0; 14421866d779SMax Reitz } 14431866d779SMax Reitz 1444266eb3f2SGreg Kurz /* Filesystem context private data holds the FUSE inode of the mount point */ 1445fe0a7bd8SGreg Kurz static int fuse_get_tree_submount(struct fs_context *fsc) 1446fe0a7bd8SGreg Kurz { 1447266eb3f2SGreg Kurz struct fuse_mount *fm; 1448266eb3f2SGreg Kurz struct fuse_inode *mp_fi = fsc->fs_private; 1449266eb3f2SGreg Kurz struct fuse_conn *fc = get_fuse_conn(&mp_fi->inode); 1450266eb3f2SGreg Kurz struct super_block *sb; 1451266eb3f2SGreg Kurz int err; 1452266eb3f2SGreg Kurz 1453266eb3f2SGreg Kurz fm = kzalloc(sizeof(struct fuse_mount), GFP_KERNEL); 1454266eb3f2SGreg Kurz if (!fm) 1455266eb3f2SGreg Kurz return -ENOMEM; 1456266eb3f2SGreg Kurz 1457c191cd07SMiklos Szeredi fm->fc = fuse_conn_get(fc); 1458266eb3f2SGreg Kurz fsc->s_fs_info = fm; 1459266eb3f2SGreg Kurz sb = sget_fc(fsc, NULL, set_anon_super_fc); 1460c191cd07SMiklos Szeredi if (fsc->s_fs_info) 1461c191cd07SMiklos Szeredi fuse_mount_destroy(fm); 1462c191cd07SMiklos Szeredi if (IS_ERR(sb)) 1463266eb3f2SGreg Kurz return PTR_ERR(sb); 1464266eb3f2SGreg Kurz 1465266eb3f2SGreg Kurz /* Initialize superblock, making @mp_fi its root */ 1466266eb3f2SGreg Kurz err = fuse_fill_super_submount(sb, mp_fi); 1467266eb3f2SGreg Kurz if (err) { 1468266eb3f2SGreg Kurz deactivate_locked_super(sb); 1469266eb3f2SGreg Kurz return err; 1470266eb3f2SGreg Kurz } 1471266eb3f2SGreg Kurz 1472266eb3f2SGreg Kurz down_write(&fc->killsb); 1473266eb3f2SGreg Kurz list_add_tail(&fm->fc_entry, &fc->mounts); 1474266eb3f2SGreg Kurz up_write(&fc->killsb); 1475266eb3f2SGreg Kurz 1476266eb3f2SGreg Kurz sb->s_flags |= SB_ACTIVE; 1477266eb3f2SGreg Kurz fsc->root = dget(sb->s_root); 1478266eb3f2SGreg Kurz 1479fe0a7bd8SGreg Kurz return 0; 1480fe0a7bd8SGreg Kurz } 1481fe0a7bd8SGreg Kurz 1482fe0a7bd8SGreg Kurz static const struct fs_context_operations fuse_context_submount_ops = { 1483fe0a7bd8SGreg Kurz .get_tree = fuse_get_tree_submount, 1484fe0a7bd8SGreg Kurz }; 1485fe0a7bd8SGreg Kurz 1486fe0a7bd8SGreg Kurz int fuse_init_fs_context_submount(struct fs_context *fsc) 1487fe0a7bd8SGreg Kurz { 1488fe0a7bd8SGreg Kurz fsc->ops = &fuse_context_submount_ops; 1489fe0a7bd8SGreg Kurz return 0; 1490fe0a7bd8SGreg Kurz } 1491fe0a7bd8SGreg Kurz EXPORT_SYMBOL_GPL(fuse_init_fs_context_submount); 1492fe0a7bd8SGreg Kurz 14930cc2656cSStefan Hajnoczi int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx) 1494d8a5ba45SMiklos Szeredi { 14957fd3abfaSVivek Goyal struct fuse_dev *fud = NULL; 1496fcee216bSMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 1497fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1498d8a5ba45SMiklos Szeredi struct inode *root; 1499f543f253SMiklos Szeredi struct dentry *root_dentry; 1500d8a5ba45SMiklos Szeredi int err; 1501d8a5ba45SMiklos Szeredi 1502c2b8f006SMiklos Szeredi err = -EINVAL; 15031751e8a6SLinus Torvalds if (sb->s_flags & SB_MANDLOCK) 1504c2b8f006SMiklos Szeredi goto err; 150571421259SMiklos Szeredi 1506660585b5SMiklos Szeredi rcu_assign_pointer(fc->curr_bucket, fuse_sync_bucket_alloc()); 15071866d779SMax Reitz fuse_sb_defaults(sb); 15089e1f1de0SAl Viro 15090cc2656cSStefan Hajnoczi if (ctx->is_bdev) { 1510875d95ecSMiklos Szeredi #ifdef CONFIG_BLOCK 1511c2b8f006SMiklos Szeredi err = -EINVAL; 1512c30da2e9SDavid Howells if (!sb_set_blocksize(sb, ctx->blksize)) 1513c2b8f006SMiklos Szeredi goto err; 1514875d95ecSMiklos Szeredi #endif 1515d8091614SMiklos Szeredi } else { 151609cbfeafSKirill A. Shutemov sb->s_blocksize = PAGE_SIZE; 151709cbfeafSKirill A. Shutemov sb->s_blocksize_bits = PAGE_SHIFT; 1518d8091614SMiklos Szeredi } 1519c30da2e9SDavid Howells 1520c30da2e9SDavid Howells sb->s_subtype = ctx->subtype; 1521c30da2e9SDavid Howells ctx->subtype = NULL; 15221dd53957SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX)) { 15231dd53957SVivek Goyal err = fuse_dax_conn_alloc(fc, ctx->dax_dev); 15241dd53957SVivek Goyal if (err) 15251dd53957SVivek Goyal goto err; 15261dd53957SVivek Goyal } 1527e45b2546SEric W. Biederman 15287fd3abfaSVivek Goyal if (ctx->fudptr) { 15297fd3abfaSVivek Goyal err = -ENOMEM; 15300cd1eb9aSVivek Goyal fud = fuse_dev_alloc_install(fc); 1531cc080e9eSMiklos Szeredi if (!fud) 15321dd53957SVivek Goyal goto err_free_dax; 15337fd3abfaSVivek Goyal } 1534cc080e9eSMiklos Szeredi 1535a325f9b9STejun Heo fc->dev = sb->s_dev; 1536fcee216bSMax Reitz fm->sb = sb; 1537a325f9b9STejun Heo err = fuse_bdi_init(fc, sb); 1538a325f9b9STejun Heo if (err) 1539cc080e9eSMiklos Szeredi goto err_dev_free; 15400d179aa5STejun Heo 1541e0a43ddcSMiklos Szeredi /* Handle umasking inside the fuse code */ 15421751e8a6SLinus Torvalds if (sb->s_flags & SB_POSIXACL) 1543e0a43ddcSMiklos Szeredi fc->dont_mask = 1; 15441751e8a6SLinus Torvalds sb->s_flags |= SB_POSIXACL; 1545e0a43ddcSMiklos Szeredi 1546c30da2e9SDavid Howells fc->default_permissions = ctx->default_permissions; 1547c30da2e9SDavid Howells fc->allow_other = ctx->allow_other; 1548c30da2e9SDavid Howells fc->user_id = ctx->user_id; 1549c30da2e9SDavid Howells fc->group_id = ctx->group_id; 1550f4fd4ae3SVivek Goyal fc->legacy_opts_show = ctx->legacy_opts_show; 15511866d779SMax Reitz fc->max_read = max_t(unsigned int, 4096, ctx->max_read); 1552783863d6SMiklos Szeredi fc->destroy = ctx->destroy; 155315c8e72eSVivek Goyal fc->no_control = ctx->no_control; 155415c8e72eSVivek Goyal fc->no_force_umount = ctx->no_force_umount; 1555f543f253SMiklos Szeredi 1556d8a5ba45SMiklos Szeredi err = -ENOMEM; 1557c30da2e9SDavid Howells root = fuse_get_root_inode(sb, ctx->rootmode); 15580ce267ffSMiklos Szeredi sb->s_d_op = &fuse_root_dentry_operations; 155948fde701SAl Viro root_dentry = d_make_root(root); 156048fde701SAl Viro if (!root_dentry) 1561cc080e9eSMiklos Szeredi goto err_dev_free; 15620ce267ffSMiklos Szeredi /* Root dentry doesn't have .d_revalidate */ 1563c35eebe9SAl Viro sb->s_d_op = &fuse_dentry_operations; 1564f543f253SMiklos Szeredi 1565bafa9654SMiklos Szeredi mutex_lock(&fuse_mutex); 15668aa09a50SMiklos Szeredi err = -EINVAL; 15677fd3abfaSVivek Goyal if (ctx->fudptr && *ctx->fudptr) 1568bafa9654SMiklos Szeredi goto err_unlock; 15698aa09a50SMiklos Szeredi 1570bafa9654SMiklos Szeredi err = fuse_ctl_add_conn(fc); 1571bafa9654SMiklos Szeredi if (err) 1572bafa9654SMiklos Szeredi goto err_unlock; 1573bafa9654SMiklos Szeredi 1574bafa9654SMiklos Szeredi list_add_tail(&fc->entry, &fuse_conn_list); 1575f543f253SMiklos Szeredi sb->s_root = root_dentry; 15767fd3abfaSVivek Goyal if (ctx->fudptr) 15770cc2656cSStefan Hajnoczi *ctx->fudptr = fud; 1578bafa9654SMiklos Szeredi mutex_unlock(&fuse_mutex); 1579d8a5ba45SMiklos Szeredi return 0; 1580d8a5ba45SMiklos Szeredi 1581bafa9654SMiklos Szeredi err_unlock: 1582bafa9654SMiklos Szeredi mutex_unlock(&fuse_mutex); 1583f543f253SMiklos Szeredi dput(root_dentry); 1584cc080e9eSMiklos Szeredi err_dev_free: 15857fd3abfaSVivek Goyal if (fud) 1586cc080e9eSMiklos Szeredi fuse_dev_free(fud); 15871dd53957SVivek Goyal err_free_dax: 15881dd53957SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX)) 15891dd53957SVivek Goyal fuse_dax_conn_free(fc); 15900cc2656cSStefan Hajnoczi err: 15910cc2656cSStefan Hajnoczi return err; 15920cc2656cSStefan Hajnoczi } 15930cc2656cSStefan Hajnoczi EXPORT_SYMBOL_GPL(fuse_fill_super_common); 15940cc2656cSStefan Hajnoczi 15950cc2656cSStefan Hajnoczi static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc) 15960cc2656cSStefan Hajnoczi { 15970cc2656cSStefan Hajnoczi struct fuse_fs_context *ctx = fsc->fs_private; 15980cc2656cSStefan Hajnoczi int err; 15990cc2656cSStefan Hajnoczi 160062dd1fc8SMiklos Szeredi if (!ctx->file || !ctx->rootmode_present || 1601badc7414SMiklos Szeredi !ctx->user_id_present || !ctx->group_id_present) 1602badc7414SMiklos Szeredi return -EINVAL; 16030cc2656cSStefan Hajnoczi 16040cc2656cSStefan Hajnoczi /* 16050cc2656cSStefan Hajnoczi * Require mount to happen from the same user namespace which 16060cc2656cSStefan Hajnoczi * opened /dev/fuse to prevent potential attacks. 16070cc2656cSStefan Hajnoczi */ 160862dd1fc8SMiklos Szeredi if ((ctx->file->f_op != &fuse_dev_operations) || 160962dd1fc8SMiklos Szeredi (ctx->file->f_cred->user_ns != sb->s_user_ns)) 1610964d32e5SMiklos Szeredi return -EINVAL; 161162dd1fc8SMiklos Szeredi ctx->fudptr = &ctx->file->private_data; 16120cc2656cSStefan Hajnoczi 16130cc2656cSStefan Hajnoczi err = fuse_fill_super_common(sb, ctx); 16140cc2656cSStefan Hajnoczi if (err) 1615964d32e5SMiklos Szeredi return err; 161662dd1fc8SMiklos Szeredi /* file->private_data shall be visible on all CPUs after this */ 161762dd1fc8SMiklos Szeredi smp_mb(); 1618fcee216bSMax Reitz fuse_send_init(get_fuse_mount_super(sb)); 16190cc2656cSStefan Hajnoczi return 0; 1620d8a5ba45SMiklos Szeredi } 1621d8a5ba45SMiklos Szeredi 16225d5b74aaSMiklos Szeredi /* 16235d5b74aaSMiklos Szeredi * This is the path where user supplied an already initialized fuse dev. In 16245d5b74aaSMiklos Szeredi * this case never create a new super if the old one is gone. 16255d5b74aaSMiklos Szeredi */ 16265d5b74aaSMiklos Szeredi static int fuse_set_no_super(struct super_block *sb, struct fs_context *fsc) 1627d8a5ba45SMiklos Szeredi { 16285d5b74aaSMiklos Szeredi return -ENOTCONN; 16295d5b74aaSMiklos Szeredi } 1630c30da2e9SDavid Howells 16315d5b74aaSMiklos Szeredi static int fuse_test_super(struct super_block *sb, struct fs_context *fsc) 16325d5b74aaSMiklos Szeredi { 16335d5b74aaSMiklos Szeredi 16345d5b74aaSMiklos Szeredi return fsc->sget_key == get_fuse_conn_super(sb); 16355d5b74aaSMiklos Szeredi } 16365d5b74aaSMiklos Szeredi 163784c21507SMiklos Szeredi static int fuse_get_tree(struct fs_context *fsc) 1638d8a5ba45SMiklos Szeredi { 163984c21507SMiklos Szeredi struct fuse_fs_context *ctx = fsc->fs_private; 16405d5b74aaSMiklos Szeredi struct fuse_dev *fud; 164180019f11SMiklos Szeredi struct fuse_conn *fc; 164280019f11SMiklos Szeredi struct fuse_mount *fm; 16435d5b74aaSMiklos Szeredi struct super_block *sb; 164462dd1fc8SMiklos Szeredi int err; 164562dd1fc8SMiklos Szeredi 164680019f11SMiklos Szeredi fc = kmalloc(sizeof(*fc), GFP_KERNEL); 164780019f11SMiklos Szeredi if (!fc) 164880019f11SMiklos Szeredi return -ENOMEM; 164980019f11SMiklos Szeredi 165080019f11SMiklos Szeredi fm = kzalloc(sizeof(*fm), GFP_KERNEL); 165180019f11SMiklos Szeredi if (!fm) { 165280019f11SMiklos Szeredi kfree(fc); 165380019f11SMiklos Szeredi return -ENOMEM; 165480019f11SMiklos Szeredi } 165580019f11SMiklos Szeredi 165680019f11SMiklos Szeredi fuse_conn_init(fc, fm, fsc->user_ns, &fuse_dev_fiq_ops, NULL); 165780019f11SMiklos Szeredi fc->release = fuse_free_conn; 165880019f11SMiklos Szeredi 165980019f11SMiklos Szeredi fsc->s_fs_info = fm; 166080019f11SMiklos Szeredi 166162dd1fc8SMiklos Szeredi if (ctx->fd_present) 166262dd1fc8SMiklos Szeredi ctx->file = fget(ctx->fd); 1663c30da2e9SDavid Howells 1664badc7414SMiklos Szeredi if (IS_ENABLED(CONFIG_BLOCK) && ctx->is_bdev) { 166562dd1fc8SMiklos Szeredi err = get_tree_bdev(fsc, fuse_fill_super); 166680019f11SMiklos Szeredi goto out; 1667badc7414SMiklos Szeredi } 16685d5b74aaSMiklos Szeredi /* 16695d5b74aaSMiklos Szeredi * While block dev mount can be initialized with a dummy device fd 16705d5b74aaSMiklos Szeredi * (found by device name), normal fuse mounts can't 16715d5b74aaSMiklos Szeredi */ 167280019f11SMiklos Szeredi err = -EINVAL; 16735d5b74aaSMiklos Szeredi if (!ctx->file) 167480019f11SMiklos Szeredi goto out; 1675c30da2e9SDavid Howells 16765d5b74aaSMiklos Szeredi /* 16775d5b74aaSMiklos Szeredi * Allow creating a fuse mount with an already initialized fuse 16785d5b74aaSMiklos Szeredi * connection 16795d5b74aaSMiklos Szeredi */ 16805d5b74aaSMiklos Szeredi fud = READ_ONCE(ctx->file->private_data); 16815d5b74aaSMiklos Szeredi if (ctx->file->f_op == &fuse_dev_operations && fud) { 16825d5b74aaSMiklos Szeredi fsc->sget_key = fud->fc; 16835d5b74aaSMiklos Szeredi sb = sget_fc(fsc, fuse_test_super, fuse_set_no_super); 16845d5b74aaSMiklos Szeredi err = PTR_ERR_OR_ZERO(sb); 16855d5b74aaSMiklos Szeredi if (!IS_ERR(sb)) 16865d5b74aaSMiklos Szeredi fsc->root = dget(sb->s_root); 16875d5b74aaSMiklos Szeredi } else { 168862dd1fc8SMiklos Szeredi err = get_tree_nodev(fsc, fuse_fill_super); 16895d5b74aaSMiklos Szeredi } 169080019f11SMiklos Szeredi out: 169180019f11SMiklos Szeredi if (fsc->s_fs_info) 169280019f11SMiklos Szeredi fuse_mount_destroy(fm); 169362dd1fc8SMiklos Szeredi if (ctx->file) 169462dd1fc8SMiklos Szeredi fput(ctx->file); 169562dd1fc8SMiklos Szeredi return err; 1696c30da2e9SDavid Howells } 1697c30da2e9SDavid Howells 1698c30da2e9SDavid Howells static const struct fs_context_operations fuse_context_ops = { 169984c21507SMiklos Szeredi .free = fuse_free_fsc, 1700c30da2e9SDavid Howells .parse_param = fuse_parse_param, 17010189a2d3SMiklos Szeredi .reconfigure = fuse_reconfigure, 1702c30da2e9SDavid Howells .get_tree = fuse_get_tree, 1703c30da2e9SDavid Howells }; 1704c30da2e9SDavid Howells 1705c30da2e9SDavid Howells /* 1706c30da2e9SDavid Howells * Set up the filesystem mount context. 1707c30da2e9SDavid Howells */ 170884c21507SMiklos Szeredi static int fuse_init_fs_context(struct fs_context *fsc) 1709c30da2e9SDavid Howells { 1710c30da2e9SDavid Howells struct fuse_fs_context *ctx; 1711c30da2e9SDavid Howells 1712c30da2e9SDavid Howells ctx = kzalloc(sizeof(struct fuse_fs_context), GFP_KERNEL); 1713c30da2e9SDavid Howells if (!ctx) 1714c30da2e9SDavid Howells return -ENOMEM; 1715c30da2e9SDavid Howells 1716c30da2e9SDavid Howells ctx->max_read = ~0; 1717c30da2e9SDavid Howells ctx->blksize = FUSE_DEFAULT_BLKSIZE; 1718f4fd4ae3SVivek Goyal ctx->legacy_opts_show = true; 1719c30da2e9SDavid Howells 1720c30da2e9SDavid Howells #ifdef CONFIG_BLOCK 172184c21507SMiklos Szeredi if (fsc->fs_type == &fuseblk_fs_type) { 1722c30da2e9SDavid Howells ctx->is_bdev = true; 1723783863d6SMiklos Szeredi ctx->destroy = true; 1724783863d6SMiklos Szeredi } 1725c30da2e9SDavid Howells #endif 1726c30da2e9SDavid Howells 172784c21507SMiklos Szeredi fsc->fs_private = ctx; 172884c21507SMiklos Szeredi fsc->ops = &fuse_context_ops; 1729c30da2e9SDavid Howells return 0; 1730d8a5ba45SMiklos Szeredi } 1731d8a5ba45SMiklos Szeredi 1732fcee216bSMax Reitz bool fuse_mount_remove(struct fuse_mount *fm) 17333b463ae0SJohn Muir { 1734fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1735fcee216bSMax Reitz bool last = false; 17363b463ae0SJohn Muir 1737fcee216bSMax Reitz down_write(&fc->killsb); 1738fcee216bSMax Reitz list_del_init(&fm->fc_entry); 1739fcee216bSMax Reitz if (list_empty(&fc->mounts)) 1740fcee216bSMax Reitz last = true; 1741fcee216bSMax Reitz up_write(&fc->killsb); 1742fcee216bSMax Reitz 1743fcee216bSMax Reitz return last; 1744fcee216bSMax Reitz } 1745fcee216bSMax Reitz EXPORT_SYMBOL_GPL(fuse_mount_remove); 1746fcee216bSMax Reitz 1747fcee216bSMax Reitz void fuse_conn_destroy(struct fuse_mount *fm) 1748fcee216bSMax Reitz { 1749fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1750fcee216bSMax Reitz 17511ccd1ea2SMiklos Szeredi if (fc->destroy) 1752fcee216bSMax Reitz fuse_send_destroy(fm); 1753e8f3bd77SMiklos Szeredi 1754eb98e3bdSMiklos Szeredi fuse_abort_conn(fc); 1755e8f3bd77SMiklos Szeredi fuse_wait_aborted(fc); 1756e8f3bd77SMiklos Szeredi 1757413daa1aSMiklos Szeredi if (!list_empty(&fc->entry)) { 1758413daa1aSMiklos Szeredi mutex_lock(&fuse_mutex); 1759413daa1aSMiklos Szeredi list_del(&fc->entry); 1760413daa1aSMiklos Szeredi fuse_ctl_remove_conn(fc); 1761413daa1aSMiklos Szeredi mutex_unlock(&fuse_mutex); 17623b463ae0SJohn Muir } 1763e8f3bd77SMiklos Szeredi } 1764fcee216bSMax Reitz EXPORT_SYMBOL_GPL(fuse_conn_destroy); 17653b463ae0SJohn Muir 17666a68d1e1SMiklos Szeredi static void fuse_sb_destroy(struct super_block *sb) 1767e8f3bd77SMiklos Szeredi { 1768fcee216bSMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 1769fcee216bSMax Reitz bool last; 1770fcee216bSMax Reitz 1771d534d31dSMiklos Szeredi if (sb->s_root) { 1772fcee216bSMax Reitz last = fuse_mount_remove(fm); 1773fcee216bSMax Reitz if (last) 1774fcee216bSMax Reitz fuse_conn_destroy(fm); 1775fcee216bSMax Reitz } 17766a68d1e1SMiklos Szeredi } 17776a68d1e1SMiklos Szeredi 1778a27c061aSMiklos Szeredi void fuse_mount_destroy(struct fuse_mount *fm) 1779a27c061aSMiklos Szeredi { 1780a27c061aSMiklos Szeredi fuse_conn_put(fm->fc); 1781a27c061aSMiklos Szeredi kfree(fm); 1782a27c061aSMiklos Szeredi } 1783a27c061aSMiklos Szeredi EXPORT_SYMBOL(fuse_mount_destroy); 1784a27c061aSMiklos Szeredi 17856a68d1e1SMiklos Szeredi static void fuse_kill_sb_anon(struct super_block *sb) 17866a68d1e1SMiklos Szeredi { 17876a68d1e1SMiklos Szeredi fuse_sb_destroy(sb); 17883b463ae0SJohn Muir kill_anon_super(sb); 1789a27c061aSMiklos Szeredi fuse_mount_destroy(get_fuse_mount_super(sb)); 17903b463ae0SJohn Muir } 17913b463ae0SJohn Muir 1792875d95ecSMiklos Szeredi static struct file_system_type fuse_fs_type = { 1793875d95ecSMiklos Szeredi .owner = THIS_MODULE, 1794875d95ecSMiklos Szeredi .name = "fuse", 17954ad769f3SEric W. Biederman .fs_flags = FS_HAS_SUBTYPE | FS_USERNS_MOUNT, 1796c30da2e9SDavid Howells .init_fs_context = fuse_init_fs_context, 1797d7167b14SAl Viro .parameters = fuse_fs_parameters, 17983b463ae0SJohn Muir .kill_sb = fuse_kill_sb_anon, 1799875d95ecSMiklos Szeredi }; 18007f78e035SEric W. Biederman MODULE_ALIAS_FS("fuse"); 1801875d95ecSMiklos Szeredi 1802875d95ecSMiklos Szeredi #ifdef CONFIG_BLOCK 18033b463ae0SJohn Muir static void fuse_kill_sb_blk(struct super_block *sb) 18043b463ae0SJohn Muir { 18056a68d1e1SMiklos Szeredi fuse_sb_destroy(sb); 18063b463ae0SJohn Muir kill_block_super(sb); 1807a27c061aSMiklos Szeredi fuse_mount_destroy(get_fuse_mount_super(sb)); 18083b463ae0SJohn Muir } 18093b463ae0SJohn Muir 1810d6392f87SMiklos Szeredi static struct file_system_type fuseblk_fs_type = { 1811d6392f87SMiklos Szeredi .owner = THIS_MODULE, 1812d6392f87SMiklos Szeredi .name = "fuseblk", 1813c30da2e9SDavid Howells .init_fs_context = fuse_init_fs_context, 1814d7167b14SAl Viro .parameters = fuse_fs_parameters, 18153b463ae0SJohn Muir .kill_sb = fuse_kill_sb_blk, 1816edad01e2SAlexey Dobriyan .fs_flags = FS_REQUIRES_DEV | FS_HAS_SUBTYPE, 1817d6392f87SMiklos Szeredi }; 18187f78e035SEric W. Biederman MODULE_ALIAS_FS("fuseblk"); 1819d6392f87SMiklos Szeredi 1820875d95ecSMiklos Szeredi static inline int register_fuseblk(void) 1821875d95ecSMiklos Szeredi { 1822875d95ecSMiklos Szeredi return register_filesystem(&fuseblk_fs_type); 1823875d95ecSMiklos Szeredi } 1824875d95ecSMiklos Szeredi 1825875d95ecSMiklos Szeredi static inline void unregister_fuseblk(void) 1826875d95ecSMiklos Szeredi { 1827875d95ecSMiklos Szeredi unregister_filesystem(&fuseblk_fs_type); 1828875d95ecSMiklos Szeredi } 1829875d95ecSMiklos Szeredi #else 1830875d95ecSMiklos Szeredi static inline int register_fuseblk(void) 1831875d95ecSMiklos Szeredi { 1832875d95ecSMiklos Szeredi return 0; 1833875d95ecSMiklos Szeredi } 1834875d95ecSMiklos Szeredi 1835875d95ecSMiklos Szeredi static inline void unregister_fuseblk(void) 1836875d95ecSMiklos Szeredi { 1837875d95ecSMiklos Szeredi } 1838875d95ecSMiklos Szeredi #endif 1839875d95ecSMiklos Szeredi 184051cc5068SAlexey Dobriyan static void fuse_inode_init_once(void *foo) 1841d8a5ba45SMiklos Szeredi { 1842d8a5ba45SMiklos Szeredi struct inode *inode = foo; 1843d8a5ba45SMiklos Szeredi 1844d8a5ba45SMiklos Szeredi inode_init_once(inode); 1845d8a5ba45SMiklos Szeredi } 1846d8a5ba45SMiklos Szeredi 1847d8a5ba45SMiklos Szeredi static int __init fuse_fs_init(void) 1848d8a5ba45SMiklos Szeredi { 1849d8a5ba45SMiklos Szeredi int err; 1850d8a5ba45SMiklos Szeredi 1851d8a5ba45SMiklos Szeredi fuse_inode_cachep = kmem_cache_create("fuse_inode", 18525d097056SVladimir Davydov sizeof(struct fuse_inode), 0, 1853df206988SJohannes Weiner SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT|SLAB_RECLAIM_ACCOUNT, 185420c2df83SPaul Mundt fuse_inode_init_once); 1855d8a5ba45SMiklos Szeredi err = -ENOMEM; 1856d6392f87SMiklos Szeredi if (!fuse_inode_cachep) 1857988f0325SAl Viro goto out; 1858988f0325SAl Viro 1859988f0325SAl Viro err = register_fuseblk(); 1860988f0325SAl Viro if (err) 1861988f0325SAl Viro goto out2; 1862988f0325SAl Viro 1863988f0325SAl Viro err = register_filesystem(&fuse_fs_type); 1864988f0325SAl Viro if (err) 1865988f0325SAl Viro goto out3; 1866d8a5ba45SMiklos Szeredi 1867d6392f87SMiklos Szeredi return 0; 1868d6392f87SMiklos Szeredi 1869988f0325SAl Viro out3: 1870875d95ecSMiklos Szeredi unregister_fuseblk(); 1871988f0325SAl Viro out2: 1872988f0325SAl Viro kmem_cache_destroy(fuse_inode_cachep); 1873d6392f87SMiklos Szeredi out: 1874d8a5ba45SMiklos Szeredi return err; 1875d8a5ba45SMiklos Szeredi } 1876d8a5ba45SMiklos Szeredi 1877d8a5ba45SMiklos Szeredi static void fuse_fs_cleanup(void) 1878d8a5ba45SMiklos Szeredi { 1879d8a5ba45SMiklos Szeredi unregister_filesystem(&fuse_fs_type); 1880875d95ecSMiklos Szeredi unregister_fuseblk(); 18818c0a8537SKirill A. Shutemov 18828c0a8537SKirill A. Shutemov /* 18838c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we 18848c0a8537SKirill A. Shutemov * destroy cache. 18858c0a8537SKirill A. Shutemov */ 18868c0a8537SKirill A. Shutemov rcu_barrier(); 1887d8a5ba45SMiklos Szeredi kmem_cache_destroy(fuse_inode_cachep); 1888d8a5ba45SMiklos Szeredi } 1889d8a5ba45SMiklos Szeredi 18905c89e17eSGreg Kroah-Hartman static struct kobject *fuse_kobj; 18915c89e17eSGreg Kroah-Hartman 1892f543f253SMiklos Szeredi static int fuse_sysfs_init(void) 1893f543f253SMiklos Szeredi { 1894f543f253SMiklos Szeredi int err; 1895f543f253SMiklos Szeredi 189600d26666SGreg Kroah-Hartman fuse_kobj = kobject_create_and_add("fuse", fs_kobj); 18975c89e17eSGreg Kroah-Hartman if (!fuse_kobj) { 18985c89e17eSGreg Kroah-Hartman err = -ENOMEM; 1899f543f253SMiklos Szeredi goto out_err; 19005c89e17eSGreg Kroah-Hartman } 1901f543f253SMiklos Szeredi 1902f9bb4882SEric W. Biederman err = sysfs_create_mount_point(fuse_kobj, "connections"); 1903f9bb4882SEric W. Biederman if (err) 1904f543f253SMiklos Szeredi goto out_fuse_unregister; 1905f543f253SMiklos Szeredi 1906f543f253SMiklos Szeredi return 0; 1907f543f253SMiklos Szeredi 1908f543f253SMiklos Szeredi out_fuse_unregister: 1909197b12d6SGreg Kroah-Hartman kobject_put(fuse_kobj); 1910f543f253SMiklos Szeredi out_err: 1911f543f253SMiklos Szeredi return err; 1912f543f253SMiklos Szeredi } 1913f543f253SMiklos Szeredi 1914f543f253SMiklos Szeredi static void fuse_sysfs_cleanup(void) 1915f543f253SMiklos Szeredi { 1916f9bb4882SEric W. Biederman sysfs_remove_mount_point(fuse_kobj, "connections"); 1917197b12d6SGreg Kroah-Hartman kobject_put(fuse_kobj); 1918f543f253SMiklos Szeredi } 1919f543f253SMiklos Szeredi 1920d8a5ba45SMiklos Szeredi static int __init fuse_init(void) 1921d8a5ba45SMiklos Szeredi { 1922d8a5ba45SMiklos Szeredi int res; 1923d8a5ba45SMiklos Szeredi 1924f2294482SKirill Smelkov pr_info("init (API version %i.%i)\n", 1925d8a5ba45SMiklos Szeredi FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION); 1926d8a5ba45SMiklos Szeredi 1927bafa9654SMiklos Szeredi INIT_LIST_HEAD(&fuse_conn_list); 1928d8a5ba45SMiklos Szeredi res = fuse_fs_init(); 1929d8a5ba45SMiklos Szeredi if (res) 1930d8a5ba45SMiklos Szeredi goto err; 1931d8a5ba45SMiklos Szeredi 1932334f485dSMiklos Szeredi res = fuse_dev_init(); 1933334f485dSMiklos Szeredi if (res) 1934334f485dSMiklos Szeredi goto err_fs_cleanup; 1935334f485dSMiklos Szeredi 1936f543f253SMiklos Szeredi res = fuse_sysfs_init(); 1937f543f253SMiklos Szeredi if (res) 1938f543f253SMiklos Szeredi goto err_dev_cleanup; 1939f543f253SMiklos Szeredi 1940bafa9654SMiklos Szeredi res = fuse_ctl_init(); 1941bafa9654SMiklos Szeredi if (res) 1942bafa9654SMiklos Szeredi goto err_sysfs_cleanup; 1943bafa9654SMiklos Szeredi 1944487ea5afSCsaba Henk sanitize_global_limit(&max_user_bgreq); 1945487ea5afSCsaba Henk sanitize_global_limit(&max_user_congthresh); 1946487ea5afSCsaba Henk 1947d8a5ba45SMiklos Szeredi return 0; 1948d8a5ba45SMiklos Szeredi 1949bafa9654SMiklos Szeredi err_sysfs_cleanup: 1950bafa9654SMiklos Szeredi fuse_sysfs_cleanup(); 1951f543f253SMiklos Szeredi err_dev_cleanup: 1952f543f253SMiklos Szeredi fuse_dev_cleanup(); 1953334f485dSMiklos Szeredi err_fs_cleanup: 1954334f485dSMiklos Szeredi fuse_fs_cleanup(); 1955d8a5ba45SMiklos Szeredi err: 1956d8a5ba45SMiklos Szeredi return res; 1957d8a5ba45SMiklos Szeredi } 1958d8a5ba45SMiklos Szeredi 1959d8a5ba45SMiklos Szeredi static void __exit fuse_exit(void) 1960d8a5ba45SMiklos Szeredi { 1961f2294482SKirill Smelkov pr_debug("exit\n"); 1962d8a5ba45SMiklos Szeredi 1963bafa9654SMiklos Szeredi fuse_ctl_cleanup(); 1964f543f253SMiklos Szeredi fuse_sysfs_cleanup(); 1965d8a5ba45SMiklos Szeredi fuse_fs_cleanup(); 1966334f485dSMiklos Szeredi fuse_dev_cleanup(); 1967d8a5ba45SMiklos Szeredi } 1968d8a5ba45SMiklos Szeredi 1969d8a5ba45SMiklos Szeredi module_init(fuse_init); 1970d8a5ba45SMiklos Szeredi module_exit(fuse_exit); 1971