mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
162 lines
4.1 KiB
162 lines
4.1 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* fs/sysfs/dir.c - sysfs core and dir operation implementation |
|
* |
|
* Copyright (c) 2001-3 Patrick Mochel |
|
* Copyright (c) 2007 SUSE Linux Products GmbH |
|
* Copyright (c) 2007 Tejun Heo <[email protected]> |
|
* |
|
* Please see Documentation/filesystems/sysfs.rst for more information. |
|
*/ |
|
|
|
#define pr_fmt(fmt) "sysfs: " fmt |
|
|
|
#include <linux/fs.h> |
|
#include <linux/kobject.h> |
|
#include <linux/slab.h> |
|
#include "sysfs.h" |
|
|
|
DEFINE_SPINLOCK(sysfs_symlink_target_lock); |
|
|
|
void sysfs_warn_dup(struct kernfs_node *parent, const char *name) |
|
{ |
|
char *buf; |
|
|
|
buf = kzalloc(PATH_MAX, GFP_KERNEL); |
|
if (buf) |
|
kernfs_path(parent, buf, PATH_MAX); |
|
|
|
pr_warn("cannot create duplicate filename '%s/%s'\n", buf, name); |
|
dump_stack(); |
|
|
|
kfree(buf); |
|
} |
|
|
|
/** |
|
* sysfs_create_dir_ns - create a directory for an object with a namespace tag |
|
* @kobj: object we're creating directory for |
|
* @ns: the namespace tag to use |
|
*/ |
|
int sysfs_create_dir_ns(struct kobject *kobj, const void *ns) |
|
{ |
|
struct kernfs_node *parent, *kn; |
|
kuid_t uid; |
|
kgid_t gid; |
|
|
|
if (WARN_ON(!kobj)) |
|
return -EINVAL; |
|
|
|
if (kobj->parent) |
|
parent = kobj->parent->sd; |
|
else |
|
parent = sysfs_root_kn; |
|
|
|
if (!parent) |
|
return -ENOENT; |
|
|
|
kobject_get_ownership(kobj, &uid, &gid); |
|
|
|
kn = kernfs_create_dir_ns(parent, kobject_name(kobj), |
|
S_IRWXU | S_IRUGO | S_IXUGO, uid, gid, |
|
kobj, ns); |
|
if (IS_ERR(kn)) { |
|
if (PTR_ERR(kn) == -EEXIST) |
|
sysfs_warn_dup(parent, kobject_name(kobj)); |
|
return PTR_ERR(kn); |
|
} |
|
|
|
kobj->sd = kn; |
|
return 0; |
|
} |
|
|
|
/** |
|
* sysfs_remove_dir - remove an object's directory. |
|
* @kobj: object. |
|
* |
|
* The only thing special about this is that we remove any files in |
|
* the directory before we remove the directory, and we've inlined |
|
* what used to be sysfs_rmdir() below, instead of calling separately. |
|
*/ |
|
void sysfs_remove_dir(struct kobject *kobj) |
|
{ |
|
struct kernfs_node *kn = kobj->sd; |
|
|
|
/* |
|
* In general, kboject owner is responsible for ensuring removal |
|
* doesn't race with other operations and sysfs doesn't provide any |
|
* protection; however, when @kobj is used as a symlink target, the |
|
* symlinking entity usually doesn't own @kobj and thus has no |
|
* control over removal. @kobj->sd may be removed anytime |
|
* and symlink code may end up dereferencing an already freed node. |
|
* |
|
* sysfs_symlink_target_lock synchronizes @kobj->sd |
|
* disassociation against symlink operations so that symlink code |
|
* can safely dereference @kobj->sd. |
|
*/ |
|
spin_lock(&sysfs_symlink_target_lock); |
|
kobj->sd = NULL; |
|
spin_unlock(&sysfs_symlink_target_lock); |
|
|
|
if (kn) { |
|
WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR); |
|
kernfs_remove(kn); |
|
} |
|
} |
|
|
|
int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name, |
|
const void *new_ns) |
|
{ |
|
struct kernfs_node *parent; |
|
int ret; |
|
|
|
parent = kernfs_get_parent(kobj->sd); |
|
ret = kernfs_rename_ns(kobj->sd, parent, new_name, new_ns); |
|
kernfs_put(parent); |
|
return ret; |
|
} |
|
|
|
int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj, |
|
const void *new_ns) |
|
{ |
|
struct kernfs_node *kn = kobj->sd; |
|
struct kernfs_node *new_parent; |
|
|
|
new_parent = new_parent_kobj && new_parent_kobj->sd ? |
|
new_parent_kobj->sd : sysfs_root_kn; |
|
|
|
return kernfs_rename_ns(kn, new_parent, kn->name, new_ns); |
|
} |
|
|
|
/** |
|
* sysfs_create_mount_point - create an always empty directory |
|
* @parent_kobj: kobject that will contain this always empty directory |
|
* @name: The name of the always empty directory to add |
|
*/ |
|
int sysfs_create_mount_point(struct kobject *parent_kobj, const char *name) |
|
{ |
|
struct kernfs_node *kn, *parent = parent_kobj->sd; |
|
|
|
kn = kernfs_create_empty_dir(parent, name); |
|
if (IS_ERR(kn)) { |
|
if (PTR_ERR(kn) == -EEXIST) |
|
sysfs_warn_dup(parent, name); |
|
return PTR_ERR(kn); |
|
} |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(sysfs_create_mount_point); |
|
|
|
/** |
|
* sysfs_remove_mount_point - remove an always empty directory. |
|
* @parent_kobj: kobject that will contain this always empty directory |
|
* @name: The name of the always empty directory to remove |
|
* |
|
*/ |
|
void sysfs_remove_mount_point(struct kobject *parent_kobj, const char *name) |
|
{ |
|
struct kernfs_node *parent = parent_kobj->sd; |
|
|
|
kernfs_remove_by_name_ns(parent, name, NULL); |
|
} |
|
EXPORT_SYMBOL_GPL(sysfs_remove_mount_point);
|
|
|