1 /* 2 * fs/sysfs/dir.c - sysfs core and dir operation implementation 3 * 4 * Copyright (c) 2001-3 Patrick Mochel 5 * Copyright (c) 2007 SUSE Linux Products GmbH 6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de> 7 * 8 * This file is released under the GPLv2. 9 * 10 * Please see Documentation/filesystems/sysfs.txt for more information. 11 */ 12 13 #undef DEBUG 14 15 #include <linux/fs.h> 16 #include <linux/kobject.h> 17 #include <linux/slab.h> 18 #include "sysfs.h" 19 20 DEFINE_SPINLOCK(sysfs_symlink_target_lock); 21 22 void sysfs_warn_dup(struct kernfs_node *parent, const char *name) 23 { 24 char *buf, *path = NULL; 25 26 buf = kzalloc(PATH_MAX, GFP_KERNEL); 27 if (buf) 28 path = kernfs_path(parent, buf, PATH_MAX); 29 30 WARN(1, KERN_WARNING "sysfs: cannot create duplicate filename '%s/%s'\n", 31 path, name); 32 33 kfree(buf); 34 } 35 36 /** 37 * sysfs_create_dir_ns - create a directory for an object with a namespace tag 38 * @kobj: object we're creating directory for 39 * @ns: the namespace tag to use 40 */ 41 int sysfs_create_dir_ns(struct kobject *kobj, const void *ns) 42 { 43 struct kernfs_node *parent, *kn; 44 45 BUG_ON(!kobj); 46 47 if (kobj->parent) 48 parent = kobj->parent->sd; 49 else 50 parent = sysfs_root_kn; 51 52 if (!parent) 53 return -ENOENT; 54 55 kn = kernfs_create_dir_ns(parent, kobject_name(kobj), 56 S_IRWXU | S_IRUGO | S_IXUGO, kobj, ns); 57 if (IS_ERR(kn)) { 58 if (PTR_ERR(kn) == -EEXIST) 59 sysfs_warn_dup(parent, kobject_name(kobj)); 60 return PTR_ERR(kn); 61 } 62 63 kobj->sd = kn; 64 return 0; 65 } 66 67 /** 68 * sysfs_remove_dir - remove an object's directory. 69 * @kobj: object. 70 * 71 * The only thing special about this is that we remove any files in 72 * the directory before we remove the directory, and we've inlined 73 * what used to be sysfs_rmdir() below, instead of calling separately. 74 */ 75 void sysfs_remove_dir(struct kobject *kobj) 76 { 77 struct kernfs_node *kn = kobj->sd; 78 79 /* 80 * In general, kboject owner is responsible for ensuring removal 81 * doesn't race with other operations and sysfs doesn't provide any 82 * protection; however, when @kobj is used as a symlink target, the 83 * symlinking entity usually doesn't own @kobj and thus has no 84 * control over removal. @kobj->sd may be removed anytime 85 * and symlink code may end up dereferencing an already freed node. 86 * 87 * sysfs_symlink_target_lock synchronizes @kobj->sd 88 * disassociation against symlink operations so that symlink code 89 * can safely dereference @kobj->sd. 90 */ 91 spin_lock(&sysfs_symlink_target_lock); 92 kobj->sd = NULL; 93 spin_unlock(&sysfs_symlink_target_lock); 94 95 if (kn) { 96 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR); 97 kernfs_remove(kn); 98 } 99 } 100 101 int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name, 102 const void *new_ns) 103 { 104 struct kernfs_node *parent; 105 int ret; 106 107 parent = kernfs_get_parent(kobj->sd); 108 ret = kernfs_rename_ns(kobj->sd, parent, new_name, new_ns); 109 kernfs_put(parent); 110 return ret; 111 } 112 113 int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj, 114 const void *new_ns) 115 { 116 struct kernfs_node *kn = kobj->sd; 117 struct kernfs_node *new_parent; 118 119 new_parent = new_parent_kobj && new_parent_kobj->sd ? 120 new_parent_kobj->sd : sysfs_root_kn; 121 122 return kernfs_rename_ns(kn, new_parent, kn->name, new_ns); 123 } 124