1 /* 2 * fs/kernfs/mount.c - kernfs mount implementation 3 * 4 * Copyright (c) 2001-3 Patrick Mochel 5 * Copyright (c) 2007 SUSE Linux Products GmbH 6 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 7 * 8 * This file is released under the GPLv2. 9 */ 10 11 #include <linux/fs.h> 12 #include <linux/mount.h> 13 #include <linux/init.h> 14 #include <linux/magic.h> 15 #include <linux/slab.h> 16 #include <linux/pagemap.h> 17 18 #include "kernfs-internal.h" 19 20 struct kmem_cache *kernfs_node_cache; 21 22 static int kernfs_sop_remount_fs(struct super_block *sb, int *flags, char *data) 23 { 24 struct kernfs_root *root = kernfs_info(sb)->root; 25 struct kernfs_syscall_ops *scops = root->syscall_ops; 26 27 if (scops && scops->remount_fs) 28 return scops->remount_fs(root, flags, data); 29 return 0; 30 } 31 32 static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry) 33 { 34 struct kernfs_root *root = kernfs_root(dentry->d_fsdata); 35 struct kernfs_syscall_ops *scops = root->syscall_ops; 36 37 if (scops && scops->show_options) 38 return scops->show_options(sf, root); 39 return 0; 40 } 41 42 const struct super_operations kernfs_sops = { 43 .statfs = simple_statfs, 44 .drop_inode = generic_delete_inode, 45 .evict_inode = kernfs_evict_inode, 46 47 .remount_fs = kernfs_sop_remount_fs, 48 .show_options = kernfs_sop_show_options, 49 }; 50 51 /** 52 * kernfs_root_from_sb - determine kernfs_root associated with a super_block 53 * @sb: the super_block in question 54 * 55 * Return the kernfs_root associated with @sb. If @sb is not a kernfs one, 56 * %NULL is returned. 57 */ 58 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) 59 { 60 if (sb->s_op == &kernfs_sops) 61 return kernfs_info(sb)->root; 62 return NULL; 63 } 64 65 static int kernfs_fill_super(struct super_block *sb) 66 { 67 struct kernfs_super_info *info = kernfs_info(sb); 68 struct inode *inode; 69 struct dentry *root; 70 71 info->sb = sb; 72 sb->s_blocksize = PAGE_CACHE_SIZE; 73 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 74 sb->s_magic = SYSFS_MAGIC; 75 sb->s_op = &kernfs_sops; 76 sb->s_time_gran = 1; 77 78 /* get root inode, initialize and unlock it */ 79 mutex_lock(&kernfs_mutex); 80 inode = kernfs_get_inode(sb, info->root->kn); 81 mutex_unlock(&kernfs_mutex); 82 if (!inode) { 83 pr_debug("kernfs: could not get root inode\n"); 84 return -ENOMEM; 85 } 86 87 /* instantiate and link root dentry */ 88 root = d_make_root(inode); 89 if (!root) { 90 pr_debug("%s: could not get root dentry!\n", __func__); 91 return -ENOMEM; 92 } 93 kernfs_get(info->root->kn); 94 root->d_fsdata = info->root->kn; 95 sb->s_root = root; 96 sb->s_d_op = &kernfs_dops; 97 return 0; 98 } 99 100 static int kernfs_test_super(struct super_block *sb, void *data) 101 { 102 struct kernfs_super_info *sb_info = kernfs_info(sb); 103 struct kernfs_super_info *info = data; 104 105 return sb_info->root == info->root && sb_info->ns == info->ns; 106 } 107 108 static int kernfs_set_super(struct super_block *sb, void *data) 109 { 110 int error; 111 error = set_anon_super(sb, data); 112 if (!error) 113 sb->s_fs_info = data; 114 return error; 115 } 116 117 /** 118 * kernfs_super_ns - determine the namespace tag of a kernfs super_block 119 * @sb: super_block of interest 120 * 121 * Return the namespace tag associated with kernfs super_block @sb. 122 */ 123 const void *kernfs_super_ns(struct super_block *sb) 124 { 125 struct kernfs_super_info *info = kernfs_info(sb); 126 127 return info->ns; 128 } 129 130 /** 131 * kernfs_mount_ns - kernfs mount helper 132 * @fs_type: file_system_type of the fs being mounted 133 * @flags: mount flags specified for the mount 134 * @root: kernfs_root of the hierarchy being mounted 135 * @new_sb_created: tell the caller if we allocated a new superblock 136 * @ns: optional namespace tag of the mount 137 * 138 * This is to be called from each kernfs user's file_system_type->mount() 139 * implementation, which should pass through the specified @fs_type and 140 * @flags, and specify the hierarchy and namespace tag to mount via @root 141 * and @ns, respectively. 142 * 143 * The return value can be passed to the vfs layer verbatim. 144 */ 145 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, 146 struct kernfs_root *root, bool *new_sb_created, 147 const void *ns) 148 { 149 struct super_block *sb; 150 struct kernfs_super_info *info; 151 int error; 152 153 info = kzalloc(sizeof(*info), GFP_KERNEL); 154 if (!info) 155 return ERR_PTR(-ENOMEM); 156 157 info->root = root; 158 info->ns = ns; 159 160 sb = sget(fs_type, kernfs_test_super, kernfs_set_super, flags, info); 161 if (IS_ERR(sb) || sb->s_fs_info != info) 162 kfree(info); 163 if (IS_ERR(sb)) 164 return ERR_CAST(sb); 165 166 if (new_sb_created) 167 *new_sb_created = !sb->s_root; 168 169 if (!sb->s_root) { 170 struct kernfs_super_info *info = kernfs_info(sb); 171 172 error = kernfs_fill_super(sb); 173 if (error) { 174 deactivate_locked_super(sb); 175 return ERR_PTR(error); 176 } 177 sb->s_flags |= MS_ACTIVE; 178 179 mutex_lock(&kernfs_mutex); 180 list_add(&info->node, &root->supers); 181 mutex_unlock(&kernfs_mutex); 182 } 183 184 return dget(sb->s_root); 185 } 186 187 /** 188 * kernfs_kill_sb - kill_sb for kernfs 189 * @sb: super_block being killed 190 * 191 * This can be used directly for file_system_type->kill_sb(). If a kernfs 192 * user needs extra cleanup, it can implement its own kill_sb() and call 193 * this function at the end. 194 */ 195 void kernfs_kill_sb(struct super_block *sb) 196 { 197 struct kernfs_super_info *info = kernfs_info(sb); 198 struct kernfs_node *root_kn = sb->s_root->d_fsdata; 199 200 mutex_lock(&kernfs_mutex); 201 list_del(&info->node); 202 mutex_unlock(&kernfs_mutex); 203 204 /* 205 * Remove the superblock from fs_supers/s_instances 206 * so we can't find it, before freeing kernfs_super_info. 207 */ 208 kill_anon_super(sb); 209 kfree(info); 210 kernfs_put(root_kn); 211 } 212 213 void __init kernfs_init(void) 214 { 215 kernfs_node_cache = kmem_cache_create("kernfs_node_cache", 216 sizeof(struct kernfs_node), 217 0, SLAB_PANIC, NULL); 218 kernfs_inode_init(); 219 } 220