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 sb->s_blocksize = PAGE_CACHE_SIZE; 72 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 73 sb->s_magic = SYSFS_MAGIC; 74 sb->s_op = &kernfs_sops; 75 sb->s_time_gran = 1; 76 77 /* get root inode, initialize and unlock it */ 78 mutex_lock(&kernfs_mutex); 79 inode = kernfs_get_inode(sb, info->root->kn); 80 mutex_unlock(&kernfs_mutex); 81 if (!inode) { 82 pr_debug("kernfs: could not get root inode\n"); 83 return -ENOMEM; 84 } 85 86 /* instantiate and link root dentry */ 87 root = d_make_root(inode); 88 if (!root) { 89 pr_debug("%s: could not get root dentry!\n", __func__); 90 return -ENOMEM; 91 } 92 kernfs_get(info->root->kn); 93 root->d_fsdata = info->root->kn; 94 sb->s_root = root; 95 sb->s_d_op = &kernfs_dops; 96 return 0; 97 } 98 99 static int kernfs_test_super(struct super_block *sb, void *data) 100 { 101 struct kernfs_super_info *sb_info = kernfs_info(sb); 102 struct kernfs_super_info *info = data; 103 104 return sb_info->root == info->root && sb_info->ns == info->ns; 105 } 106 107 static int kernfs_set_super(struct super_block *sb, void *data) 108 { 109 int error; 110 error = set_anon_super(sb, data); 111 if (!error) 112 sb->s_fs_info = data; 113 return error; 114 } 115 116 /** 117 * kernfs_super_ns - determine the namespace tag of a kernfs super_block 118 * @sb: super_block of interest 119 * 120 * Return the namespace tag associated with kernfs super_block @sb. 121 */ 122 const void *kernfs_super_ns(struct super_block *sb) 123 { 124 struct kernfs_super_info *info = kernfs_info(sb); 125 126 return info->ns; 127 } 128 129 /** 130 * kernfs_mount_ns - kernfs mount helper 131 * @fs_type: file_system_type of the fs being mounted 132 * @flags: mount flags specified for the mount 133 * @root: kernfs_root of the hierarchy being mounted 134 * @new_sb_created: tell the caller if we allocated a new superblock 135 * @ns: optional namespace tag of the mount 136 * 137 * This is to be called from each kernfs user's file_system_type->mount() 138 * implementation, which should pass through the specified @fs_type and 139 * @flags, and specify the hierarchy and namespace tag to mount via @root 140 * and @ns, respectively. 141 * 142 * The return value can be passed to the vfs layer verbatim. 143 */ 144 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, 145 struct kernfs_root *root, bool *new_sb_created, 146 const void *ns) 147 { 148 struct super_block *sb; 149 struct kernfs_super_info *info; 150 int error; 151 152 info = kzalloc(sizeof(*info), GFP_KERNEL); 153 if (!info) 154 return ERR_PTR(-ENOMEM); 155 156 info->root = root; 157 info->ns = ns; 158 159 sb = sget(fs_type, kernfs_test_super, kernfs_set_super, flags, info); 160 if (IS_ERR(sb) || sb->s_fs_info != info) 161 kfree(info); 162 if (IS_ERR(sb)) 163 return ERR_CAST(sb); 164 165 if (new_sb_created) 166 *new_sb_created = !sb->s_root; 167 168 if (!sb->s_root) { 169 error = kernfs_fill_super(sb); 170 if (error) { 171 deactivate_locked_super(sb); 172 return ERR_PTR(error); 173 } 174 sb->s_flags |= MS_ACTIVE; 175 } 176 177 return dget(sb->s_root); 178 } 179 180 /** 181 * kernfs_kill_sb - kill_sb for kernfs 182 * @sb: super_block being killed 183 * 184 * This can be used directly for file_system_type->kill_sb(). If a kernfs 185 * user needs extra cleanup, it can implement its own kill_sb() and call 186 * this function at the end. 187 */ 188 void kernfs_kill_sb(struct super_block *sb) 189 { 190 struct kernfs_super_info *info = kernfs_info(sb); 191 struct kernfs_node *root_kn = sb->s_root->d_fsdata; 192 193 /* 194 * Remove the superblock from fs_supers/s_instances 195 * so we can't find it, before freeing kernfs_super_info. 196 */ 197 kill_anon_super(sb); 198 kfree(info); 199 kernfs_put(root_kn); 200 } 201 202 void __init kernfs_init(void) 203 { 204 kernfs_node_cache = kmem_cache_create("kernfs_node_cache", 205 sizeof(struct kernfs_node), 206 0, SLAB_PANIC, NULL); 207 kernfs_inode_init(); 208 } 209