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