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); 31693a497b9SJeffle Xu fuse_init_file_inode(inode, attr->flags); 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 770780b1b95SJeffle Xu if (fc->dax_mode == FUSE_DAX_ALWAYS) 771780b1b95SJeffle Xu seq_puts(m, ",dax=always"); 772780b1b95SJeffle Xu else if (fc->dax_mode == FUSE_DAX_NEVER) 773780b1b95SJeffle Xu seq_puts(m, ",dax=never"); 774780b1b95SJeffle Xu else if (fc->dax_mode == FUSE_DAX_INODE_USER) 775780b1b95SJeffle Xu seq_puts(m, ",dax=inode"); 7761dd53957SVivek Goyal #endif 7771dd53957SVivek Goyal 778d8a5ba45SMiklos Szeredi return 0; 779d8a5ba45SMiklos Szeredi } 780d8a5ba45SMiklos Szeredi 781ae3aad77SStefan Hajnoczi static void fuse_iqueue_init(struct fuse_iqueue *fiq, 782ae3aad77SStefan Hajnoczi const struct fuse_iqueue_ops *ops, 783ae3aad77SStefan Hajnoczi void *priv) 784f88996a9SMiklos Szeredi { 785f88996a9SMiklos Szeredi memset(fiq, 0, sizeof(struct fuse_iqueue)); 78676e43c8cSEric Biggers spin_lock_init(&fiq->lock); 787f88996a9SMiklos Szeredi init_waitqueue_head(&fiq->waitq); 788f88996a9SMiklos Szeredi INIT_LIST_HEAD(&fiq->pending); 789f88996a9SMiklos Szeredi INIT_LIST_HEAD(&fiq->interrupts); 790f88996a9SMiklos Szeredi fiq->forget_list_tail = &fiq->forget_list_head; 791e16714d8SMiklos Szeredi fiq->connected = 1; 792ae3aad77SStefan Hajnoczi fiq->ops = ops; 793ae3aad77SStefan Hajnoczi fiq->priv = priv; 794f88996a9SMiklos Szeredi } 795f88996a9SMiklos Szeredi 7963a2b5b9cSMiklos Szeredi static void fuse_pqueue_init(struct fuse_pqueue *fpq) 7973a2b5b9cSMiklos Szeredi { 798be2ff42cSKirill Tkhai unsigned int i; 799be2ff42cSKirill Tkhai 80045a91cb1SMiklos Szeredi spin_lock_init(&fpq->lock); 801be2ff42cSKirill Tkhai for (i = 0; i < FUSE_PQ_HASH_SIZE; i++) 802be2ff42cSKirill Tkhai INIT_LIST_HEAD(&fpq->processing[i]); 8033a2b5b9cSMiklos Szeredi INIT_LIST_HEAD(&fpq->io); 804e96edd94SMiklos Szeredi fpq->connected = 1; 8053a2b5b9cSMiklos Szeredi } 8063a2b5b9cSMiklos Szeredi 807fcee216bSMax Reitz void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm, 808fcee216bSMax Reitz struct user_namespace *user_ns, 809ae3aad77SStefan Hajnoczi const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv) 810d8a5ba45SMiklos Szeredi { 8110d179aa5STejun Heo memset(fc, 0, sizeof(*fc)); 812d7133114SMiklos Szeredi spin_lock_init(&fc->lock); 813ae2dffa3SKirill Tkhai spin_lock_init(&fc->bg_lock); 8143b463ae0SJohn Muir init_rwsem(&fc->killsb); 815095fc40aSElena Reshetova refcount_set(&fc->count, 1); 816c3696046SMiklos Szeredi atomic_set(&fc->dev_count, 1); 81708a53cdcSMiklos Szeredi init_waitqueue_head(&fc->blocked_waitq); 818ae3aad77SStefan Hajnoczi fuse_iqueue_init(&fc->iq, fiq_ops, fiq_priv); 819d12def1bSMiklos Szeredi INIT_LIST_HEAD(&fc->bg_queue); 8200d179aa5STejun Heo INIT_LIST_HEAD(&fc->entry); 821cc080e9eSMiklos Szeredi INIT_LIST_HEAD(&fc->devices); 822095da6cbSMiklos Szeredi atomic_set(&fc->num_waiting, 0); 8237a6d3c8bSCsaba Henk fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND; 8247a6d3c8bSCsaba Henk fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD; 82575126f55SMiklos Szeredi atomic64_set(&fc->khctr, 0); 82695668a69STejun Heo fc->polled_files = RB_ROOT; 8270aada884SMaxim Patlasov fc->blocked = 0; 828796523fbSMaxim Patlasov fc->initialized = 0; 829e16714d8SMiklos Szeredi fc->connected = 1; 8304510d86fSKirill Tkhai atomic64_set(&fc->attr_version, 1); 8319c8ef561SMiklos Szeredi get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key)); 8320b6e9ea0SSeth Forshee fc->pid_ns = get_pid_ns(task_active_pid_ns(current)); 8338cb08329SEric W. Biederman fc->user_ns = get_user_ns(user_ns); 8348a3177dbSMiklos Szeredi fc->max_pages = FUSE_DEFAULT_MAX_PAGES_PER_REQ; 835a7f0d7aaSConnor Kuehl fc->max_pages_limit = FUSE_MAX_MAX_PAGES; 836fcee216bSMax Reitz 837fcee216bSMax Reitz INIT_LIST_HEAD(&fc->mounts); 838fcee216bSMax Reitz list_add(&fm->fc_entry, &fc->mounts); 839fcee216bSMax Reitz fm->fc = fc; 840d8a5ba45SMiklos Szeredi } 8410d179aa5STejun Heo EXPORT_SYMBOL_GPL(fuse_conn_init); 842d8a5ba45SMiklos Szeredi 843bafa9654SMiklos Szeredi void fuse_conn_put(struct fuse_conn *fc) 844bafa9654SMiklos Szeredi { 845095fc40aSElena Reshetova if (refcount_dec_and_test(&fc->count)) { 846a62a8ef9SStefan Hajnoczi struct fuse_iqueue *fiq = &fc->iq; 847660585b5SMiklos Szeredi struct fuse_sync_bucket *bucket; 848a62a8ef9SStefan Hajnoczi 8491dd53957SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX)) 8501dd53957SVivek Goyal fuse_dax_conn_free(fc); 851a62a8ef9SStefan Hajnoczi if (fiq->ops->release) 852a62a8ef9SStefan Hajnoczi fiq->ops->release(fiq); 8530b6e9ea0SSeth Forshee put_pid_ns(fc->pid_ns); 8548cb08329SEric W. Biederman put_user_ns(fc->user_ns); 855660585b5SMiklos Szeredi bucket = rcu_dereference_protected(fc->curr_bucket, 1); 856660585b5SMiklos Szeredi if (bucket) { 857660585b5SMiklos Szeredi WARN_ON(atomic_read(&bucket->count) != 1); 858660585b5SMiklos Szeredi kfree(bucket); 859660585b5SMiklos Szeredi } 86043901aabSTejun Heo fc->release(fc); 861bafa9654SMiklos Szeredi } 862d2a85164SMiklos Szeredi } 86308cbf542STejun Heo EXPORT_SYMBOL_GPL(fuse_conn_put); 864bafa9654SMiklos Szeredi 865bafa9654SMiklos Szeredi struct fuse_conn *fuse_conn_get(struct fuse_conn *fc) 866bafa9654SMiklos Szeredi { 867095fc40aSElena Reshetova refcount_inc(&fc->count); 868bafa9654SMiklos Szeredi return fc; 869bafa9654SMiklos Szeredi } 87008cbf542STejun Heo EXPORT_SYMBOL_GPL(fuse_conn_get); 871bafa9654SMiklos Szeredi 872b93f858aSTejun Heo static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode) 873d8a5ba45SMiklos Szeredi { 874d8a5ba45SMiklos Szeredi struct fuse_attr attr; 875d8a5ba45SMiklos Szeredi memset(&attr, 0, sizeof(attr)); 876d8a5ba45SMiklos Szeredi 877d8a5ba45SMiklos Szeredi attr.mode = mode; 878d8a5ba45SMiklos Szeredi attr.ino = FUSE_ROOT_ID; 879074406faSMiklos Szeredi attr.nlink = 1; 8801fb69e78SMiklos Szeredi return fuse_iget(sb, 1, 0, &attr, 0, 0); 881d8a5ba45SMiklos Szeredi } 882d8a5ba45SMiklos Szeredi 8831729a16cSMiklos Szeredi struct fuse_inode_handle { 884dbd561d2SMiklos Szeredi u64 nodeid; 885dbd561d2SMiklos Szeredi u32 generation; 886dbd561d2SMiklos Szeredi }; 887dbd561d2SMiklos Szeredi 888dbd561d2SMiklos Szeredi static struct dentry *fuse_get_dentry(struct super_block *sb, 889dbd561d2SMiklos Szeredi struct fuse_inode_handle *handle) 890dbd561d2SMiklos Szeredi { 89133670fa2SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn_super(sb); 892dbd561d2SMiklos Szeredi struct inode *inode; 893dbd561d2SMiklos Szeredi struct dentry *entry; 894dbd561d2SMiklos Szeredi int err = -ESTALE; 895dbd561d2SMiklos Szeredi 896dbd561d2SMiklos Szeredi if (handle->nodeid == 0) 897dbd561d2SMiklos Szeredi goto out_err; 898dbd561d2SMiklos Szeredi 899dbd561d2SMiklos Szeredi inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid); 90033670fa2SMiklos Szeredi if (!inode) { 90133670fa2SMiklos Szeredi struct fuse_entry_out outarg; 90213983d06SAl Viro const struct qstr name = QSTR_INIT(".", 1); 90333670fa2SMiklos Szeredi 90433670fa2SMiklos Szeredi if (!fc->export_support) 905dbd561d2SMiklos Szeredi goto out_err; 90633670fa2SMiklos Szeredi 90733670fa2SMiklos Szeredi err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg, 90833670fa2SMiklos Szeredi &inode); 90933670fa2SMiklos Szeredi if (err && err != -ENOENT) 91033670fa2SMiklos Szeredi goto out_err; 91133670fa2SMiklos Szeredi if (err || !inode) { 91233670fa2SMiklos Szeredi err = -ESTALE; 91333670fa2SMiklos Szeredi goto out_err; 91433670fa2SMiklos Szeredi } 91533670fa2SMiklos Szeredi err = -EIO; 91633670fa2SMiklos Szeredi if (get_node_id(inode) != handle->nodeid) 91733670fa2SMiklos Szeredi goto out_iput; 91833670fa2SMiklos Szeredi } 919dbd561d2SMiklos Szeredi err = -ESTALE; 920dbd561d2SMiklos Szeredi if (inode->i_generation != handle->generation) 921dbd561d2SMiklos Szeredi goto out_iput; 922dbd561d2SMiklos Szeredi 92344003728SChristoph Hellwig entry = d_obtain_alias(inode); 924c35eebe9SAl Viro if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID) 925dbd561d2SMiklos Szeredi fuse_invalidate_entry_cache(entry); 926dbd561d2SMiklos Szeredi 927dbd561d2SMiklos Szeredi return entry; 928dbd561d2SMiklos Szeredi 929dbd561d2SMiklos Szeredi out_iput: 930dbd561d2SMiklos Szeredi iput(inode); 931dbd561d2SMiklos Szeredi out_err: 932dbd561d2SMiklos Szeredi return ERR_PTR(err); 933dbd561d2SMiklos Szeredi } 934dbd561d2SMiklos Szeredi 935b0b0382bSAl Viro static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len, 936b0b0382bSAl Viro struct inode *parent) 937dbd561d2SMiklos Szeredi { 938b0b0382bSAl Viro int len = parent ? 6 : 3; 939dbd561d2SMiklos Szeredi u64 nodeid; 940dbd561d2SMiklos Szeredi u32 generation; 941dbd561d2SMiklos Szeredi 9425fe0c237SAneesh Kumar K.V if (*max_len < len) { 9435fe0c237SAneesh Kumar K.V *max_len = len; 94494e07a75SNamjae Jeon return FILEID_INVALID; 9455fe0c237SAneesh Kumar K.V } 946dbd561d2SMiklos Szeredi 947dbd561d2SMiklos Szeredi nodeid = get_fuse_inode(inode)->nodeid; 948dbd561d2SMiklos Szeredi generation = inode->i_generation; 949dbd561d2SMiklos Szeredi 950dbd561d2SMiklos Szeredi fh[0] = (u32)(nodeid >> 32); 951dbd561d2SMiklos Szeredi fh[1] = (u32)(nodeid & 0xffffffff); 952dbd561d2SMiklos Szeredi fh[2] = generation; 953dbd561d2SMiklos Szeredi 954b0b0382bSAl Viro if (parent) { 955dbd561d2SMiklos Szeredi nodeid = get_fuse_inode(parent)->nodeid; 956dbd561d2SMiklos Szeredi generation = parent->i_generation; 957dbd561d2SMiklos Szeredi 958dbd561d2SMiklos Szeredi fh[3] = (u32)(nodeid >> 32); 959dbd561d2SMiklos Szeredi fh[4] = (u32)(nodeid & 0xffffffff); 960dbd561d2SMiklos Szeredi fh[5] = generation; 961dbd561d2SMiklos Szeredi } 962dbd561d2SMiklos Szeredi 963dbd561d2SMiklos Szeredi *max_len = len; 964b0b0382bSAl Viro return parent ? 0x82 : 0x81; 965dbd561d2SMiklos Szeredi } 966dbd561d2SMiklos Szeredi 967dbd561d2SMiklos Szeredi static struct dentry *fuse_fh_to_dentry(struct super_block *sb, 968dbd561d2SMiklos Szeredi struct fid *fid, int fh_len, int fh_type) 969dbd561d2SMiklos Szeredi { 970dbd561d2SMiklos Szeredi struct fuse_inode_handle handle; 971dbd561d2SMiklos Szeredi 972dbd561d2SMiklos Szeredi if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3) 973dbd561d2SMiklos Szeredi return NULL; 974dbd561d2SMiklos Szeredi 975dbd561d2SMiklos Szeredi handle.nodeid = (u64) fid->raw[0] << 32; 976dbd561d2SMiklos Szeredi handle.nodeid |= (u64) fid->raw[1]; 977dbd561d2SMiklos Szeredi handle.generation = fid->raw[2]; 978dbd561d2SMiklos Szeredi return fuse_get_dentry(sb, &handle); 979dbd561d2SMiklos Szeredi } 980dbd561d2SMiklos Szeredi 981dbd561d2SMiklos Szeredi static struct dentry *fuse_fh_to_parent(struct super_block *sb, 982dbd561d2SMiklos Szeredi struct fid *fid, int fh_len, int fh_type) 983dbd561d2SMiklos Szeredi { 984dbd561d2SMiklos Szeredi struct fuse_inode_handle parent; 985dbd561d2SMiklos Szeredi 986dbd561d2SMiklos Szeredi if (fh_type != 0x82 || fh_len < 6) 987dbd561d2SMiklos Szeredi return NULL; 988dbd561d2SMiklos Szeredi 989dbd561d2SMiklos Szeredi parent.nodeid = (u64) fid->raw[3] << 32; 990dbd561d2SMiklos Szeredi parent.nodeid |= (u64) fid->raw[4]; 991dbd561d2SMiklos Szeredi parent.generation = fid->raw[5]; 992dbd561d2SMiklos Szeredi return fuse_get_dentry(sb, &parent); 993dbd561d2SMiklos Szeredi } 994dbd561d2SMiklos Szeredi 99533670fa2SMiklos Szeredi static struct dentry *fuse_get_parent(struct dentry *child) 99633670fa2SMiklos Szeredi { 9972b0143b5SDavid Howells struct inode *child_inode = d_inode(child); 99833670fa2SMiklos Szeredi struct fuse_conn *fc = get_fuse_conn(child_inode); 99933670fa2SMiklos Szeredi struct inode *inode; 100033670fa2SMiklos Szeredi struct dentry *parent; 100133670fa2SMiklos Szeredi struct fuse_entry_out outarg; 100233670fa2SMiklos Szeredi int err; 100333670fa2SMiklos Szeredi 100433670fa2SMiklos Szeredi if (!fc->export_support) 100533670fa2SMiklos Szeredi return ERR_PTR(-ESTALE); 100633670fa2SMiklos Szeredi 100733670fa2SMiklos Szeredi err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode), 100880e5d1ffSAl Viro &dotdot_name, &outarg, &inode); 100944003728SChristoph Hellwig if (err) { 101044003728SChristoph Hellwig if (err == -ENOENT) 101133670fa2SMiklos Szeredi return ERR_PTR(-ESTALE); 101244003728SChristoph Hellwig return ERR_PTR(err); 101333670fa2SMiklos Szeredi } 101444003728SChristoph Hellwig 101544003728SChristoph Hellwig parent = d_obtain_alias(inode); 1016c35eebe9SAl Viro if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID) 101733670fa2SMiklos Szeredi fuse_invalidate_entry_cache(parent); 101833670fa2SMiklos Szeredi 101933670fa2SMiklos Szeredi return parent; 102033670fa2SMiklos Szeredi } 1021dbd561d2SMiklos Szeredi 1022dbd561d2SMiklos Szeredi static const struct export_operations fuse_export_operations = { 1023dbd561d2SMiklos Szeredi .fh_to_dentry = fuse_fh_to_dentry, 1024dbd561d2SMiklos Szeredi .fh_to_parent = fuse_fh_to_parent, 1025dbd561d2SMiklos Szeredi .encode_fh = fuse_encode_fh, 102633670fa2SMiklos Szeredi .get_parent = fuse_get_parent, 1027dbd561d2SMiklos Szeredi }; 1028dbd561d2SMiklos Szeredi 1029ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations fuse_super_operations = { 1030d8a5ba45SMiklos Szeredi .alloc_inode = fuse_alloc_inode, 10319baf28bbSAl Viro .free_inode = fuse_free_inode, 1032b57922d9SAl Viro .evict_inode = fuse_evict_inode, 10331e18bda8SMiklos Szeredi .write_inode = fuse_write_inode, 1034ead5f0b5SMiklos Szeredi .drop_inode = generic_delete_inode, 103569a53bf2SMiklos Szeredi .umount_begin = fuse_umount_begin, 1036e5e5558eSMiklos Szeredi .statfs = fuse_statfs, 10372d82ab25SGreg Kurz .sync_fs = fuse_sync_fs, 1038d8a5ba45SMiklos Szeredi .show_options = fuse_show_options, 1039d8a5ba45SMiklos Szeredi }; 1040d8a5ba45SMiklos Szeredi 1041487ea5afSCsaba Henk static void sanitize_global_limit(unsigned *limit) 1042487ea5afSCsaba Henk { 1043f22f812dSMiklos Szeredi /* 1044f22f812dSMiklos Szeredi * The default maximum number of async requests is calculated to consume 1045f22f812dSMiklos Szeredi * 1/2^13 of the total memory, assuming 392 bytes per request. 1046f22f812dSMiklos Szeredi */ 1047487ea5afSCsaba Henk if (*limit == 0) 1048f22f812dSMiklos Szeredi *limit = ((totalram_pages() << PAGE_SHIFT) >> 13) / 392; 1049487ea5afSCsaba Henk 1050487ea5afSCsaba Henk if (*limit >= 1 << 16) 1051487ea5afSCsaba Henk *limit = (1 << 16) - 1; 1052487ea5afSCsaba Henk } 1053487ea5afSCsaba Henk 1054e4dca7b7SKees Cook static int set_global_limit(const char *val, const struct kernel_param *kp) 1055487ea5afSCsaba Henk { 1056487ea5afSCsaba Henk int rv; 1057487ea5afSCsaba Henk 1058487ea5afSCsaba Henk rv = param_set_uint(val, kp); 1059487ea5afSCsaba Henk if (rv) 1060487ea5afSCsaba Henk return rv; 1061487ea5afSCsaba Henk 1062487ea5afSCsaba Henk sanitize_global_limit((unsigned *)kp->arg); 1063487ea5afSCsaba Henk 1064487ea5afSCsaba Henk return 0; 1065487ea5afSCsaba Henk } 1066487ea5afSCsaba Henk 1067487ea5afSCsaba Henk static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg) 1068487ea5afSCsaba Henk { 1069487ea5afSCsaba Henk int cap_sys_admin = capable(CAP_SYS_ADMIN); 1070487ea5afSCsaba Henk 1071487ea5afSCsaba Henk if (arg->minor < 13) 1072487ea5afSCsaba Henk return; 1073487ea5afSCsaba Henk 1074487ea5afSCsaba Henk sanitize_global_limit(&max_user_bgreq); 1075487ea5afSCsaba Henk sanitize_global_limit(&max_user_congthresh); 1076487ea5afSCsaba Henk 1077ae2dffa3SKirill Tkhai spin_lock(&fc->bg_lock); 1078487ea5afSCsaba Henk if (arg->max_background) { 1079487ea5afSCsaba Henk fc->max_background = arg->max_background; 1080487ea5afSCsaba Henk 1081487ea5afSCsaba Henk if (!cap_sys_admin && fc->max_background > max_user_bgreq) 1082487ea5afSCsaba Henk fc->max_background = max_user_bgreq; 1083487ea5afSCsaba Henk } 1084487ea5afSCsaba Henk if (arg->congestion_threshold) { 1085487ea5afSCsaba Henk fc->congestion_threshold = arg->congestion_threshold; 1086487ea5afSCsaba Henk 1087487ea5afSCsaba Henk if (!cap_sys_admin && 1088487ea5afSCsaba Henk fc->congestion_threshold > max_user_congthresh) 1089487ea5afSCsaba Henk fc->congestion_threshold = max_user_congthresh; 1090487ea5afSCsaba Henk } 1091ae2dffa3SKirill Tkhai spin_unlock(&fc->bg_lock); 1092487ea5afSCsaba Henk } 1093487ea5afSCsaba Henk 1094615047efSMiklos Szeredi struct fuse_init_args { 1095615047efSMiklos Szeredi struct fuse_args args; 1096615047efSMiklos Szeredi struct fuse_init_in in; 1097615047efSMiklos Szeredi struct fuse_init_out out; 1098615047efSMiklos Szeredi }; 10999b9a0469SMiklos Szeredi 1100fcee216bSMax Reitz static void process_init_reply(struct fuse_mount *fm, struct fuse_args *args, 1101615047efSMiklos Szeredi int error) 1102615047efSMiklos Szeredi { 1103fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1104615047efSMiklos Szeredi struct fuse_init_args *ia = container_of(args, typeof(*ia), args); 1105615047efSMiklos Szeredi struct fuse_init_out *arg = &ia->out; 1106fd1a1dc6SStefan Hajnoczi bool ok = true; 1107615047efSMiklos Szeredi 1108615047efSMiklos Szeredi if (error || arg->major != FUSE_KERNEL_VERSION) 1109fd1a1dc6SStefan Hajnoczi ok = false; 11109b9a0469SMiklos Szeredi else { 11119cd68455SMiklos Szeredi unsigned long ra_pages; 11129cd68455SMiklos Szeredi 1113487ea5afSCsaba Henk process_init_limits(fc, arg); 1114487ea5afSCsaba Henk 11159cd68455SMiklos Szeredi if (arg->minor >= 6) { 111653db2893SMiklos Szeredi u64 flags = arg->flags | (u64) arg->flags2 << 32; 111753db2893SMiklos Szeredi 111809cbfeafSKirill A. Shutemov ra_pages = arg->max_readahead / PAGE_SIZE; 111953db2893SMiklos Szeredi if (flags & FUSE_ASYNC_READ) 11209cd68455SMiklos Szeredi fc->async_read = 1; 112153db2893SMiklos Szeredi if (!(flags & FUSE_POSIX_LOCKS)) 112271421259SMiklos Szeredi fc->no_lock = 1; 112337fb3a30SMiklos Szeredi if (arg->minor >= 17) { 112453db2893SMiklos Szeredi if (!(flags & FUSE_FLOCK_LOCKS)) 112537fb3a30SMiklos Szeredi fc->no_flock = 1; 112624114504SMiklos Szeredi } else { 112753db2893SMiklos Szeredi if (!(flags & FUSE_POSIX_LOCKS)) 112824114504SMiklos Szeredi fc->no_flock = 1; 112937fb3a30SMiklos Szeredi } 113053db2893SMiklos Szeredi if (flags & FUSE_ATOMIC_O_TRUNC) 11316ff958edSMiklos Szeredi fc->atomic_o_trunc = 1; 113233670fa2SMiklos Szeredi if (arg->minor >= 9) { 113333670fa2SMiklos Szeredi /* LOOKUP has dependency on proto version */ 113453db2893SMiklos Szeredi if (flags & FUSE_EXPORT_SUPPORT) 113533670fa2SMiklos Szeredi fc->export_support = 1; 113633670fa2SMiklos Szeredi } 113753db2893SMiklos Szeredi if (flags & FUSE_BIG_WRITES) 113878bb6cb9SMiklos Szeredi fc->big_writes = 1; 113953db2893SMiklos Szeredi if (flags & FUSE_DONT_MASK) 1140e0a43ddcSMiklos Szeredi fc->dont_mask = 1; 114153db2893SMiklos Szeredi if (flags & FUSE_AUTO_INVAL_DATA) 114272d0d248SBrian Foster fc->auto_inval_data = 1; 114353db2893SMiklos Szeredi else if (flags & FUSE_EXPLICIT_INVAL_DATA) 1144ad2ba64dSKirill Smelkov fc->explicit_inval_data = 1; 114553db2893SMiklos Szeredi if (flags & FUSE_DO_READDIRPLUS) { 11460b05b183SAnand V. Avati fc->do_readdirplus = 1; 114753db2893SMiklos Szeredi if (flags & FUSE_READDIRPLUS_AUTO) 1148634734b6SEric Wong fc->readdirplus_auto = 1; 114928420dadSMiklos Szeredi } 115053db2893SMiklos Szeredi if (flags & FUSE_ASYNC_DIO) 115160b9df7aSMiklos Szeredi fc->async_dio = 1; 115253db2893SMiklos Szeredi if (flags & FUSE_WRITEBACK_CACHE) 11534d99ff8fSPavel Emelyanov fc->writeback_cache = 1; 115453db2893SMiklos Szeredi if (flags & FUSE_PARALLEL_DIROPS) 11555c672ab3SMiklos Szeredi fc->parallel_dirops = 1; 115653db2893SMiklos Szeredi if (flags & FUSE_HANDLE_KILLPRIV) 11575e940c1dSMiklos Szeredi fc->handle_killpriv = 1; 1158e27c9d38SMiklos Szeredi if (arg->time_gran && arg->time_gran <= 1000000000) 1159fcee216bSMax Reitz fm->sb->s_time_gran = arg->time_gran; 116053db2893SMiklos Szeredi if ((flags & FUSE_POSIX_ACL)) { 116129433a29SMiklos Szeredi fc->default_permissions = 1; 116260bcc88aSSeth Forshee fc->posix_acl = 1; 1163fcee216bSMax Reitz fm->sb->s_xattr = fuse_acl_xattr_handlers; 116460bcc88aSSeth Forshee } 116553db2893SMiklos Szeredi if (flags & FUSE_CACHE_SYMLINKS) 11665571f1e6SDan Schatzberg fc->cache_symlinks = 1; 116753db2893SMiklos Szeredi if (flags & FUSE_ABORT_ERROR) 11683b7008b2SSzymon Lukasz fc->abort_err = 1; 116953db2893SMiklos Szeredi if (flags & FUSE_MAX_PAGES) { 11705da784ccSConstantine Shulyupin fc->max_pages = 1171a7f0d7aaSConnor Kuehl min_t(unsigned int, fc->max_pages_limit, 11725da784ccSConstantine Shulyupin max_t(unsigned int, arg->max_pages, 1)); 11735da784ccSConstantine Shulyupin } 1174*2ee019faSJeffle Xu if (IS_ENABLED(CONFIG_FUSE_DAX)) { 1175*2ee019faSJeffle Xu if (flags & FUSE_MAP_ALIGNMENT && 1176fd1a1dc6SStefan Hajnoczi !fuse_dax_check_alignment(fc, arg->map_alignment)) { 1177fd1a1dc6SStefan Hajnoczi ok = false; 1178fd1a1dc6SStefan Hajnoczi } 1179*2ee019faSJeffle Xu if (flags & FUSE_HAS_INODE_DAX) 1180*2ee019faSJeffle Xu fc->inode_dax = 1; 1181*2ee019faSJeffle Xu } 118253db2893SMiklos Szeredi if (flags & FUSE_HANDLE_KILLPRIV_V2) { 118363f9909fSVivek Goyal fc->handle_killpriv_v2 = 1; 11849d769e6aSVivek Goyal fm->sb->s_flags |= SB_NOSEC; 11859d769e6aSVivek Goyal } 118653db2893SMiklos Szeredi if (flags & FUSE_SETXATTR_EXT) 118752a4c95fSVivek Goyal fc->setxattr_ext = 1; 11883e2b6fdbSVivek Goyal if (flags & FUSE_SECURITY_CTX) 11893e2b6fdbSVivek Goyal fc->init_security = 1; 119071421259SMiklos Szeredi } else { 119109cbfeafSKirill A. Shutemov ra_pages = fc->max_read / PAGE_SIZE; 119271421259SMiklos Szeredi fc->no_lock = 1; 119337fb3a30SMiklos Szeredi fc->no_flock = 1; 119471421259SMiklos Szeredi } 11959cd68455SMiklos Szeredi 1196fcee216bSMax Reitz fm->sb->s_bdi->ra_pages = 1197fcee216bSMax Reitz min(fm->sb->s_bdi->ra_pages, ra_pages); 11989b9a0469SMiklos Szeredi fc->minor = arg->minor; 11999b9a0469SMiklos Szeredi fc->max_write = arg->minor < 5 ? 4096 : arg->max_write; 1200f948d564SMiklos Szeredi fc->max_write = max_t(unsigned, 4096, fc->max_write); 12010ec7ca41SMiklos Szeredi fc->conn_init = 1; 12029b9a0469SMiklos Szeredi } 1203615047efSMiklos Szeredi kfree(ia); 1204615047efSMiklos Szeredi 1205fd1a1dc6SStefan Hajnoczi if (!ok) { 1206fd1a1dc6SStefan Hajnoczi fc->conn_init = 0; 1207fd1a1dc6SStefan Hajnoczi fc->conn_error = 1; 1208fd1a1dc6SStefan Hajnoczi } 1209fd1a1dc6SStefan Hajnoczi 12109759bd51SMiklos Szeredi fuse_set_initialized(fc); 121108a53cdcSMiklos Szeredi wake_up_all(&fc->blocked_waitq); 12129b9a0469SMiklos Szeredi } 12139b9a0469SMiklos Szeredi 1214fcee216bSMax Reitz void fuse_send_init(struct fuse_mount *fm) 12159b9a0469SMiklos Szeredi { 1216615047efSMiklos Szeredi struct fuse_init_args *ia; 121753db2893SMiklos Szeredi u64 flags; 1218095da6cbSMiklos Szeredi 1219615047efSMiklos Szeredi ia = kzalloc(sizeof(*ia), GFP_KERNEL | __GFP_NOFAIL); 1220615047efSMiklos Szeredi 1221615047efSMiklos Szeredi ia->in.major = FUSE_KERNEL_VERSION; 1222615047efSMiklos Szeredi ia->in.minor = FUSE_KERNEL_MINOR_VERSION; 1223fcee216bSMax Reitz ia->in.max_readahead = fm->sb->s_bdi->ra_pages * PAGE_SIZE; 122453db2893SMiklos Szeredi flags = 1225615047efSMiklos Szeredi FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC | 122637fb3a30SMiklos Szeredi FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK | 122769fe05c9SMiklos Szeredi FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ | 12289446385fSWei Fang FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA | 12294d99ff8fSPavel Emelyanov FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO | 12305c672ab3SMiklos Szeredi FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT | 12313b7008b2SSzymon Lukasz FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL | 1232d9a9ea94SChad Austin FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS | 123363f9909fSVivek Goyal FUSE_NO_OPENDIR_SUPPORT | FUSE_EXPLICIT_INVAL_DATA | 12343e2b6fdbSVivek Goyal FUSE_HANDLE_KILLPRIV_V2 | FUSE_SETXATTR_EXT | FUSE_INIT_EXT | 12353e2b6fdbSVivek Goyal FUSE_SECURITY_CTX; 1236fd1a1dc6SStefan Hajnoczi #ifdef CONFIG_FUSE_DAX 1237fcee216bSMax Reitz if (fm->fc->dax) 123853db2893SMiklos Szeredi flags |= FUSE_MAP_ALIGNMENT; 1239*2ee019faSJeffle Xu if (fuse_is_inode_dax_mode(fm->fc->dax_mode)) 1240*2ee019faSJeffle Xu flags |= FUSE_HAS_INODE_DAX; 1241fd1a1dc6SStefan Hajnoczi #endif 1242bf109c64SMax Reitz if (fm->fc->auto_submounts) 124353db2893SMiklos Szeredi flags |= FUSE_SUBMOUNTS; 124453db2893SMiklos Szeredi 124553db2893SMiklos Szeredi ia->in.flags = flags; 124653db2893SMiklos Szeredi ia->in.flags2 = flags >> 32; 1247bf109c64SMax Reitz 1248615047efSMiklos Szeredi ia->args.opcode = FUSE_INIT; 1249615047efSMiklos Szeredi ia->args.in_numargs = 1; 1250615047efSMiklos Szeredi ia->args.in_args[0].size = sizeof(ia->in); 1251615047efSMiklos Szeredi ia->args.in_args[0].value = &ia->in; 1252615047efSMiklos Szeredi ia->args.out_numargs = 1; 12533ad2f3fbSDaniel Mack /* Variable length argument used for backward compatibility 12549b9a0469SMiklos Szeredi with interface version < 7.5. Rest of init_out is zeroed 12559b9a0469SMiklos Szeredi by do_get_request(), so a short reply is not a problem */ 1256cabdb4faSzhengbin ia->args.out_argvar = true; 1257615047efSMiklos Szeredi ia->args.out_args[0].size = sizeof(ia->out); 1258615047efSMiklos Szeredi ia->args.out_args[0].value = &ia->out; 1259615047efSMiklos Szeredi ia->args.force = true; 1260615047efSMiklos Szeredi ia->args.nocreds = true; 1261615047efSMiklos Szeredi ia->args.end = process_init_reply; 1262615047efSMiklos Szeredi 1263fcee216bSMax Reitz if (fuse_simple_background(fm, &ia->args, GFP_KERNEL) != 0) 1264fcee216bSMax Reitz process_init_reply(fm, &ia->args, -ENOTCONN); 12659b9a0469SMiklos Szeredi } 126695a84cdbSVivek Goyal EXPORT_SYMBOL_GPL(fuse_send_init); 12679b9a0469SMiklos Szeredi 1268783863d6SMiklos Szeredi void fuse_free_conn(struct fuse_conn *fc) 126943901aabSTejun Heo { 1270cc080e9eSMiklos Szeredi WARN_ON(!list_empty(&fc->devices)); 1271dd3e2c55SAl Viro kfree_rcu(fc, rcu); 127243901aabSTejun Heo } 1273783863d6SMiklos Szeredi EXPORT_SYMBOL_GPL(fuse_free_conn); 127443901aabSTejun Heo 1275a325f9b9STejun Heo static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb) 1276a325f9b9STejun Heo { 1277a325f9b9STejun Heo int err; 12785f7f7543SJan Kara char *suffix = ""; 1279a325f9b9STejun Heo 128069c8ebf8SJan Kara if (sb->s_bdev) { 12815f7f7543SJan Kara suffix = "-fuseblk"; 128269c8ebf8SJan Kara /* 128369c8ebf8SJan Kara * sb->s_bdi points to blkdev's bdi however we want to redirect 128469c8ebf8SJan Kara * it to our private bdi... 128569c8ebf8SJan Kara */ 128669c8ebf8SJan Kara bdi_put(sb->s_bdi); 128769c8ebf8SJan Kara sb->s_bdi = &noop_backing_dev_info; 128869c8ebf8SJan Kara } 12895f7f7543SJan Kara err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev), 12905f7f7543SJan Kara MINOR(fc->dev), suffix); 1291a325f9b9STejun Heo if (err) 1292a325f9b9STejun Heo return err; 1293a325f9b9STejun Heo 12945f7f7543SJan Kara /* fuse does it's own writeback accounting */ 1295823423efSChristoph Hellwig sb->s_bdi->capabilities &= ~BDI_CAP_WRITEBACK_ACCT; 1296823423efSChristoph Hellwig sb->s_bdi->capabilities |= BDI_CAP_STRICTLIMIT; 12975f7f7543SJan Kara 1298a325f9b9STejun Heo /* 1299a325f9b9STejun Heo * For a single fuse filesystem use max 1% of dirty + 1300a325f9b9STejun Heo * writeback threshold. 1301a325f9b9STejun Heo * 1302a325f9b9STejun Heo * This gives about 1M of write buffer for memory maps on a 1303a325f9b9STejun Heo * machine with 1G and 10% dirty_ratio, which should be more 1304a325f9b9STejun Heo * than enough. 1305a325f9b9STejun Heo * 1306a325f9b9STejun Heo * Privileged users can raise it by writing to 1307a325f9b9STejun Heo * 1308a325f9b9STejun Heo * /sys/class/bdi/<bdi>/max_ratio 1309a325f9b9STejun Heo */ 13105f7f7543SJan Kara bdi_set_max_ratio(sb->s_bdi, 1); 1311a325f9b9STejun Heo 1312a325f9b9STejun Heo return 0; 1313a325f9b9STejun Heo } 1314a325f9b9STejun Heo 13150cd1eb9aSVivek Goyal struct fuse_dev *fuse_dev_alloc(void) 1316cc080e9eSMiklos Szeredi { 1317cc080e9eSMiklos Szeredi struct fuse_dev *fud; 1318be2ff42cSKirill Tkhai struct list_head *pq; 1319cc080e9eSMiklos Szeredi 1320cc080e9eSMiklos Szeredi fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL); 1321be2ff42cSKirill Tkhai if (!fud) 1322be2ff42cSKirill Tkhai return NULL; 1323be2ff42cSKirill Tkhai 1324be2ff42cSKirill Tkhai pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL); 1325be2ff42cSKirill Tkhai if (!pq) { 1326be2ff42cSKirill Tkhai kfree(fud); 1327be2ff42cSKirill Tkhai return NULL; 1328be2ff42cSKirill Tkhai } 1329be2ff42cSKirill Tkhai 1330be2ff42cSKirill Tkhai fud->pq.processing = pq; 1331c3696046SMiklos Szeredi fuse_pqueue_init(&fud->pq); 1332cc080e9eSMiklos Szeredi 1333cc080e9eSMiklos Szeredi return fud; 1334cc080e9eSMiklos Szeredi } 1335cc080e9eSMiklos Szeredi EXPORT_SYMBOL_GPL(fuse_dev_alloc); 1336cc080e9eSMiklos Szeredi 13370cd1eb9aSVivek Goyal void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc) 13380cd1eb9aSVivek Goyal { 13390cd1eb9aSVivek Goyal fud->fc = fuse_conn_get(fc); 13400cd1eb9aSVivek Goyal spin_lock(&fc->lock); 13410cd1eb9aSVivek Goyal list_add_tail(&fud->entry, &fc->devices); 13420cd1eb9aSVivek Goyal spin_unlock(&fc->lock); 13430cd1eb9aSVivek Goyal } 13440cd1eb9aSVivek Goyal EXPORT_SYMBOL_GPL(fuse_dev_install); 13450cd1eb9aSVivek Goyal 13460cd1eb9aSVivek Goyal struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc) 13470cd1eb9aSVivek Goyal { 13480cd1eb9aSVivek Goyal struct fuse_dev *fud; 13490cd1eb9aSVivek Goyal 13500cd1eb9aSVivek Goyal fud = fuse_dev_alloc(); 13510cd1eb9aSVivek Goyal if (!fud) 13520cd1eb9aSVivek Goyal return NULL; 13530cd1eb9aSVivek Goyal 13540cd1eb9aSVivek Goyal fuse_dev_install(fud, fc); 13550cd1eb9aSVivek Goyal return fud; 13560cd1eb9aSVivek Goyal } 13570cd1eb9aSVivek Goyal EXPORT_SYMBOL_GPL(fuse_dev_alloc_install); 13580cd1eb9aSVivek Goyal 1359cc080e9eSMiklos Szeredi void fuse_dev_free(struct fuse_dev *fud) 1360cc080e9eSMiklos Szeredi { 1361cc080e9eSMiklos Szeredi struct fuse_conn *fc = fud->fc; 1362cc080e9eSMiklos Szeredi 1363cc080e9eSMiklos Szeredi if (fc) { 1364cc080e9eSMiklos Szeredi spin_lock(&fc->lock); 1365cc080e9eSMiklos Szeredi list_del(&fud->entry); 1366cc080e9eSMiklos Szeredi spin_unlock(&fc->lock); 1367cc080e9eSMiklos Szeredi 1368cc080e9eSMiklos Szeredi fuse_conn_put(fc); 1369cc080e9eSMiklos Szeredi } 1370d72f70daSTakeshi Misawa kfree(fud->pq.processing); 1371cc080e9eSMiklos Szeredi kfree(fud); 1372cc080e9eSMiklos Szeredi } 1373cc080e9eSMiklos Szeredi EXPORT_SYMBOL_GPL(fuse_dev_free); 1374cc080e9eSMiklos Szeredi 13751866d779SMax Reitz static void fuse_fill_attr_from_inode(struct fuse_attr *attr, 13761866d779SMax Reitz const struct fuse_inode *fi) 13771866d779SMax Reitz { 13781866d779SMax Reitz *attr = (struct fuse_attr){ 13791866d779SMax Reitz .ino = fi->inode.i_ino, 13801866d779SMax Reitz .size = fi->inode.i_size, 13811866d779SMax Reitz .blocks = fi->inode.i_blocks, 13821866d779SMax Reitz .atime = fi->inode.i_atime.tv_sec, 13831866d779SMax Reitz .mtime = fi->inode.i_mtime.tv_sec, 13841866d779SMax Reitz .ctime = fi->inode.i_ctime.tv_sec, 13851866d779SMax Reitz .atimensec = fi->inode.i_atime.tv_nsec, 13861866d779SMax Reitz .mtimensec = fi->inode.i_mtime.tv_nsec, 13871866d779SMax Reitz .ctimensec = fi->inode.i_ctime.tv_nsec, 13881866d779SMax Reitz .mode = fi->inode.i_mode, 13891866d779SMax Reitz .nlink = fi->inode.i_nlink, 13901866d779SMax Reitz .uid = fi->inode.i_uid.val, 13911866d779SMax Reitz .gid = fi->inode.i_gid.val, 13921866d779SMax Reitz .rdev = fi->inode.i_rdev, 13931866d779SMax Reitz .blksize = 1u << fi->inode.i_blkbits, 13941866d779SMax Reitz }; 13951866d779SMax Reitz } 13961866d779SMax Reitz 13971866d779SMax Reitz static void fuse_sb_defaults(struct super_block *sb) 13981866d779SMax Reitz { 13991866d779SMax Reitz sb->s_magic = FUSE_SUPER_MAGIC; 14001866d779SMax Reitz sb->s_op = &fuse_super_operations; 14011866d779SMax Reitz sb->s_xattr = fuse_xattr_handlers; 14021866d779SMax Reitz sb->s_maxbytes = MAX_LFS_FILESIZE; 14031866d779SMax Reitz sb->s_time_gran = 1; 14041866d779SMax Reitz sb->s_export_op = &fuse_export_operations; 14051866d779SMax Reitz sb->s_iflags |= SB_I_IMA_UNVERIFIABLE_SIGNATURE; 14061866d779SMax Reitz if (sb->s_user_ns != &init_user_ns) 14071866d779SMax Reitz sb->s_iflags |= SB_I_UNTRUSTED_MOUNTER; 14081866d779SMax Reitz sb->s_flags &= ~(SB_NOSEC | SB_I_VERSION); 14091866d779SMax Reitz 14101866d779SMax Reitz /* 14111866d779SMax Reitz * If we are not in the initial user namespace posix 14121866d779SMax Reitz * acls must be translated. 14131866d779SMax Reitz */ 14141866d779SMax Reitz if (sb->s_user_ns != &init_user_ns) 14151866d779SMax Reitz sb->s_xattr = fuse_no_acl_xattr_handlers; 14161866d779SMax Reitz } 14171866d779SMax Reitz 14181b539917SGreg Kurz static int fuse_fill_super_submount(struct super_block *sb, 14191866d779SMax Reitz struct fuse_inode *parent_fi) 14201866d779SMax Reitz { 14211866d779SMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 14221866d779SMax Reitz struct super_block *parent_sb = parent_fi->inode.i_sb; 14231866d779SMax Reitz struct fuse_attr root_attr; 14241866d779SMax Reitz struct inode *root; 14251866d779SMax Reitz 14261866d779SMax Reitz fuse_sb_defaults(sb); 14271866d779SMax Reitz fm->sb = sb; 14281866d779SMax Reitz 14291866d779SMax Reitz WARN_ON(sb->s_bdi != &noop_backing_dev_info); 14301866d779SMax Reitz sb->s_bdi = bdi_get(parent_sb->s_bdi); 14311866d779SMax Reitz 14321866d779SMax Reitz sb->s_xattr = parent_sb->s_xattr; 14331866d779SMax Reitz sb->s_time_gran = parent_sb->s_time_gran; 14341866d779SMax Reitz sb->s_blocksize = parent_sb->s_blocksize; 14351866d779SMax Reitz sb->s_blocksize_bits = parent_sb->s_blocksize_bits; 14361866d779SMax Reitz sb->s_subtype = kstrdup(parent_sb->s_subtype, GFP_KERNEL); 14371866d779SMax Reitz if (parent_sb->s_subtype && !sb->s_subtype) 14381866d779SMax Reitz return -ENOMEM; 14391866d779SMax Reitz 14401866d779SMax Reitz fuse_fill_attr_from_inode(&root_attr, parent_fi); 14411866d779SMax Reitz root = fuse_iget(sb, parent_fi->nodeid, 0, &root_attr, 0, 0); 14421866d779SMax Reitz /* 14431866d779SMax Reitz * This inode is just a duplicate, so it is not looked up and 14441866d779SMax Reitz * its nlookup should not be incremented. fuse_iget() does 14451866d779SMax Reitz * that, though, so undo it here. 14461866d779SMax Reitz */ 14471866d779SMax Reitz get_fuse_inode(root)->nlookup--; 14481866d779SMax Reitz sb->s_d_op = &fuse_dentry_operations; 14491866d779SMax Reitz sb->s_root = d_make_root(root); 14501866d779SMax Reitz if (!sb->s_root) 14511866d779SMax Reitz return -ENOMEM; 14521866d779SMax Reitz 14531866d779SMax Reitz return 0; 14541866d779SMax Reitz } 14551866d779SMax Reitz 1456266eb3f2SGreg Kurz /* Filesystem context private data holds the FUSE inode of the mount point */ 1457fe0a7bd8SGreg Kurz static int fuse_get_tree_submount(struct fs_context *fsc) 1458fe0a7bd8SGreg Kurz { 1459266eb3f2SGreg Kurz struct fuse_mount *fm; 1460266eb3f2SGreg Kurz struct fuse_inode *mp_fi = fsc->fs_private; 1461266eb3f2SGreg Kurz struct fuse_conn *fc = get_fuse_conn(&mp_fi->inode); 1462266eb3f2SGreg Kurz struct super_block *sb; 1463266eb3f2SGreg Kurz int err; 1464266eb3f2SGreg Kurz 1465266eb3f2SGreg Kurz fm = kzalloc(sizeof(struct fuse_mount), GFP_KERNEL); 1466266eb3f2SGreg Kurz if (!fm) 1467266eb3f2SGreg Kurz return -ENOMEM; 1468266eb3f2SGreg Kurz 1469c191cd07SMiklos Szeredi fm->fc = fuse_conn_get(fc); 1470266eb3f2SGreg Kurz fsc->s_fs_info = fm; 1471266eb3f2SGreg Kurz sb = sget_fc(fsc, NULL, set_anon_super_fc); 1472c191cd07SMiklos Szeredi if (fsc->s_fs_info) 1473c191cd07SMiklos Szeredi fuse_mount_destroy(fm); 1474c191cd07SMiklos Szeredi if (IS_ERR(sb)) 1475266eb3f2SGreg Kurz return PTR_ERR(sb); 1476266eb3f2SGreg Kurz 1477266eb3f2SGreg Kurz /* Initialize superblock, making @mp_fi its root */ 1478266eb3f2SGreg Kurz err = fuse_fill_super_submount(sb, mp_fi); 1479266eb3f2SGreg Kurz if (err) { 1480266eb3f2SGreg Kurz deactivate_locked_super(sb); 1481266eb3f2SGreg Kurz return err; 1482266eb3f2SGreg Kurz } 1483266eb3f2SGreg Kurz 1484266eb3f2SGreg Kurz down_write(&fc->killsb); 1485266eb3f2SGreg Kurz list_add_tail(&fm->fc_entry, &fc->mounts); 1486266eb3f2SGreg Kurz up_write(&fc->killsb); 1487266eb3f2SGreg Kurz 1488266eb3f2SGreg Kurz sb->s_flags |= SB_ACTIVE; 1489266eb3f2SGreg Kurz fsc->root = dget(sb->s_root); 1490266eb3f2SGreg Kurz 1491fe0a7bd8SGreg Kurz return 0; 1492fe0a7bd8SGreg Kurz } 1493fe0a7bd8SGreg Kurz 1494fe0a7bd8SGreg Kurz static const struct fs_context_operations fuse_context_submount_ops = { 1495fe0a7bd8SGreg Kurz .get_tree = fuse_get_tree_submount, 1496fe0a7bd8SGreg Kurz }; 1497fe0a7bd8SGreg Kurz 1498fe0a7bd8SGreg Kurz int fuse_init_fs_context_submount(struct fs_context *fsc) 1499fe0a7bd8SGreg Kurz { 1500fe0a7bd8SGreg Kurz fsc->ops = &fuse_context_submount_ops; 1501fe0a7bd8SGreg Kurz return 0; 1502fe0a7bd8SGreg Kurz } 1503fe0a7bd8SGreg Kurz EXPORT_SYMBOL_GPL(fuse_init_fs_context_submount); 1504fe0a7bd8SGreg Kurz 15050cc2656cSStefan Hajnoczi int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx) 1506d8a5ba45SMiklos Szeredi { 15077fd3abfaSVivek Goyal struct fuse_dev *fud = NULL; 1508fcee216bSMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 1509fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1510d8a5ba45SMiklos Szeredi struct inode *root; 1511f543f253SMiklos Szeredi struct dentry *root_dentry; 1512d8a5ba45SMiklos Szeredi int err; 1513d8a5ba45SMiklos Szeredi 1514c2b8f006SMiklos Szeredi err = -EINVAL; 15151751e8a6SLinus Torvalds if (sb->s_flags & SB_MANDLOCK) 1516c2b8f006SMiklos Szeredi goto err; 151771421259SMiklos Szeredi 1518660585b5SMiklos Szeredi rcu_assign_pointer(fc->curr_bucket, fuse_sync_bucket_alloc()); 15191866d779SMax Reitz fuse_sb_defaults(sb); 15209e1f1de0SAl Viro 15210cc2656cSStefan Hajnoczi if (ctx->is_bdev) { 1522875d95ecSMiklos Szeredi #ifdef CONFIG_BLOCK 1523c2b8f006SMiklos Szeredi err = -EINVAL; 1524c30da2e9SDavid Howells if (!sb_set_blocksize(sb, ctx->blksize)) 1525c2b8f006SMiklos Szeredi goto err; 1526875d95ecSMiklos Szeredi #endif 1527d8091614SMiklos Szeredi } else { 152809cbfeafSKirill A. Shutemov sb->s_blocksize = PAGE_SIZE; 152909cbfeafSKirill A. Shutemov sb->s_blocksize_bits = PAGE_SHIFT; 1530d8091614SMiklos Szeredi } 1531c30da2e9SDavid Howells 1532c30da2e9SDavid Howells sb->s_subtype = ctx->subtype; 1533c30da2e9SDavid Howells ctx->subtype = NULL; 15341dd53957SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX)) { 1535780b1b95SJeffle Xu err = fuse_dax_conn_alloc(fc, ctx->dax_mode, ctx->dax_dev); 15361dd53957SVivek Goyal if (err) 15371dd53957SVivek Goyal goto err; 15381dd53957SVivek Goyal } 1539e45b2546SEric W. Biederman 15407fd3abfaSVivek Goyal if (ctx->fudptr) { 15417fd3abfaSVivek Goyal err = -ENOMEM; 15420cd1eb9aSVivek Goyal fud = fuse_dev_alloc_install(fc); 1543cc080e9eSMiklos Szeredi if (!fud) 15441dd53957SVivek Goyal goto err_free_dax; 15457fd3abfaSVivek Goyal } 1546cc080e9eSMiklos Szeredi 1547a325f9b9STejun Heo fc->dev = sb->s_dev; 1548fcee216bSMax Reitz fm->sb = sb; 1549a325f9b9STejun Heo err = fuse_bdi_init(fc, sb); 1550a325f9b9STejun Heo if (err) 1551cc080e9eSMiklos Szeredi goto err_dev_free; 15520d179aa5STejun Heo 1553e0a43ddcSMiklos Szeredi /* Handle umasking inside the fuse code */ 15541751e8a6SLinus Torvalds if (sb->s_flags & SB_POSIXACL) 1555e0a43ddcSMiklos Szeredi fc->dont_mask = 1; 15561751e8a6SLinus Torvalds sb->s_flags |= SB_POSIXACL; 1557e0a43ddcSMiklos Szeredi 1558c30da2e9SDavid Howells fc->default_permissions = ctx->default_permissions; 1559c30da2e9SDavid Howells fc->allow_other = ctx->allow_other; 1560c30da2e9SDavid Howells fc->user_id = ctx->user_id; 1561c30da2e9SDavid Howells fc->group_id = ctx->group_id; 1562f4fd4ae3SVivek Goyal fc->legacy_opts_show = ctx->legacy_opts_show; 15631866d779SMax Reitz fc->max_read = max_t(unsigned int, 4096, ctx->max_read); 1564783863d6SMiklos Szeredi fc->destroy = ctx->destroy; 156515c8e72eSVivek Goyal fc->no_control = ctx->no_control; 156615c8e72eSVivek Goyal fc->no_force_umount = ctx->no_force_umount; 1567f543f253SMiklos Szeredi 1568d8a5ba45SMiklos Szeredi err = -ENOMEM; 1569c30da2e9SDavid Howells root = fuse_get_root_inode(sb, ctx->rootmode); 15700ce267ffSMiklos Szeredi sb->s_d_op = &fuse_root_dentry_operations; 157148fde701SAl Viro root_dentry = d_make_root(root); 157248fde701SAl Viro if (!root_dentry) 1573cc080e9eSMiklos Szeredi goto err_dev_free; 15740ce267ffSMiklos Szeredi /* Root dentry doesn't have .d_revalidate */ 1575c35eebe9SAl Viro sb->s_d_op = &fuse_dentry_operations; 1576f543f253SMiklos Szeredi 1577bafa9654SMiklos Szeredi mutex_lock(&fuse_mutex); 15788aa09a50SMiklos Szeredi err = -EINVAL; 15797fd3abfaSVivek Goyal if (ctx->fudptr && *ctx->fudptr) 1580bafa9654SMiklos Szeredi goto err_unlock; 15818aa09a50SMiklos Szeredi 1582bafa9654SMiklos Szeredi err = fuse_ctl_add_conn(fc); 1583bafa9654SMiklos Szeredi if (err) 1584bafa9654SMiklos Szeredi goto err_unlock; 1585bafa9654SMiklos Szeredi 1586bafa9654SMiklos Szeredi list_add_tail(&fc->entry, &fuse_conn_list); 1587f543f253SMiklos Szeredi sb->s_root = root_dentry; 15887fd3abfaSVivek Goyal if (ctx->fudptr) 15890cc2656cSStefan Hajnoczi *ctx->fudptr = fud; 1590bafa9654SMiklos Szeredi mutex_unlock(&fuse_mutex); 1591d8a5ba45SMiklos Szeredi return 0; 1592d8a5ba45SMiklos Szeredi 1593bafa9654SMiklos Szeredi err_unlock: 1594bafa9654SMiklos Szeredi mutex_unlock(&fuse_mutex); 1595f543f253SMiklos Szeredi dput(root_dentry); 1596cc080e9eSMiklos Szeredi err_dev_free: 15977fd3abfaSVivek Goyal if (fud) 1598cc080e9eSMiklos Szeredi fuse_dev_free(fud); 15991dd53957SVivek Goyal err_free_dax: 16001dd53957SVivek Goyal if (IS_ENABLED(CONFIG_FUSE_DAX)) 16011dd53957SVivek Goyal fuse_dax_conn_free(fc); 16020cc2656cSStefan Hajnoczi err: 16030cc2656cSStefan Hajnoczi return err; 16040cc2656cSStefan Hajnoczi } 16050cc2656cSStefan Hajnoczi EXPORT_SYMBOL_GPL(fuse_fill_super_common); 16060cc2656cSStefan Hajnoczi 16070cc2656cSStefan Hajnoczi static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc) 16080cc2656cSStefan Hajnoczi { 16090cc2656cSStefan Hajnoczi struct fuse_fs_context *ctx = fsc->fs_private; 16100cc2656cSStefan Hajnoczi int err; 16110cc2656cSStefan Hajnoczi 161262dd1fc8SMiklos Szeredi if (!ctx->file || !ctx->rootmode_present || 1613badc7414SMiklos Szeredi !ctx->user_id_present || !ctx->group_id_present) 1614badc7414SMiklos Szeredi return -EINVAL; 16150cc2656cSStefan Hajnoczi 16160cc2656cSStefan Hajnoczi /* 16170cc2656cSStefan Hajnoczi * Require mount to happen from the same user namespace which 16180cc2656cSStefan Hajnoczi * opened /dev/fuse to prevent potential attacks. 16190cc2656cSStefan Hajnoczi */ 162062dd1fc8SMiklos Szeredi if ((ctx->file->f_op != &fuse_dev_operations) || 162162dd1fc8SMiklos Szeredi (ctx->file->f_cred->user_ns != sb->s_user_ns)) 1622964d32e5SMiklos Szeredi return -EINVAL; 162362dd1fc8SMiklos Szeredi ctx->fudptr = &ctx->file->private_data; 16240cc2656cSStefan Hajnoczi 16250cc2656cSStefan Hajnoczi err = fuse_fill_super_common(sb, ctx); 16260cc2656cSStefan Hajnoczi if (err) 1627964d32e5SMiklos Szeredi return err; 162862dd1fc8SMiklos Szeredi /* file->private_data shall be visible on all CPUs after this */ 162962dd1fc8SMiklos Szeredi smp_mb(); 1630fcee216bSMax Reitz fuse_send_init(get_fuse_mount_super(sb)); 16310cc2656cSStefan Hajnoczi return 0; 1632d8a5ba45SMiklos Szeredi } 1633d8a5ba45SMiklos Szeredi 16345d5b74aaSMiklos Szeredi /* 16355d5b74aaSMiklos Szeredi * This is the path where user supplied an already initialized fuse dev. In 16365d5b74aaSMiklos Szeredi * this case never create a new super if the old one is gone. 16375d5b74aaSMiklos Szeredi */ 16385d5b74aaSMiklos Szeredi static int fuse_set_no_super(struct super_block *sb, struct fs_context *fsc) 1639d8a5ba45SMiklos Szeredi { 16405d5b74aaSMiklos Szeredi return -ENOTCONN; 16415d5b74aaSMiklos Szeredi } 1642c30da2e9SDavid Howells 16435d5b74aaSMiklos Szeredi static int fuse_test_super(struct super_block *sb, struct fs_context *fsc) 16445d5b74aaSMiklos Szeredi { 16455d5b74aaSMiklos Szeredi 16465d5b74aaSMiklos Szeredi return fsc->sget_key == get_fuse_conn_super(sb); 16475d5b74aaSMiklos Szeredi } 16485d5b74aaSMiklos Szeredi 164984c21507SMiklos Szeredi static int fuse_get_tree(struct fs_context *fsc) 1650d8a5ba45SMiklos Szeredi { 165184c21507SMiklos Szeredi struct fuse_fs_context *ctx = fsc->fs_private; 16525d5b74aaSMiklos Szeredi struct fuse_dev *fud; 165380019f11SMiklos Szeredi struct fuse_conn *fc; 165480019f11SMiklos Szeredi struct fuse_mount *fm; 16555d5b74aaSMiklos Szeredi struct super_block *sb; 165662dd1fc8SMiklos Szeredi int err; 165762dd1fc8SMiklos Szeredi 165880019f11SMiklos Szeredi fc = kmalloc(sizeof(*fc), GFP_KERNEL); 165980019f11SMiklos Szeredi if (!fc) 166080019f11SMiklos Szeredi return -ENOMEM; 166180019f11SMiklos Szeredi 166280019f11SMiklos Szeredi fm = kzalloc(sizeof(*fm), GFP_KERNEL); 166380019f11SMiklos Szeredi if (!fm) { 166480019f11SMiklos Szeredi kfree(fc); 166580019f11SMiklos Szeredi return -ENOMEM; 166680019f11SMiklos Szeredi } 166780019f11SMiklos Szeredi 166880019f11SMiklos Szeredi fuse_conn_init(fc, fm, fsc->user_ns, &fuse_dev_fiq_ops, NULL); 166980019f11SMiklos Szeredi fc->release = fuse_free_conn; 167080019f11SMiklos Szeredi 167180019f11SMiklos Szeredi fsc->s_fs_info = fm; 167280019f11SMiklos Szeredi 167362dd1fc8SMiklos Szeredi if (ctx->fd_present) 167462dd1fc8SMiklos Szeredi ctx->file = fget(ctx->fd); 1675c30da2e9SDavid Howells 1676badc7414SMiklos Szeredi if (IS_ENABLED(CONFIG_BLOCK) && ctx->is_bdev) { 167762dd1fc8SMiklos Szeredi err = get_tree_bdev(fsc, fuse_fill_super); 167880019f11SMiklos Szeredi goto out; 1679badc7414SMiklos Szeredi } 16805d5b74aaSMiklos Szeredi /* 16815d5b74aaSMiklos Szeredi * While block dev mount can be initialized with a dummy device fd 16825d5b74aaSMiklos Szeredi * (found by device name), normal fuse mounts can't 16835d5b74aaSMiklos Szeredi */ 168480019f11SMiklos Szeredi err = -EINVAL; 16855d5b74aaSMiklos Szeredi if (!ctx->file) 168680019f11SMiklos Szeredi goto out; 1687c30da2e9SDavid Howells 16885d5b74aaSMiklos Szeredi /* 16895d5b74aaSMiklos Szeredi * Allow creating a fuse mount with an already initialized fuse 16905d5b74aaSMiklos Szeredi * connection 16915d5b74aaSMiklos Szeredi */ 16925d5b74aaSMiklos Szeredi fud = READ_ONCE(ctx->file->private_data); 16935d5b74aaSMiklos Szeredi if (ctx->file->f_op == &fuse_dev_operations && fud) { 16945d5b74aaSMiklos Szeredi fsc->sget_key = fud->fc; 16955d5b74aaSMiklos Szeredi sb = sget_fc(fsc, fuse_test_super, fuse_set_no_super); 16965d5b74aaSMiklos Szeredi err = PTR_ERR_OR_ZERO(sb); 16975d5b74aaSMiklos Szeredi if (!IS_ERR(sb)) 16985d5b74aaSMiklos Szeredi fsc->root = dget(sb->s_root); 16995d5b74aaSMiklos Szeredi } else { 170062dd1fc8SMiklos Szeredi err = get_tree_nodev(fsc, fuse_fill_super); 17015d5b74aaSMiklos Szeredi } 170280019f11SMiklos Szeredi out: 170380019f11SMiklos Szeredi if (fsc->s_fs_info) 170480019f11SMiklos Szeredi fuse_mount_destroy(fm); 170562dd1fc8SMiklos Szeredi if (ctx->file) 170662dd1fc8SMiklos Szeredi fput(ctx->file); 170762dd1fc8SMiklos Szeredi return err; 1708c30da2e9SDavid Howells } 1709c30da2e9SDavid Howells 1710c30da2e9SDavid Howells static const struct fs_context_operations fuse_context_ops = { 171184c21507SMiklos Szeredi .free = fuse_free_fsc, 1712c30da2e9SDavid Howells .parse_param = fuse_parse_param, 17130189a2d3SMiklos Szeredi .reconfigure = fuse_reconfigure, 1714c30da2e9SDavid Howells .get_tree = fuse_get_tree, 1715c30da2e9SDavid Howells }; 1716c30da2e9SDavid Howells 1717c30da2e9SDavid Howells /* 1718c30da2e9SDavid Howells * Set up the filesystem mount context. 1719c30da2e9SDavid Howells */ 172084c21507SMiklos Szeredi static int fuse_init_fs_context(struct fs_context *fsc) 1721c30da2e9SDavid Howells { 1722c30da2e9SDavid Howells struct fuse_fs_context *ctx; 1723c30da2e9SDavid Howells 1724c30da2e9SDavid Howells ctx = kzalloc(sizeof(struct fuse_fs_context), GFP_KERNEL); 1725c30da2e9SDavid Howells if (!ctx) 1726c30da2e9SDavid Howells return -ENOMEM; 1727c30da2e9SDavid Howells 1728c30da2e9SDavid Howells ctx->max_read = ~0; 1729c30da2e9SDavid Howells ctx->blksize = FUSE_DEFAULT_BLKSIZE; 1730f4fd4ae3SVivek Goyal ctx->legacy_opts_show = true; 1731c30da2e9SDavid Howells 1732c30da2e9SDavid Howells #ifdef CONFIG_BLOCK 173384c21507SMiklos Szeredi if (fsc->fs_type == &fuseblk_fs_type) { 1734c30da2e9SDavid Howells ctx->is_bdev = true; 1735783863d6SMiklos Szeredi ctx->destroy = true; 1736783863d6SMiklos Szeredi } 1737c30da2e9SDavid Howells #endif 1738c30da2e9SDavid Howells 173984c21507SMiklos Szeredi fsc->fs_private = ctx; 174084c21507SMiklos Szeredi fsc->ops = &fuse_context_ops; 1741c30da2e9SDavid Howells return 0; 1742d8a5ba45SMiklos Szeredi } 1743d8a5ba45SMiklos Szeredi 1744fcee216bSMax Reitz bool fuse_mount_remove(struct fuse_mount *fm) 17453b463ae0SJohn Muir { 1746fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1747fcee216bSMax Reitz bool last = false; 17483b463ae0SJohn Muir 1749fcee216bSMax Reitz down_write(&fc->killsb); 1750fcee216bSMax Reitz list_del_init(&fm->fc_entry); 1751fcee216bSMax Reitz if (list_empty(&fc->mounts)) 1752fcee216bSMax Reitz last = true; 1753fcee216bSMax Reitz up_write(&fc->killsb); 1754fcee216bSMax Reitz 1755fcee216bSMax Reitz return last; 1756fcee216bSMax Reitz } 1757fcee216bSMax Reitz EXPORT_SYMBOL_GPL(fuse_mount_remove); 1758fcee216bSMax Reitz 1759fcee216bSMax Reitz void fuse_conn_destroy(struct fuse_mount *fm) 1760fcee216bSMax Reitz { 1761fcee216bSMax Reitz struct fuse_conn *fc = fm->fc; 1762fcee216bSMax Reitz 17631ccd1ea2SMiklos Szeredi if (fc->destroy) 1764fcee216bSMax Reitz fuse_send_destroy(fm); 1765e8f3bd77SMiklos Szeredi 1766eb98e3bdSMiklos Szeredi fuse_abort_conn(fc); 1767e8f3bd77SMiklos Szeredi fuse_wait_aborted(fc); 1768e8f3bd77SMiklos Szeredi 1769413daa1aSMiklos Szeredi if (!list_empty(&fc->entry)) { 1770413daa1aSMiklos Szeredi mutex_lock(&fuse_mutex); 1771413daa1aSMiklos Szeredi list_del(&fc->entry); 1772413daa1aSMiklos Szeredi fuse_ctl_remove_conn(fc); 1773413daa1aSMiklos Szeredi mutex_unlock(&fuse_mutex); 17743b463ae0SJohn Muir } 1775e8f3bd77SMiklos Szeredi } 1776fcee216bSMax Reitz EXPORT_SYMBOL_GPL(fuse_conn_destroy); 17773b463ae0SJohn Muir 17786a68d1e1SMiklos Szeredi static void fuse_sb_destroy(struct super_block *sb) 1779e8f3bd77SMiklos Szeredi { 1780fcee216bSMax Reitz struct fuse_mount *fm = get_fuse_mount_super(sb); 1781fcee216bSMax Reitz bool last; 1782fcee216bSMax Reitz 1783d534d31dSMiklos Szeredi if (sb->s_root) { 1784fcee216bSMax Reitz last = fuse_mount_remove(fm); 1785fcee216bSMax Reitz if (last) 1786fcee216bSMax Reitz fuse_conn_destroy(fm); 1787fcee216bSMax Reitz } 17886a68d1e1SMiklos Szeredi } 17896a68d1e1SMiklos Szeredi 1790a27c061aSMiklos Szeredi void fuse_mount_destroy(struct fuse_mount *fm) 1791a27c061aSMiklos Szeredi { 1792a27c061aSMiklos Szeredi fuse_conn_put(fm->fc); 1793a27c061aSMiklos Szeredi kfree(fm); 1794a27c061aSMiklos Szeredi } 1795a27c061aSMiklos Szeredi EXPORT_SYMBOL(fuse_mount_destroy); 1796a27c061aSMiklos Szeredi 17976a68d1e1SMiklos Szeredi static void fuse_kill_sb_anon(struct super_block *sb) 17986a68d1e1SMiklos Szeredi { 17996a68d1e1SMiklos Szeredi fuse_sb_destroy(sb); 18003b463ae0SJohn Muir kill_anon_super(sb); 1801a27c061aSMiklos Szeredi fuse_mount_destroy(get_fuse_mount_super(sb)); 18023b463ae0SJohn Muir } 18033b463ae0SJohn Muir 1804875d95ecSMiklos Szeredi static struct file_system_type fuse_fs_type = { 1805875d95ecSMiklos Szeredi .owner = THIS_MODULE, 1806875d95ecSMiklos Szeredi .name = "fuse", 18074ad769f3SEric W. Biederman .fs_flags = FS_HAS_SUBTYPE | FS_USERNS_MOUNT, 1808c30da2e9SDavid Howells .init_fs_context = fuse_init_fs_context, 1809d7167b14SAl Viro .parameters = fuse_fs_parameters, 18103b463ae0SJohn Muir .kill_sb = fuse_kill_sb_anon, 1811875d95ecSMiklos Szeredi }; 18127f78e035SEric W. Biederman MODULE_ALIAS_FS("fuse"); 1813875d95ecSMiklos Szeredi 1814875d95ecSMiklos Szeredi #ifdef CONFIG_BLOCK 18153b463ae0SJohn Muir static void fuse_kill_sb_blk(struct super_block *sb) 18163b463ae0SJohn Muir { 18176a68d1e1SMiklos Szeredi fuse_sb_destroy(sb); 18183b463ae0SJohn Muir kill_block_super(sb); 1819a27c061aSMiklos Szeredi fuse_mount_destroy(get_fuse_mount_super(sb)); 18203b463ae0SJohn Muir } 18213b463ae0SJohn Muir 1822d6392f87SMiklos Szeredi static struct file_system_type fuseblk_fs_type = { 1823d6392f87SMiklos Szeredi .owner = THIS_MODULE, 1824d6392f87SMiklos Szeredi .name = "fuseblk", 1825c30da2e9SDavid Howells .init_fs_context = fuse_init_fs_context, 1826d7167b14SAl Viro .parameters = fuse_fs_parameters, 18273b463ae0SJohn Muir .kill_sb = fuse_kill_sb_blk, 1828edad01e2SAlexey Dobriyan .fs_flags = FS_REQUIRES_DEV | FS_HAS_SUBTYPE, 1829d6392f87SMiklos Szeredi }; 18307f78e035SEric W. Biederman MODULE_ALIAS_FS("fuseblk"); 1831d6392f87SMiklos Szeredi 1832875d95ecSMiklos Szeredi static inline int register_fuseblk(void) 1833875d95ecSMiklos Szeredi { 1834875d95ecSMiklos Szeredi return register_filesystem(&fuseblk_fs_type); 1835875d95ecSMiklos Szeredi } 1836875d95ecSMiklos Szeredi 1837875d95ecSMiklos Szeredi static inline void unregister_fuseblk(void) 1838875d95ecSMiklos Szeredi { 1839875d95ecSMiklos Szeredi unregister_filesystem(&fuseblk_fs_type); 1840875d95ecSMiklos Szeredi } 1841875d95ecSMiklos Szeredi #else 1842875d95ecSMiklos Szeredi static inline int register_fuseblk(void) 1843875d95ecSMiklos Szeredi { 1844875d95ecSMiklos Szeredi return 0; 1845875d95ecSMiklos Szeredi } 1846875d95ecSMiklos Szeredi 1847875d95ecSMiklos Szeredi static inline void unregister_fuseblk(void) 1848875d95ecSMiklos Szeredi { 1849875d95ecSMiklos Szeredi } 1850875d95ecSMiklos Szeredi #endif 1851875d95ecSMiklos Szeredi 185251cc5068SAlexey Dobriyan static void fuse_inode_init_once(void *foo) 1853d8a5ba45SMiklos Szeredi { 1854d8a5ba45SMiklos Szeredi struct inode *inode = foo; 1855d8a5ba45SMiklos Szeredi 1856d8a5ba45SMiklos Szeredi inode_init_once(inode); 1857d8a5ba45SMiklos Szeredi } 1858d8a5ba45SMiklos Szeredi 1859d8a5ba45SMiklos Szeredi static int __init fuse_fs_init(void) 1860d8a5ba45SMiklos Szeredi { 1861d8a5ba45SMiklos Szeredi int err; 1862d8a5ba45SMiklos Szeredi 1863d8a5ba45SMiklos Szeredi fuse_inode_cachep = kmem_cache_create("fuse_inode", 18645d097056SVladimir Davydov sizeof(struct fuse_inode), 0, 1865df206988SJohannes Weiner SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT|SLAB_RECLAIM_ACCOUNT, 186620c2df83SPaul Mundt fuse_inode_init_once); 1867d8a5ba45SMiklos Szeredi err = -ENOMEM; 1868d6392f87SMiklos Szeredi if (!fuse_inode_cachep) 1869988f0325SAl Viro goto out; 1870988f0325SAl Viro 1871988f0325SAl Viro err = register_fuseblk(); 1872988f0325SAl Viro if (err) 1873988f0325SAl Viro goto out2; 1874988f0325SAl Viro 1875988f0325SAl Viro err = register_filesystem(&fuse_fs_type); 1876988f0325SAl Viro if (err) 1877988f0325SAl Viro goto out3; 1878d8a5ba45SMiklos Szeredi 1879d6392f87SMiklos Szeredi return 0; 1880d6392f87SMiklos Szeredi 1881988f0325SAl Viro out3: 1882875d95ecSMiklos Szeredi unregister_fuseblk(); 1883988f0325SAl Viro out2: 1884988f0325SAl Viro kmem_cache_destroy(fuse_inode_cachep); 1885d6392f87SMiklos Szeredi out: 1886d8a5ba45SMiklos Szeredi return err; 1887d8a5ba45SMiklos Szeredi } 1888d8a5ba45SMiklos Szeredi 1889d8a5ba45SMiklos Szeredi static void fuse_fs_cleanup(void) 1890d8a5ba45SMiklos Szeredi { 1891d8a5ba45SMiklos Szeredi unregister_filesystem(&fuse_fs_type); 1892875d95ecSMiklos Szeredi unregister_fuseblk(); 18938c0a8537SKirill A. Shutemov 18948c0a8537SKirill A. Shutemov /* 18958c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we 18968c0a8537SKirill A. Shutemov * destroy cache. 18978c0a8537SKirill A. Shutemov */ 18988c0a8537SKirill A. Shutemov rcu_barrier(); 1899d8a5ba45SMiklos Szeredi kmem_cache_destroy(fuse_inode_cachep); 1900d8a5ba45SMiklos Szeredi } 1901d8a5ba45SMiklos Szeredi 19025c89e17eSGreg Kroah-Hartman static struct kobject *fuse_kobj; 19035c89e17eSGreg Kroah-Hartman 1904f543f253SMiklos Szeredi static int fuse_sysfs_init(void) 1905f543f253SMiklos Szeredi { 1906f543f253SMiklos Szeredi int err; 1907f543f253SMiklos Szeredi 190800d26666SGreg Kroah-Hartman fuse_kobj = kobject_create_and_add("fuse", fs_kobj); 19095c89e17eSGreg Kroah-Hartman if (!fuse_kobj) { 19105c89e17eSGreg Kroah-Hartman err = -ENOMEM; 1911f543f253SMiklos Szeredi goto out_err; 19125c89e17eSGreg Kroah-Hartman } 1913f543f253SMiklos Szeredi 1914f9bb4882SEric W. Biederman err = sysfs_create_mount_point(fuse_kobj, "connections"); 1915f9bb4882SEric W. Biederman if (err) 1916f543f253SMiklos Szeredi goto out_fuse_unregister; 1917f543f253SMiklos Szeredi 1918f543f253SMiklos Szeredi return 0; 1919f543f253SMiklos Szeredi 1920f543f253SMiklos Szeredi out_fuse_unregister: 1921197b12d6SGreg Kroah-Hartman kobject_put(fuse_kobj); 1922f543f253SMiklos Szeredi out_err: 1923f543f253SMiklos Szeredi return err; 1924f543f253SMiklos Szeredi } 1925f543f253SMiklos Szeredi 1926f543f253SMiklos Szeredi static void fuse_sysfs_cleanup(void) 1927f543f253SMiklos Szeredi { 1928f9bb4882SEric W. Biederman sysfs_remove_mount_point(fuse_kobj, "connections"); 1929197b12d6SGreg Kroah-Hartman kobject_put(fuse_kobj); 1930f543f253SMiklos Szeredi } 1931f543f253SMiklos Szeredi 1932d8a5ba45SMiklos Szeredi static int __init fuse_init(void) 1933d8a5ba45SMiklos Szeredi { 1934d8a5ba45SMiklos Szeredi int res; 1935d8a5ba45SMiklos Szeredi 1936f2294482SKirill Smelkov pr_info("init (API version %i.%i)\n", 1937d8a5ba45SMiklos Szeredi FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION); 1938d8a5ba45SMiklos Szeredi 1939bafa9654SMiklos Szeredi INIT_LIST_HEAD(&fuse_conn_list); 1940d8a5ba45SMiklos Szeredi res = fuse_fs_init(); 1941d8a5ba45SMiklos Szeredi if (res) 1942d8a5ba45SMiklos Szeredi goto err; 1943d8a5ba45SMiklos Szeredi 1944334f485dSMiklos Szeredi res = fuse_dev_init(); 1945334f485dSMiklos Szeredi if (res) 1946334f485dSMiklos Szeredi goto err_fs_cleanup; 1947334f485dSMiklos Szeredi 1948f543f253SMiklos Szeredi res = fuse_sysfs_init(); 1949f543f253SMiklos Szeredi if (res) 1950f543f253SMiklos Szeredi goto err_dev_cleanup; 1951f543f253SMiklos Szeredi 1952bafa9654SMiklos Szeredi res = fuse_ctl_init(); 1953bafa9654SMiklos Szeredi if (res) 1954bafa9654SMiklos Szeredi goto err_sysfs_cleanup; 1955bafa9654SMiklos Szeredi 1956487ea5afSCsaba Henk sanitize_global_limit(&max_user_bgreq); 1957487ea5afSCsaba Henk sanitize_global_limit(&max_user_congthresh); 1958487ea5afSCsaba Henk 1959d8a5ba45SMiklos Szeredi return 0; 1960d8a5ba45SMiklos Szeredi 1961bafa9654SMiklos Szeredi err_sysfs_cleanup: 1962bafa9654SMiklos Szeredi fuse_sysfs_cleanup(); 1963f543f253SMiklos Szeredi err_dev_cleanup: 1964f543f253SMiklos Szeredi fuse_dev_cleanup(); 1965334f485dSMiklos Szeredi err_fs_cleanup: 1966334f485dSMiklos Szeredi fuse_fs_cleanup(); 1967d8a5ba45SMiklos Szeredi err: 1968d8a5ba45SMiklos Szeredi return res; 1969d8a5ba45SMiklos Szeredi } 1970d8a5ba45SMiklos Szeredi 1971d8a5ba45SMiklos Szeredi static void __exit fuse_exit(void) 1972d8a5ba45SMiklos Szeredi { 1973f2294482SKirill Smelkov pr_debug("exit\n"); 1974d8a5ba45SMiklos Szeredi 1975bafa9654SMiklos Szeredi fuse_ctl_cleanup(); 1976f543f253SMiklos Szeredi fuse_sysfs_cleanup(); 1977d8a5ba45SMiklos Szeredi fuse_fs_cleanup(); 1978334f485dSMiklos Szeredi fuse_dev_cleanup(); 1979d8a5ba45SMiklos Szeredi } 1980d8a5ba45SMiklos Szeredi 1981d8a5ba45SMiklos Szeredi module_init(fuse_init); 1982d8a5ba45SMiklos Szeredi module_exit(fuse_exit); 1983