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