1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * fs/sysfs/symlink.c - sysfs symlink 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 #include <linux/fs.h> 13 #include <linux/module.h> 14 #include <linux/kobject.h> 15 #include <linux/mutex.h> 16 #include <linux/security.h> 17 18 #include "sysfs.h" 19 20 static int sysfs_do_create_link_sd(struct kernfs_node *parent, 21 struct kobject *target_kobj, 22 const char *name, int warn) 23 { 24 struct kernfs_node *kn, *target = NULL; 25 26 BUG_ON(!name || !parent); 27 28 /* 29 * We don't own @target_kobj and it may be removed at any time. 30 * Synchronize using sysfs_symlink_target_lock. See 31 * sysfs_remove_dir() for details. 32 */ 33 spin_lock(&sysfs_symlink_target_lock); 34 if (target_kobj->sd) { 35 target = target_kobj->sd; 36 kernfs_get(target); 37 } 38 spin_unlock(&sysfs_symlink_target_lock); 39 40 if (!target) 41 return -ENOENT; 42 43 kn = kernfs_create_link(parent, name, target); 44 kernfs_put(target); 45 46 if (!IS_ERR(kn)) 47 return 0; 48 49 if (warn && PTR_ERR(kn) == -EEXIST) 50 sysfs_warn_dup(parent, name); 51 return PTR_ERR(kn); 52 } 53 54 /** 55 * sysfs_create_link_sd - create symlink to a given object. 56 * @kn: directory we're creating the link in. 57 * @target: object we're pointing to. 58 * @name: name of the symlink. 59 */ 60 int sysfs_create_link_sd(struct kernfs_node *kn, struct kobject *target, 61 const char *name) 62 { 63 return sysfs_do_create_link_sd(kn, target, name, 1); 64 } 65 66 static int sysfs_do_create_link(struct kobject *kobj, struct kobject *target, 67 const char *name, int warn) 68 { 69 struct kernfs_node *parent = NULL; 70 71 if (!kobj) 72 parent = sysfs_root_kn; 73 else 74 parent = kobj->sd; 75 76 if (!parent) 77 return -EFAULT; 78 79 return sysfs_do_create_link_sd(parent, target, name, warn); 80 } 81 82 /** 83 * sysfs_create_link - create symlink between two objects. 84 * @kobj: object whose directory we're creating the link in. 85 * @target: object we're pointing to. 86 * @name: name of the symlink. 87 */ 88 int sysfs_create_link(struct kobject *kobj, struct kobject *target, 89 const char *name) 90 { 91 return sysfs_do_create_link(kobj, target, name, 1); 92 } 93 EXPORT_SYMBOL_GPL(sysfs_create_link); 94 95 /** 96 * sysfs_create_link_nowarn - create symlink between two objects. 97 * @kobj: object whose directory we're creating the link in. 98 * @target: object we're pointing to. 99 * @name: name of the symlink. 100 * 101 * This function does the same as sysfs_create_link(), but it 102 * doesn't warn if the link already exists. 103 */ 104 int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target, 105 const char *name) 106 { 107 return sysfs_do_create_link(kobj, target, name, 0); 108 } 109 110 /** 111 * sysfs_delete_link - remove symlink in object's directory. 112 * @kobj: object we're acting for. 113 * @targ: object we're pointing to. 114 * @name: name of the symlink to remove. 115 * 116 * Unlike sysfs_remove_link sysfs_delete_link has enough information 117 * to successfully delete symlinks in tagged directories. 118 */ 119 void sysfs_delete_link(struct kobject *kobj, struct kobject *targ, 120 const char *name) 121 { 122 const void *ns = NULL; 123 124 /* 125 * We don't own @target and it may be removed at any time. 126 * Synchronize using sysfs_symlink_target_lock. See 127 * sysfs_remove_dir() for details. 128 */ 129 spin_lock(&sysfs_symlink_target_lock); 130 if (targ->sd && kernfs_ns_enabled(kobj->sd)) 131 ns = targ->sd->ns; 132 spin_unlock(&sysfs_symlink_target_lock); 133 kernfs_remove_by_name_ns(kobj->sd, name, ns); 134 } 135 136 /** 137 * sysfs_remove_link - remove symlink in object's directory. 138 * @kobj: object we're acting for. 139 * @name: name of the symlink to remove. 140 */ 141 void sysfs_remove_link(struct kobject *kobj, const char *name) 142 { 143 struct kernfs_node *parent = NULL; 144 145 if (!kobj) 146 parent = sysfs_root_kn; 147 else 148 parent = kobj->sd; 149 150 kernfs_remove_by_name(parent, name); 151 } 152 EXPORT_SYMBOL_GPL(sysfs_remove_link); 153 154 /** 155 * sysfs_rename_link_ns - rename symlink in object's directory. 156 * @kobj: object we're acting for. 157 * @targ: object we're pointing to. 158 * @old: previous name of the symlink. 159 * @new: new name of the symlink. 160 * @new_ns: new namespace of the symlink. 161 * 162 * A helper function for the common rename symlink idiom. 163 */ 164 int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *targ, 165 const char *old, const char *new, const void *new_ns) 166 { 167 struct kernfs_node *parent, *kn = NULL; 168 const void *old_ns = NULL; 169 int result; 170 171 if (!kobj) 172 parent = sysfs_root_kn; 173 else 174 parent = kobj->sd; 175 176 if (targ->sd) 177 old_ns = targ->sd->ns; 178 179 result = -ENOENT; 180 kn = kernfs_find_and_get_ns(parent, old, old_ns); 181 if (!kn) 182 goto out; 183 184 result = -EINVAL; 185 if (kernfs_type(kn) != KERNFS_LINK) 186 goto out; 187 if (kn->symlink.target_kn->priv != targ) 188 goto out; 189 190 result = kernfs_rename_ns(kn, parent, new, new_ns); 191 192 out: 193 kernfs_put(kn); 194 return result; 195 } 196 EXPORT_SYMBOL_GPL(sysfs_rename_link_ns); 197