| 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 | #include <linux/namei.h> |
| 18 | #include <linux/seq_file.h> |
| 19 | |
| 20 | #include "kernfs-internal.h" |
| 21 | |
| 22 | struct kmem_cache *kernfs_node_cache; |
| 23 | |
| 24 | static int kernfs_sop_remount_fs(struct super_block *sb, int *flags, char *data) |
| 25 | { |
| 26 | struct kernfs_root *root = kernfs_info(sb)->root; |
| 27 | struct kernfs_syscall_ops *scops = root->syscall_ops; |
| 28 | |
| 29 | if (scops && scops->remount_fs) |
| 30 | return scops->remount_fs(root, flags, data); |
| 31 | return 0; |
| 32 | } |
| 33 | |
| 34 | static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry) |
| 35 | { |
| 36 | struct kernfs_root *root = kernfs_root(dentry->d_fsdata); |
| 37 | struct kernfs_syscall_ops *scops = root->syscall_ops; |
| 38 | |
| 39 | if (scops && scops->show_options) |
| 40 | return scops->show_options(sf, root); |
| 41 | return 0; |
| 42 | } |
| 43 | |
| 44 | static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry) |
| 45 | { |
| 46 | struct kernfs_node *node = dentry->d_fsdata; |
| 47 | struct kernfs_root *root = kernfs_root(node); |
| 48 | struct kernfs_syscall_ops *scops = root->syscall_ops; |
| 49 | |
| 50 | if (scops && scops->show_path) |
| 51 | return scops->show_path(sf, node, root); |
| 52 | |
| 53 | seq_dentry(sf, dentry, " \t\n\\"); |
| 54 | return 0; |
| 55 | } |
| 56 | |
| 57 | const struct super_operations kernfs_sops = { |
| 58 | .statfs = simple_statfs, |
| 59 | .drop_inode = generic_delete_inode, |
| 60 | .evict_inode = kernfs_evict_inode, |
| 61 | |
| 62 | .remount_fs = kernfs_sop_remount_fs, |
| 63 | .show_options = kernfs_sop_show_options, |
| 64 | .show_path = kernfs_sop_show_path, |
| 65 | }; |
| 66 | |
| 67 | /** |
| 68 | * kernfs_root_from_sb - determine kernfs_root associated with a super_block |
| 69 | * @sb: the super_block in question |
| 70 | * |
| 71 | * Return the kernfs_root associated with @sb. If @sb is not a kernfs one, |
| 72 | * %NULL is returned. |
| 73 | */ |
| 74 | struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) |
| 75 | { |
| 76 | if (sb->s_op == &kernfs_sops) |
| 77 | return kernfs_info(sb)->root; |
| 78 | return NULL; |
| 79 | } |
| 80 | |
| 81 | /* |
| 82 | * find the next ancestor in the path down to @child, where @parent was the |
| 83 | * ancestor whose descendant we want to find. |
| 84 | * |
| 85 | * Say the path is /a/b/c/d. @child is d, @parent is NULL. We return the root |
| 86 | * node. If @parent is b, then we return the node for c. |
| 87 | * Passing in d as @parent is not ok. |
| 88 | */ |
| 89 | static struct kernfs_node *find_next_ancestor(struct kernfs_node *child, |
| 90 | struct kernfs_node *parent) |
| 91 | { |
| 92 | if (child == parent) { |
| 93 | pr_crit_once("BUG in find_next_ancestor: called with parent == child"); |
| 94 | return NULL; |
| 95 | } |
| 96 | |
| 97 | while (child->parent != parent) { |
| 98 | if (!child->parent) |
| 99 | return NULL; |
| 100 | child = child->parent; |
| 101 | } |
| 102 | |
| 103 | return child; |
| 104 | } |
| 105 | |
| 106 | /** |
| 107 | * kernfs_node_dentry - get a dentry for the given kernfs_node |
| 108 | * @kn: kernfs_node for which a dentry is needed |
| 109 | * @sb: the kernfs super_block |
| 110 | */ |
| 111 | struct dentry *kernfs_node_dentry(struct kernfs_node *kn, |
| 112 | struct super_block *sb) |
| 113 | { |
| 114 | struct dentry *dentry; |
| 115 | struct kernfs_node *knparent = NULL; |
| 116 | |
| 117 | BUG_ON(sb->s_op != &kernfs_sops); |
| 118 | |
| 119 | dentry = dget(sb->s_root); |
| 120 | |
| 121 | /* Check if this is the root kernfs_node */ |
| 122 | if (!kn->parent) |
| 123 | return dentry; |
| 124 | |
| 125 | knparent = find_next_ancestor(kn, NULL); |
| 126 | if (WARN_ON(!knparent)) |
| 127 | return ERR_PTR(-EINVAL); |
| 128 | |
| 129 | do { |
| 130 | struct dentry *dtmp; |
| 131 | struct kernfs_node *kntmp; |
| 132 | |
| 133 | if (kn == knparent) |
| 134 | return dentry; |
| 135 | kntmp = find_next_ancestor(kn, knparent); |
| 136 | if (WARN_ON(!kntmp)) |
| 137 | return ERR_PTR(-EINVAL); |
| 138 | mutex_lock(&d_inode(dentry)->i_mutex); |
| 139 | dtmp = lookup_one_len(kntmp->name, dentry, strlen(kntmp->name)); |
| 140 | mutex_unlock(&d_inode(dentry)->i_mutex); |
| 141 | dput(dentry); |
| 142 | if (IS_ERR(dtmp)) |
| 143 | return dtmp; |
| 144 | knparent = kntmp; |
| 145 | dentry = dtmp; |
| 146 | } while (true); |
| 147 | } |
| 148 | |
| 149 | static int kernfs_fill_super(struct super_block *sb, unsigned long magic) |
| 150 | { |
| 151 | struct kernfs_super_info *info = kernfs_info(sb); |
| 152 | struct inode *inode; |
| 153 | struct dentry *root; |
| 154 | |
| 155 | info->sb = sb; |
| 156 | sb->s_blocksize = PAGE_SIZE; |
| 157 | sb->s_blocksize_bits = PAGE_SHIFT; |
| 158 | sb->s_magic = magic; |
| 159 | sb->s_op = &kernfs_sops; |
| 160 | sb->s_time_gran = 1; |
| 161 | |
| 162 | /* get root inode, initialize and unlock it */ |
| 163 | mutex_lock(&kernfs_mutex); |
| 164 | inode = kernfs_get_inode(sb, info->root->kn); |
| 165 | mutex_unlock(&kernfs_mutex); |
| 166 | if (!inode) { |
| 167 | pr_debug("kernfs: could not get root inode\n"); |
| 168 | return -ENOMEM; |
| 169 | } |
| 170 | |
| 171 | /* instantiate and link root dentry */ |
| 172 | root = d_make_root(inode); |
| 173 | if (!root) { |
| 174 | pr_debug("%s: could not get root dentry!\n", __func__); |
| 175 | return -ENOMEM; |
| 176 | } |
| 177 | kernfs_get(info->root->kn); |
| 178 | root->d_fsdata = info->root->kn; |
| 179 | sb->s_root = root; |
| 180 | sb->s_d_op = &kernfs_dops; |
| 181 | return 0; |
| 182 | } |
| 183 | |
| 184 | static int kernfs_test_super(struct super_block *sb, void *data) |
| 185 | { |
| 186 | struct kernfs_super_info *sb_info = kernfs_info(sb); |
| 187 | struct kernfs_super_info *info = data; |
| 188 | |
| 189 | return sb_info->root == info->root && sb_info->ns == info->ns; |
| 190 | } |
| 191 | |
| 192 | static int kernfs_set_super(struct super_block *sb, void *data) |
| 193 | { |
| 194 | int error; |
| 195 | error = set_anon_super(sb, data); |
| 196 | if (!error) |
| 197 | sb->s_fs_info = data; |
| 198 | return error; |
| 199 | } |
| 200 | |
| 201 | /** |
| 202 | * kernfs_super_ns - determine the namespace tag of a kernfs super_block |
| 203 | * @sb: super_block of interest |
| 204 | * |
| 205 | * Return the namespace tag associated with kernfs super_block @sb. |
| 206 | */ |
| 207 | const void *kernfs_super_ns(struct super_block *sb) |
| 208 | { |
| 209 | struct kernfs_super_info *info = kernfs_info(sb); |
| 210 | |
| 211 | return info->ns; |
| 212 | } |
| 213 | |
| 214 | /** |
| 215 | * kernfs_mount_ns - kernfs mount helper |
| 216 | * @fs_type: file_system_type of the fs being mounted |
| 217 | * @flags: mount flags specified for the mount |
| 218 | * @root: kernfs_root of the hierarchy being mounted |
| 219 | * @magic: file system specific magic number |
| 220 | * @new_sb_created: tell the caller if we allocated a new superblock |
| 221 | * @ns: optional namespace tag of the mount |
| 222 | * |
| 223 | * This is to be called from each kernfs user's file_system_type->mount() |
| 224 | * implementation, which should pass through the specified @fs_type and |
| 225 | * @flags, and specify the hierarchy and namespace tag to mount via @root |
| 226 | * and @ns, respectively. |
| 227 | * |
| 228 | * The return value can be passed to the vfs layer verbatim. |
| 229 | */ |
| 230 | struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, |
| 231 | struct kernfs_root *root, unsigned long magic, |
| 232 | bool *new_sb_created, const void *ns) |
| 233 | { |
| 234 | struct super_block *sb; |
| 235 | struct kernfs_super_info *info; |
| 236 | int error; |
| 237 | |
| 238 | info = kzalloc(sizeof(*info), GFP_KERNEL); |
| 239 | if (!info) |
| 240 | return ERR_PTR(-ENOMEM); |
| 241 | |
| 242 | info->root = root; |
| 243 | info->ns = ns; |
| 244 | |
| 245 | sb = sget(fs_type, kernfs_test_super, kernfs_set_super, flags, info); |
| 246 | if (IS_ERR(sb) || sb->s_fs_info != info) |
| 247 | kfree(info); |
| 248 | if (IS_ERR(sb)) |
| 249 | return ERR_CAST(sb); |
| 250 | |
| 251 | if (new_sb_created) |
| 252 | *new_sb_created = !sb->s_root; |
| 253 | |
| 254 | if (!sb->s_root) { |
| 255 | struct kernfs_super_info *info = kernfs_info(sb); |
| 256 | |
| 257 | error = kernfs_fill_super(sb, magic); |
| 258 | if (error) { |
| 259 | deactivate_locked_super(sb); |
| 260 | return ERR_PTR(error); |
| 261 | } |
| 262 | sb->s_flags |= MS_ACTIVE; |
| 263 | |
| 264 | mutex_lock(&kernfs_mutex); |
| 265 | list_add(&info->node, &root->supers); |
| 266 | mutex_unlock(&kernfs_mutex); |
| 267 | } |
| 268 | |
| 269 | return dget(sb->s_root); |
| 270 | } |
| 271 | |
| 272 | /** |
| 273 | * kernfs_kill_sb - kill_sb for kernfs |
| 274 | * @sb: super_block being killed |
| 275 | * |
| 276 | * This can be used directly for file_system_type->kill_sb(). If a kernfs |
| 277 | * user needs extra cleanup, it can implement its own kill_sb() and call |
| 278 | * this function at the end. |
| 279 | */ |
| 280 | void kernfs_kill_sb(struct super_block *sb) |
| 281 | { |
| 282 | struct kernfs_super_info *info = kernfs_info(sb); |
| 283 | struct kernfs_node *root_kn = sb->s_root->d_fsdata; |
| 284 | |
| 285 | mutex_lock(&kernfs_mutex); |
| 286 | list_del(&info->node); |
| 287 | mutex_unlock(&kernfs_mutex); |
| 288 | |
| 289 | /* |
| 290 | * Remove the superblock from fs_supers/s_instances |
| 291 | * so we can't find it, before freeing kernfs_super_info. |
| 292 | */ |
| 293 | kill_anon_super(sb); |
| 294 | kfree(info); |
| 295 | kernfs_put(root_kn); |
| 296 | } |
| 297 | |
| 298 | /** |
| 299 | * kernfs_pin_sb: try to pin the superblock associated with a kernfs_root |
| 300 | * @kernfs_root: the kernfs_root in question |
| 301 | * @ns: the namespace tag |
| 302 | * |
| 303 | * Pin the superblock so the superblock won't be destroyed in subsequent |
| 304 | * operations. This can be used to block ->kill_sb() which may be useful |
| 305 | * for kernfs users which dynamically manage superblocks. |
| 306 | * |
| 307 | * Returns NULL if there's no superblock associated to this kernfs_root, or |
| 308 | * -EINVAL if the superblock is being freed. |
| 309 | */ |
| 310 | struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns) |
| 311 | { |
| 312 | struct kernfs_super_info *info; |
| 313 | struct super_block *sb = NULL; |
| 314 | |
| 315 | mutex_lock(&kernfs_mutex); |
| 316 | list_for_each_entry(info, &root->supers, node) { |
| 317 | if (info->ns == ns) { |
| 318 | sb = info->sb; |
| 319 | if (!atomic_inc_not_zero(&info->sb->s_active)) |
| 320 | sb = ERR_PTR(-EINVAL); |
| 321 | break; |
| 322 | } |
| 323 | } |
| 324 | mutex_unlock(&kernfs_mutex); |
| 325 | return sb; |
| 326 | } |
| 327 | |
| 328 | void __init kernfs_init(void) |
| 329 | { |
| 330 | kernfs_node_cache = kmem_cache_create("kernfs_node_cache", |
| 331 | sizeof(struct kernfs_node), |
| 332 | 0, SLAB_PANIC, NULL); |
| 333 | } |