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