Loading...
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
20DEFINE_SPINLOCK(sysfs_symlink_target_lock);
21
22void sysfs_warn_dup(struct kernfs_node *parent, const char *name)
23{
24 char *buf;
25
26 buf = kzalloc(PATH_MAX, GFP_KERNEL);
27 if (buf)
28 kernfs_path(parent, buf, PATH_MAX);
29
30 WARN(1, KERN_WARNING "sysfs: cannot create duplicate filename '%s/%s'\n",
31 buf, 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 */
41int 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 */
75void 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
101int 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
113int 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
125/**
126 * sysfs_create_mount_point - create an always empty directory
127 * @parent_kobj: kobject that will contain this always empty directory
128 * @name: The name of the always empty directory to add
129 */
130int sysfs_create_mount_point(struct kobject *parent_kobj, const char *name)
131{
132 struct kernfs_node *kn, *parent = parent_kobj->sd;
133
134 kn = kernfs_create_empty_dir(parent, name);
135 if (IS_ERR(kn)) {
136 if (PTR_ERR(kn) == -EEXIST)
137 sysfs_warn_dup(parent, name);
138 return PTR_ERR(kn);
139 }
140
141 return 0;
142}
143EXPORT_SYMBOL_GPL(sysfs_create_mount_point);
144
145/**
146 * sysfs_remove_mount_point - remove an always empty directory.
147 * @parent_kobj: kobject that will contain this always empty directory
148 * @name: The name of the always empty directory to remove
149 *
150 */
151void sysfs_remove_mount_point(struct kobject *parent_kobj, const char *name)
152{
153 struct kernfs_node *parent = parent_kobj->sd;
154
155 kernfs_remove_by_name_ns(parent, name, NULL);
156}
157EXPORT_SYMBOL_GPL(sysfs_remove_mount_point);
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.rst 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
19DEFINE_SPINLOCK(sysfs_symlink_target_lock);
20
21void 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 */
40int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
41{
42 struct kernfs_node *parent, *kn;
43 kuid_t uid;
44 kgid_t gid;
45
46 if (WARN_ON(!kobj))
47 return -EINVAL;
48
49 if (kobj->parent)
50 parent = kobj->parent->sd;
51 else
52 parent = sysfs_root_kn;
53
54 if (!parent)
55 return -ENOENT;
56
57 kobject_get_ownership(kobj, &uid, &gid);
58
59 kn = kernfs_create_dir_ns(parent, kobject_name(kobj),
60 S_IRWXU | S_IRUGO | S_IXUGO, uid, gid,
61 kobj, ns);
62 if (IS_ERR(kn)) {
63 if (PTR_ERR(kn) == -EEXIST)
64 sysfs_warn_dup(parent, kobject_name(kobj));
65 return PTR_ERR(kn);
66 }
67
68 kobj->sd = kn;
69 return 0;
70}
71
72/**
73 * sysfs_remove_dir - remove an object's directory.
74 * @kobj: object.
75 *
76 * The only thing special about this is that we remove any files in
77 * the directory before we remove the directory, and we've inlined
78 * what used to be sysfs_rmdir() below, instead of calling separately.
79 */
80void sysfs_remove_dir(struct kobject *kobj)
81{
82 struct kernfs_node *kn = kobj->sd;
83
84 /*
85 * In general, kboject owner is responsible for ensuring removal
86 * doesn't race with other operations and sysfs doesn't provide any
87 * protection; however, when @kobj is used as a symlink target, the
88 * symlinking entity usually doesn't own @kobj and thus has no
89 * control over removal. @kobj->sd may be removed anytime
90 * and symlink code may end up dereferencing an already freed node.
91 *
92 * sysfs_symlink_target_lock synchronizes @kobj->sd
93 * disassociation against symlink operations so that symlink code
94 * can safely dereference @kobj->sd.
95 */
96 spin_lock(&sysfs_symlink_target_lock);
97 kobj->sd = NULL;
98 spin_unlock(&sysfs_symlink_target_lock);
99
100 if (kn) {
101 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
102 kernfs_remove(kn);
103 }
104}
105
106int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
107 const void *new_ns)
108{
109 struct kernfs_node *parent;
110 int ret;
111
112 parent = kernfs_get_parent(kobj->sd);
113 ret = kernfs_rename_ns(kobj->sd, parent, new_name, new_ns);
114 kernfs_put(parent);
115 return ret;
116}
117
118int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj,
119 const void *new_ns)
120{
121 struct kernfs_node *kn = kobj->sd;
122 struct kernfs_node *new_parent;
123
124 new_parent = new_parent_kobj && new_parent_kobj->sd ?
125 new_parent_kobj->sd : sysfs_root_kn;
126
127 return kernfs_rename_ns(kn, new_parent, kn->name, new_ns);
128}
129
130/**
131 * sysfs_create_mount_point - create an always empty directory
132 * @parent_kobj: kobject that will contain this always empty directory
133 * @name: The name of the always empty directory to add
134 */
135int sysfs_create_mount_point(struct kobject *parent_kobj, const char *name)
136{
137 struct kernfs_node *kn, *parent = parent_kobj->sd;
138
139 kn = kernfs_create_empty_dir(parent, name);
140 if (IS_ERR(kn)) {
141 if (PTR_ERR(kn) == -EEXIST)
142 sysfs_warn_dup(parent, name);
143 return PTR_ERR(kn);
144 }
145
146 return 0;
147}
148EXPORT_SYMBOL_GPL(sysfs_create_mount_point);
149
150/**
151 * sysfs_remove_mount_point - remove an always empty directory.
152 * @parent_kobj: kobject that will contain this always empty directory
153 * @name: The name of the always empty directory to remove
154 *
155 */
156void sysfs_remove_mount_point(struct kobject *parent_kobj, const char *name)
157{
158 struct kernfs_node *parent = parent_kobj->sd;
159
160 kernfs_remove_by_name_ns(parent, name, NULL);
161}
162EXPORT_SYMBOL_GPL(sysfs_remove_mount_point);