blob: 7fdf6a7b743663fe44a78ea12f9c9ec30eecfe5b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Tejun Heo6d66f5c2007-09-20 17:31:38 +09002 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
13#undef DEBUG
14
15#include <linux/fs.h>
16#include <linux/mount.h>
17#include <linux/module.h>
18#include <linux/kobject.h>
Christoph Hellwig5f45f1a2005-06-23 00:09:12 -070019#include <linux/namei.h>
Tejun Heo2b611bb2007-06-14 03:45:13 +090020#include <linux/idr.h>
Tejun Heo8619f972007-06-14 03:45:18 +090021#include <linux/completion.h>
Dave Young869512a2007-07-26 14:53:53 +000022#include <linux/mutex.h>
Robert P. J. Dayc6f87732008-03-13 22:41:52 -040023#include <linux/slab.h>
Eric W. Biederman4c3da222009-11-04 02:50:06 -080024#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "sysfs.h"
26
Tejun Heo3007e992007-06-14 04:27:23 +090027DEFINE_MUTEX(sysfs_mutex);
Roel Kluinf7a75f02007-10-16 23:30:25 -070028DEFINE_SPINLOCK(sysfs_assoc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Roel Kluinf7a75f02007-10-16 23:30:25 -070030static DEFINE_SPINLOCK(sysfs_ino_lock);
Tejun Heo2b611bb2007-06-14 03:45:13 +090031static DEFINE_IDA(sysfs_ino_ida);
32
Tejun Heob6b4a432007-06-14 03:45:18 +090033/**
Tejun Heo0c73f182007-06-14 03:45:18 +090034 * sysfs_link_sibling - link sysfs_dirent into sibling list
35 * @sd: sysfs_dirent of interest
36 *
37 * Link @sd into its sibling list which starts from
Tejun Heobc747f32007-09-20 16:05:12 +090038 * sd->s_parent->s_dir.children.
Tejun Heo0c73f182007-06-14 03:45:18 +090039 *
40 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090041 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +090042 */
Tejun Heo41fc1c22007-08-02 21:38:03 +090043static void sysfs_link_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +090044{
45 struct sysfs_dirent *parent_sd = sd->s_parent;
46
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -040047 struct rb_node **p;
48 struct rb_node *parent;
49
Mikulas Patocka7f9838f2011-07-21 19:59:22 -040050 if (sysfs_type(sd) == SYSFS_DIR)
51 parent_sd->s_dir.subdirs++;
52
Mikulas Patockaa406f752011-07-25 17:57:03 -040053 p = &parent_sd->s_dir.inode_tree.rb_node;
54 parent = NULL;
55 while (*p) {
56 parent = *p;
57#define node rb_entry(parent, struct sysfs_dirent, inode_node)
58 if (sd->s_ino < node->s_ino) {
59 p = &node->inode_node.rb_left;
60 } else if (sd->s_ino > node->s_ino) {
61 p = &node->inode_node.rb_right;
62 } else {
Heiko Carstensc4253cb2011-09-22 19:34:33 +020063 printk(KERN_CRIT "sysfs: inserting duplicate inode '%lx'\n",
64 (unsigned long) sd->s_ino);
Mikulas Patockaa406f752011-07-25 17:57:03 -040065 BUG();
66 }
67#undef node
Eric W. Biederman3efa65b2007-08-20 21:36:30 +090068 }
Mikulas Patockaa406f752011-07-25 17:57:03 -040069 rb_link_node(&sd->inode_node, parent, p);
70 rb_insert_color(&sd->inode_node, &parent_sd->s_dir.inode_tree);
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -040071
72 p = &parent_sd->s_dir.name_tree.rb_node;
73 parent = NULL;
74 while (*p) {
75 int c;
76 parent = *p;
77#define node rb_entry(parent, struct sysfs_dirent, name_node)
78 c = strcmp(sd->s_name, node->s_name);
79 if (c < 0) {
80 p = &node->name_node.rb_left;
81 } else {
82 p = &node->name_node.rb_right;
83 }
84#undef node
85 }
86 rb_link_node(&sd->name_node, parent, p);
87 rb_insert_color(&sd->name_node, &parent_sd->s_dir.name_tree);
Tejun Heo0c73f182007-06-14 03:45:18 +090088}
89
90/**
91 * sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
92 * @sd: sysfs_dirent of interest
93 *
94 * Unlink @sd from its sibling list which starts from
Tejun Heobc747f32007-09-20 16:05:12 +090095 * sd->s_parent->s_dir.children.
Tejun Heo0c73f182007-06-14 03:45:18 +090096 *
97 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090098 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +090099 */
Tejun Heo41fc1c22007-08-02 21:38:03 +0900100static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +0900101{
Mikulas Patocka7f9838f2011-07-21 19:59:22 -0400102 if (sysfs_type(sd) == SYSFS_DIR)
103 sd->s_parent->s_dir.subdirs--;
104
Mikulas Patockaa406f752011-07-25 17:57:03 -0400105 rb_erase(&sd->inode_node, &sd->s_parent->s_dir.inode_tree);
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400106 rb_erase(&sd->name_node, &sd->s_parent->s_dir.name_tree);
Tejun Heo0c73f182007-06-14 03:45:18 +0900107}
108
109/**
Tejun Heob6b4a432007-06-14 03:45:18 +0900110 * sysfs_get_active - get an active reference to sysfs_dirent
111 * @sd: sysfs_dirent to get an active reference to
112 *
113 * Get an active reference of @sd. This function is noop if @sd
114 * is NULL.
115 *
116 * RETURNS:
117 * Pointer to @sd on success, NULL on failure.
118 */
Eric W. Biedermane72ceb82010-02-11 15:18:38 -0800119struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900120{
Tejun Heo8619f972007-06-14 03:45:18 +0900121 if (unlikely(!sd))
122 return NULL;
123
124 while (1) {
125 int v, t;
126
127 v = atomic_read(&sd->s_active);
128 if (unlikely(v < 0))
129 return NULL;
130
131 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
Eric W. Biederman846f9972010-01-02 13:37:12 -0800132 if (likely(t == v)) {
133 rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900134 return sd;
Eric W. Biederman846f9972010-01-02 13:37:12 -0800135 }
Tejun Heo8619f972007-06-14 03:45:18 +0900136 if (t < 0)
137 return NULL;
138
139 cpu_relax();
Tejun Heob6b4a432007-06-14 03:45:18 +0900140 }
Tejun Heob6b4a432007-06-14 03:45:18 +0900141}
142
143/**
144 * sysfs_put_active - put an active reference to sysfs_dirent
145 * @sd: sysfs_dirent to put an active reference to
146 *
147 * Put an active reference to @sd. This function is noop if @sd
148 * is NULL.
149 */
Eric W. Biedermane72ceb82010-02-11 15:18:38 -0800150void sysfs_put_active(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900151{
Tejun Heo8619f972007-06-14 03:45:18 +0900152 int v;
153
154 if (unlikely(!sd))
155 return;
156
Eric W. Biederman846f9972010-01-02 13:37:12 -0800157 rwsem_release(&sd->dep_map, 1, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900158 v = atomic_dec_return(&sd->s_active);
159 if (likely(v != SD_DEACTIVATED_BIAS))
160 return;
161
162 /* atomic_dec_return() is a mb(), we'll always see the updated
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400163 * sd->u.completion.
Tejun Heo8619f972007-06-14 03:45:18 +0900164 */
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400165 complete(sd->u.completion);
Tejun Heob6b4a432007-06-14 03:45:18 +0900166}
167
168/**
Tejun Heob6b4a432007-06-14 03:45:18 +0900169 * sysfs_deactivate - deactivate sysfs_dirent
170 * @sd: sysfs_dirent to deactivate
171 *
Tejun Heo8619f972007-06-14 03:45:18 +0900172 * Deny new active references and drain existing ones.
Tejun Heob6b4a432007-06-14 03:45:18 +0900173 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900174static void sysfs_deactivate(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900175{
Tejun Heo8619f972007-06-14 03:45:18 +0900176 DECLARE_COMPLETION_ONSTACK(wait);
177 int v;
Tejun Heob6b4a432007-06-14 03:45:18 +0900178
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400179 BUG_ON(!(sd->s_flags & SYSFS_FLAG_REMOVED));
Eric W. Biedermana2db6842010-02-11 15:20:00 -0800180
181 if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
182 return;
183
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400184 sd->u.completion = (void *)&wait;
Tejun Heo8619f972007-06-14 03:45:18 +0900185
Eric W. Biederman846f9972010-01-02 13:37:12 -0800186 rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900187 /* atomic_add_return() is a mb(), put_active() will always see
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400188 * the updated sd->u.completion.
Tejun Heob6b4a432007-06-14 03:45:18 +0900189 */
Tejun Heo8619f972007-06-14 03:45:18 +0900190 v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
191
Eric W. Biederman846f9972010-01-02 13:37:12 -0800192 if (v != SD_DEACTIVATED_BIAS) {
193 lock_contended(&sd->dep_map, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900194 wait_for_completion(&wait);
Eric W. Biederman846f9972010-01-02 13:37:12 -0800195 }
Tejun Heo8619f972007-06-14 03:45:18 +0900196
Eric W. Biederman846f9972010-01-02 13:37:12 -0800197 lock_acquired(&sd->dep_map, _RET_IP_);
198 rwsem_release(&sd->dep_map, 1, _RET_IP_);
Tejun Heob6b4a432007-06-14 03:45:18 +0900199}
200
Tejun Heo42b37df2007-06-14 03:45:17 +0900201static int sysfs_alloc_ino(ino_t *pino)
Tejun Heo2b611bb2007-06-14 03:45:13 +0900202{
203 int ino, rc;
204
205 retry:
206 spin_lock(&sysfs_ino_lock);
207 rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
208 spin_unlock(&sysfs_ino_lock);
209
210 if (rc == -EAGAIN) {
211 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
212 goto retry;
213 rc = -ENOMEM;
214 }
215
216 *pino = ino;
217 return rc;
218}
219
220static void sysfs_free_ino(ino_t ino)
221{
222 spin_lock(&sysfs_ino_lock);
223 ida_remove(&sysfs_ino_ida, ino);
224 spin_unlock(&sysfs_ino_lock);
225}
226
Tejun Heofa7f9122007-06-14 03:45:13 +0900227void release_sysfs_dirent(struct sysfs_dirent * sd)
228{
Tejun Heo13b30862007-06-14 03:45:14 +0900229 struct sysfs_dirent *parent_sd;
230
231 repeat:
Tejun Heo3007e992007-06-14 04:27:23 +0900232 /* Moving/renaming is always done while holding reference.
233 * sd->s_parent won't change beneath us.
234 */
Tejun Heo13b30862007-06-14 03:45:14 +0900235 parent_sd = sd->s_parent;
236
Tejun Heob402d722007-06-14 04:27:21 +0900237 if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
Tejun Heob1fc3d62007-09-20 16:05:11 +0900238 sysfs_put(sd->s_symlink.target_sd);
Tejun Heob402d722007-06-14 04:27:21 +0900239 if (sysfs_type(sd) & SYSFS_COPY_NAME)
Tejun Heo0c096b52007-06-14 03:45:15 +0900240 kfree(sd->s_name);
Eric W. Biederman4c3da222009-11-04 02:50:06 -0800241 if (sd->s_iattr && sd->s_iattr->ia_secdata)
242 security_release_secctx(sd->s_iattr->ia_secdata,
243 sd->s_iattr->ia_secdata_len);
Tejun Heofa7f9122007-06-14 03:45:13 +0900244 kfree(sd->s_iattr);
Tejun Heo2b611bb2007-06-14 03:45:13 +0900245 sysfs_free_ino(sd->s_ino);
Tejun Heofa7f9122007-06-14 03:45:13 +0900246 kmem_cache_free(sysfs_dir_cachep, sd);
Tejun Heo13b30862007-06-14 03:45:14 +0900247
248 sd = parent_sd;
249 if (sd && atomic_dec_and_test(&sd->s_count))
250 goto repeat;
Tejun Heofa7f9122007-06-14 03:45:13 +0900251}
252
Nick Pigginfe15ce42011-01-07 17:49:23 +1100253static int sysfs_dentry_delete(const struct dentry *dentry)
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800254{
255 struct sysfs_dirent *sd = dentry->d_fsdata;
256 return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
257}
258
259static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
260{
Nick Piggin34286d62011-01-07 17:49:57 +1100261 struct sysfs_dirent *sd;
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800262 int is_dir;
263
Nick Piggin34286d62011-01-07 17:49:57 +1100264 if (nd->flags & LOOKUP_RCU)
265 return -ECHILD;
266
267 sd = dentry->d_fsdata;
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800268 mutex_lock(&sysfs_mutex);
269
270 /* The sysfs dirent has been deleted */
271 if (sd->s_flags & SYSFS_FLAG_REMOVED)
272 goto out_bad;
273
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800274 /* The sysfs dirent has been moved? */
275 if (dentry->d_parent->d_fsdata != sd->s_parent)
276 goto out_bad;
277
278 /* The sysfs dirent has been renamed */
279 if (strcmp(dentry->d_name.name, sd->s_name) != 0)
280 goto out_bad;
281
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800282 mutex_unlock(&sysfs_mutex);
283out_valid:
284 return 1;
285out_bad:
286 /* Remove the dentry from the dcache hashes.
287 * If this is a deleted dentry we use d_drop instead of d_delete
288 * so sysfs doesn't need to cope with negative dentries.
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800289 *
290 * If this is a dentry that has simply been renamed we
291 * use d_drop to remove it from the dcache lookup on its
292 * old parent. If this dentry persists later when a lookup
293 * is performed at its new name the dentry will be readded
294 * to the dcache hashes.
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800295 */
296 is_dir = (sysfs_type(sd) == SYSFS_DIR);
297 mutex_unlock(&sysfs_mutex);
298 if (is_dir) {
299 /* If we have submounts we must allow the vfs caches
300 * to lie about the state of the filesystem to prevent
301 * leaks and other nasty things.
302 */
303 if (have_submounts(dentry))
304 goto out_valid;
305 shrink_dcache_parent(dentry);
306 }
307 d_drop(dentry);
308 return 0;
309}
310
Eric W. Biederman28a027c2009-11-07 23:27:00 -0800311static void sysfs_dentry_iput(struct dentry *dentry, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313 struct sysfs_dirent * sd = dentry->d_fsdata;
314
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900315 sysfs_put(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 iput(inode);
317}
318
Al Viroee1ec322009-02-20 06:01:46 +0000319static const struct dentry_operations sysfs_dentry_ops = {
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800320 .d_revalidate = sysfs_dentry_revalidate,
321 .d_delete = sysfs_dentry_delete,
Eric W. Biederman28a027c2009-11-07 23:27:00 -0800322 .d_iput = sysfs_dentry_iput,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323};
324
Tejun Heo3e519032007-06-14 03:45:15 +0900325struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326{
Tejun Heo0c096b52007-06-14 03:45:15 +0900327 char *dup_name = NULL;
Akinobu Mita01da2422007-07-14 11:03:35 +0900328 struct sysfs_dirent *sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900329
330 if (type & SYSFS_COPY_NAME) {
331 name = dup_name = kstrdup(name, GFP_KERNEL);
332 if (!name)
Akinobu Mita01da2422007-07-14 11:03:35 +0900333 return NULL;
Tejun Heo0c096b52007-06-14 03:45:15 +0900334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800336 sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 if (!sd)
Akinobu Mita01da2422007-07-14 11:03:35 +0900338 goto err_out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Tejun Heo0c096b52007-06-14 03:45:15 +0900340 if (sysfs_alloc_ino(&sd->s_ino))
Akinobu Mita01da2422007-07-14 11:03:35 +0900341 goto err_out2;
Tejun Heo2b611bb2007-06-14 03:45:13 +0900342
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 atomic_set(&sd->s_count, 1);
Tejun Heo8619f972007-06-14 03:45:18 +0900344 atomic_set(&sd->s_active, 0);
Tejun Heoa26cd722007-06-14 03:45:14 +0900345
Tejun Heo0c096b52007-06-14 03:45:15 +0900346 sd->s_name = name;
Tejun Heoa26cd722007-06-14 03:45:14 +0900347 sd->s_mode = mode;
Tejun Heob402d722007-06-14 04:27:21 +0900348 sd->s_flags = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 return sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900351
Akinobu Mita01da2422007-07-14 11:03:35 +0900352 err_out2:
Tejun Heo0c096b52007-06-14 03:45:15 +0900353 kmem_cache_free(sysfs_dir_cachep, sd);
Akinobu Mita01da2422007-07-14 11:03:35 +0900354 err_out1:
355 kfree(dup_name);
Tejun Heo0c096b52007-06-14 03:45:15 +0900356 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357}
358
Tejun Heo3007e992007-06-14 04:27:23 +0900359/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900360 * sysfs_addrm_start - prepare for sysfs_dirent add/remove
361 * @acxt: pointer to sysfs_addrm_cxt to be used
362 * @parent_sd: parent sysfs_dirent
Tejun Heo3007e992007-06-14 04:27:23 +0900363 *
Tejun Heofb6896d2007-06-14 04:27:24 +0900364 * This function is called when the caller is about to add or
365 * remove sysfs_dirent under @parent_sd. This function acquires
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800366 * sysfs_mutex. @acxt is used to keep and pass context to
Tejun Heofb6896d2007-06-14 04:27:24 +0900367 * other addrm functions.
Tejun Heo3007e992007-06-14 04:27:23 +0900368 *
369 * LOCKING:
Tejun Heofb6896d2007-06-14 04:27:24 +0900370 * Kernel thread context (may sleep). sysfs_mutex is locked on
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800371 * return.
Tejun Heo3007e992007-06-14 04:27:23 +0900372 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900373void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
374 struct sysfs_dirent *parent_sd)
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700375{
Tejun Heofb6896d2007-06-14 04:27:24 +0900376 memset(acxt, 0, sizeof(*acxt));
377 acxt->parent_sd = parent_sd;
378
Tejun Heofb6896d2007-06-14 04:27:24 +0900379 mutex_lock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +0900380}
381
382/**
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200383 * __sysfs_add_one - add sysfs_dirent to parent without warning
384 * @acxt: addrm context to use
385 * @sd: sysfs_dirent to be added
386 *
387 * Get @acxt->parent_sd and set sd->s_parent to it and increment
388 * nlink of parent inode if @sd is a directory and link into the
389 * children list of the parent.
390 *
391 * This function should be called between calls to
392 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
393 * passed the same @acxt as passed to sysfs_addrm_start().
394 *
395 * LOCKING:
396 * Determined by sysfs_addrm_start().
397 *
398 * RETURNS:
399 * 0 on success, -EEXIST if entry with the given name already
400 * exists.
401 */
402int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
403{
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800404 struct sysfs_inode_attrs *ps_iattr;
405
Eric W. Biederman903e21e2011-10-12 22:02:43 +0000406 if (!!sysfs_ns_type(acxt->parent_sd) != !!sd->s_ns) {
407 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
408 sysfs_ns_type(acxt->parent_sd)? "required": "invalid",
409 acxt->parent_sd->s_name, sd->s_name);
410 return -EINVAL;
411 }
412
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700413 if (sysfs_find_dirent(acxt->parent_sd, sd->s_ns, sd->s_name))
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200414 return -EEXIST;
415
416 sd->s_parent = sysfs_get(acxt->parent_sd);
417
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200418 sysfs_link_sibling(sd);
419
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800420 /* Update timestamps on the parent */
421 ps_iattr = acxt->parent_sd->s_iattr;
422 if (ps_iattr) {
423 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
424 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
425 }
426
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200427 return 0;
428}
429
430/**
Alex Chiang425cb022009-02-12 10:56:59 -0700431 * sysfs_pathname - return full path to sysfs dirent
432 * @sd: sysfs_dirent whose path we want
433 * @path: caller allocated buffer
434 *
435 * Gives the name "/" to the sysfs_root entry; any path returned
436 * is relative to wherever sysfs is mounted.
437 *
438 * XXX: does no error checking on @path size
439 */
440static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
441{
442 if (sd->s_parent) {
443 sysfs_pathname(sd->s_parent, path);
444 strcat(path, "/");
445 }
446 strcat(path, sd->s_name);
447 return path;
448}
449
450/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900451 * sysfs_add_one - add sysfs_dirent to parent
452 * @acxt: addrm context to use
453 * @sd: sysfs_dirent to be added
454 *
455 * Get @acxt->parent_sd and set sd->s_parent to it and increment
Tejun Heo181b2e42007-09-20 16:05:09 +0900456 * nlink of parent inode if @sd is a directory and link into the
457 * children list of the parent.
Tejun Heofb6896d2007-06-14 04:27:24 +0900458 *
459 * This function should be called between calls to
460 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
461 * passed the same @acxt as passed to sysfs_addrm_start().
462 *
463 * LOCKING:
464 * Determined by sysfs_addrm_start().
Tejun Heo23dc2792007-08-02 21:38:03 +0900465 *
466 * RETURNS:
467 * 0 on success, -EEXIST if entry with the given name already
468 * exists.
Tejun Heofb6896d2007-06-14 04:27:24 +0900469 */
Tejun Heo23dc2792007-08-02 21:38:03 +0900470int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
Tejun Heofb6896d2007-06-14 04:27:24 +0900471{
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200472 int ret;
Tejun Heo23dc2792007-08-02 21:38:03 +0900473
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200474 ret = __sysfs_add_one(acxt, sd);
Alex Chiang425cb022009-02-12 10:56:59 -0700475 if (ret == -EEXIST) {
476 char *path = kzalloc(PATH_MAX, GFP_KERNEL);
477 WARN(1, KERN_WARNING
478 "sysfs: cannot create duplicate filename '%s'\n",
479 (path == NULL) ? sd->s_name :
480 strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
481 sd->s_name));
482 kfree(path);
483 }
484
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200485 return ret;
Tejun Heofb6896d2007-06-14 04:27:24 +0900486}
487
488/**
489 * sysfs_remove_one - remove sysfs_dirent from parent
490 * @acxt: addrm context to use
Jean Delvare9fd5b1c2008-01-08 18:11:24 +0100491 * @sd: sysfs_dirent to be removed
Tejun Heofb6896d2007-06-14 04:27:24 +0900492 *
493 * Mark @sd removed and drop nlink of parent inode if @sd is a
Tejun Heo181b2e42007-09-20 16:05:09 +0900494 * directory. @sd is unlinked from the children list.
Tejun Heofb6896d2007-06-14 04:27:24 +0900495 *
496 * This function should be called between calls to
497 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
498 * passed the same @acxt as passed to sysfs_addrm_start().
499 *
500 * LOCKING:
501 * Determined by sysfs_addrm_start().
502 */
503void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
504{
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800505 struct sysfs_inode_attrs *ps_iattr;
506
Tejun Heo41fc1c22007-08-02 21:38:03 +0900507 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
508
509 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900510
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800511 /* Update timestamps on the parent */
512 ps_iattr = acxt->parent_sd->s_iattr;
513 if (ps_iattr) {
514 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
515 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
516 }
517
Tejun Heofb6896d2007-06-14 04:27:24 +0900518 sd->s_flags |= SYSFS_FLAG_REMOVED;
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400519 sd->u.removed_list = acxt->removed;
Tejun Heofb6896d2007-06-14 04:27:24 +0900520 acxt->removed = sd;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900521}
522
523/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900524 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
525 * @acxt: addrm context to finish up
526 *
527 * Finish up sysfs_dirent add/remove. Resources acquired by
528 * sysfs_addrm_start() are released and removed sysfs_dirents are
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800529 * cleaned up.
Tejun Heofb6896d2007-06-14 04:27:24 +0900530 *
531 * LOCKING:
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800532 * sysfs_mutex is released.
Tejun Heofb6896d2007-06-14 04:27:24 +0900533 */
Tejun Heo990e53f2007-08-02 21:38:03 +0900534void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
Tejun Heofb6896d2007-06-14 04:27:24 +0900535{
536 /* release resources acquired by sysfs_addrm_start() */
537 mutex_unlock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +0900538
539 /* kill removed sysfs_dirents */
540 while (acxt->removed) {
541 struct sysfs_dirent *sd = acxt->removed;
542
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400543 acxt->removed = sd->u.removed_list;
Tejun Heofb6896d2007-06-14 04:27:24 +0900544
Tejun Heofb6896d2007-06-14 04:27:24 +0900545 sysfs_deactivate(sd);
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800546 unmap_bin_file(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900547 sysfs_put(sd);
548 }
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700549}
550
Tejun Heof0b0af42007-06-14 04:27:22 +0900551/**
552 * sysfs_find_dirent - find sysfs_dirent with the given name
553 * @parent_sd: sysfs_dirent to search under
554 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530555 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900556 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530557 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900558 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900559 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900560 *
561 * RETURNS:
562 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530563 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900564struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700565 const void *ns,
Tejun Heof0b0af42007-06-14 04:27:22 +0900566 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530567{
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400568 struct rb_node *p = parent_sd->s_dir.name_tree.rb_node;
569 struct sysfs_dirent *found = NULL;
Maneesh Sonic5168652006-03-09 19:40:14 +0530570
Eric W. Biederman903e21e2011-10-12 22:02:43 +0000571 if (!!sysfs_ns_type(parent_sd) != !!ns) {
572 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
573 sysfs_ns_type(parent_sd)? "required": "invalid",
574 parent_sd->s_name, name);
575 return NULL;
576 }
577
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400578 while (p) {
579 int c;
580#define node rb_entry(p, struct sysfs_dirent, name_node)
581 c = strcmp(name, node->s_name);
582 if (c < 0) {
583 p = node->name_node.rb_left;
584 } else if (c > 0) {
585 p = node->name_node.rb_right;
586 } else {
587 found = node;
588 p = node->name_node.rb_left;
589 }
590#undef node
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700591 }
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400592
Eric W. Biedermanb9e27802011-10-25 05:38:41 -0700593 if (found) {
594 while (found->s_ns != ns) {
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400595 p = rb_next(&found->name_node);
596 if (!p)
597 return NULL;
598 found = rb_entry(p, struct sysfs_dirent, name_node);
599 if (strcmp(name, found->s_name))
600 return NULL;
601 }
602 }
603
604 return found;
Tejun Heof0b0af42007-06-14 04:27:22 +0900605}
Maneesh Sonic5168652006-03-09 19:40:14 +0530606
Tejun Heof0b0af42007-06-14 04:27:22 +0900607/**
608 * sysfs_get_dirent - find and get sysfs_dirent with the given name
609 * @parent_sd: sysfs_dirent to search under
610 * @name: name to look for
611 *
612 * Look for sysfs_dirent with name @name under @parent_sd and get
613 * it if found.
614 *
615 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900616 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900617 *
618 * RETURNS:
619 * Pointer to sysfs_dirent if found, NULL if not.
620 */
621struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700622 const void *ns,
Tejun Heof0b0af42007-06-14 04:27:22 +0900623 const unsigned char *name)
624{
625 struct sysfs_dirent *sd;
626
Tejun Heo3007e992007-06-14 04:27:23 +0900627 mutex_lock(&sysfs_mutex);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700628 sd = sysfs_find_dirent(parent_sd, ns, name);
Tejun Heof0b0af42007-06-14 04:27:22 +0900629 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900630 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900631
632 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530633}
Neil Brownf1282c82008-07-16 08:58:04 +1000634EXPORT_SYMBOL_GPL(sysfs_get_dirent);
Maneesh Sonic5168652006-03-09 19:40:14 +0530635
Tejun Heo608e2662007-06-14 04:27:22 +0900636static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700637 enum kobj_ns_type type, const void *ns, const char *name,
638 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900641 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900642 struct sysfs_dirent *sd;
Tejun Heo23dc2792007-08-02 21:38:03 +0900643 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Tejun Heofc9f54b2007-06-14 03:45:17 +0900645 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900646 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900647 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900648 return -ENOMEM;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700649
650 sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
651 sd->s_ns = ns;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900652 sd->s_dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900653
Tejun Heo51225032007-06-14 04:27:25 +0900654 /* link in */
655 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo23dc2792007-08-02 21:38:03 +0900656 rc = sysfs_add_one(&acxt, sd);
657 sysfs_addrm_finish(&acxt);
Tejun Heo967e35d2007-07-18 16:38:11 +0900658
Tejun Heo23dc2792007-08-02 21:38:03 +0900659 if (rc == 0)
660 *p_sd = sd;
661 else
Tejun Heo967e35d2007-07-18 16:38:11 +0900662 sysfs_put(sd);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900663
Tejun Heo23dc2792007-08-02 21:38:03 +0900664 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665}
666
Tejun Heo608e2662007-06-14 04:27:22 +0900667int sysfs_create_subdir(struct kobject *kobj, const char *name,
668 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700670 return create_dir(kobj, kobj->sd,
671 KOBJ_NS_TYPE_NONE, NULL, name, p_sd);
672}
673
Serge E. Hallynbe867b12010-05-03 16:23:15 -0500674/**
675 * sysfs_read_ns_type: return associated ns_type
676 * @kobj: the kobject being queried
677 *
678 * Each kobject can be tagged with exactly one namespace type
679 * (i.e. network or user). Return the ns_type associated with
680 * this object if any
681 */
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700682static enum kobj_ns_type sysfs_read_ns_type(struct kobject *kobj)
683{
684 const struct kobj_ns_type_operations *ops;
685 enum kobj_ns_type type;
686
687 ops = kobj_child_ns_ops(kobj);
688 if (!ops)
689 return KOBJ_NS_TYPE_NONE;
690
691 type = ops->type;
692 BUG_ON(type <= KOBJ_NS_TYPE_NONE);
693 BUG_ON(type >= KOBJ_NS_TYPES);
694 BUG_ON(!kobj_ns_type_registered(type));
695
696 return type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697}
698
699/**
700 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 * @kobj: object we're creating directory for.
702 */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900703int sysfs_create_dir(struct kobject * kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700705 enum kobj_ns_type type;
Tejun Heo608e2662007-06-14 04:27:22 +0900706 struct sysfs_dirent *parent_sd, *sd;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700707 const void *ns = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 int error = 0;
709
710 BUG_ON(!kobj);
711
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900712 if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900713 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 else
Eric W. Biederman7d0c7d62007-08-20 21:36:30 +0900715 parent_sd = &sysfs_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700717 if (sysfs_ns_type(parent_sd))
718 ns = kobj->ktype->namespace(kobj);
719 type = sysfs_read_ns_type(kobj);
720
721 error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900723 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 return error;
725}
726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
728 struct nameidata *nd)
729{
Tejun Heo6cb52142007-07-31 19:15:08 +0900730 struct dentry *ret = NULL;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700731 struct dentry *parent = dentry->d_parent;
732 struct sysfs_dirent *parent_sd = parent->d_fsdata;
Tejun Heoa7a04752007-08-02 21:38:02 +0900733 struct sysfs_dirent *sd;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900734 struct inode *inode;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700735 enum kobj_ns_type type;
736 const void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Tejun Heo6cb52142007-07-31 19:15:08 +0900738 mutex_lock(&sysfs_mutex);
739
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700740 type = sysfs_ns_type(parent_sd);
741 ns = sysfs_info(dir->i_sb)->ns[type];
742
743 sd = sysfs_find_dirent(parent_sd, ns, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Tejun Heofc9f54b2007-06-14 03:45:17 +0900745 /* no such entry */
Tejun Heoe49452c2008-01-16 12:06:14 +0900746 if (!sd) {
747 ret = ERR_PTR(-ENOENT);
Tejun Heo6cb52142007-07-31 19:15:08 +0900748 goto out_unlock;
Tejun Heoe49452c2008-01-16 12:06:14 +0900749 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900750
751 /* attach dentry and inode */
Eric W. Biedermanfac26222010-02-12 19:22:27 -0800752 inode = sysfs_get_inode(dir->i_sb, sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900753 if (!inode) {
754 ret = ERR_PTR(-ENOMEM);
755 goto out_unlock;
756 }
Tejun Heo3007e992007-06-14 04:27:23 +0900757
Tejun Heod6b4fd22007-09-20 16:05:11 +0900758 /* instantiate and hash dentry */
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800759 ret = d_find_alias(inode);
760 if (!ret) {
Nick Pigginfb045ad2011-01-07 17:49:55 +1100761 d_set_d_op(dentry, &sysfs_dentry_ops);
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800762 dentry->d_fsdata = sysfs_get(sd);
763 d_add(dentry, inode);
764 } else {
765 d_move(ret, dentry);
766 iput(inode);
767 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900768
Tejun Heo6cb52142007-07-31 19:15:08 +0900769 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900770 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900771 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772}
773
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800774const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 .lookup = sysfs_lookup,
Eric W. Biedermane61ab4a2009-11-20 16:08:53 -0800776 .permission = sysfs_permission,
Maneesh Soni988d1862005-05-31 10:39:14 +0530777 .setattr = sysfs_setattr,
Eric W. Biedermane61ab4a2009-11-20 16:08:53 -0800778 .getattr = sysfs_getattr,
David P. Quigleyddd29ec2009-09-09 14:25:37 -0400779 .setxattr = sysfs_setxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780};
781
Tejun Heo608e2662007-06-14 04:27:22 +0900782static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783{
Tejun Heofb6896d2007-06-14 04:27:24 +0900784 struct sysfs_addrm_cxt acxt;
785
786 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heofb6896d2007-06-14 04:27:24 +0900787 sysfs_remove_one(&acxt, sd);
788 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789}
790
Tejun Heo608e2662007-06-14 04:27:22 +0900791void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792{
Tejun Heo608e2662007-06-14 04:27:22 +0900793 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794}
795
796
Tejun Heo608e2662007-06-14 04:27:22 +0900797static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798{
Tejun Heofb6896d2007-06-14 04:27:24 +0900799 struct sysfs_addrm_cxt acxt;
Mikulas Patockaa406f752011-07-25 17:57:03 -0400800 struct rb_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Tejun Heo608e2662007-06-14 04:27:22 +0900802 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 return;
804
Tejun Heo608e2662007-06-14 04:27:22 +0900805 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900806 sysfs_addrm_start(&acxt, dir_sd);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400807 pos = rb_first(&dir_sd->s_dir.inode_tree);
808 while (pos) {
809 struct sysfs_dirent *sd = rb_entry(pos, struct sysfs_dirent, inode_node);
810 pos = rb_next(pos);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900811 if (sysfs_type(sd) != SYSFS_DIR)
Tejun Heofb6896d2007-06-14 04:27:24 +0900812 sysfs_remove_one(&acxt, sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900814 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900815
Tejun Heo608e2662007-06-14 04:27:22 +0900816 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700817}
818
819/**
820 * sysfs_remove_dir - remove an object's directory.
821 * @kobj: object.
822 *
823 * The only thing special about this is that we remove any files in
824 * the directory before we remove the directory, and we've inlined
825 * what used to be sysfs_rmdir() below, instead of calling separately.
826 */
827
828void sysfs_remove_dir(struct kobject * kobj)
829{
Tejun Heo608e2662007-06-14 04:27:22 +0900830 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900831
Tejun Heo5f995322007-06-14 04:27:23 +0900832 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900833 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900834 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900835
Tejun Heo608e2662007-06-14 04:27:22 +0900836 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837}
838
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800839int sysfs_rename(struct sysfs_dirent *sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700840 struct sysfs_dirent *new_parent_sd, const void *new_ns,
841 const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Tejun Heo51225032007-06-14 04:27:25 +0900843 const char *dup_name = NULL;
Tejun Heo996b7372007-06-14 03:45:14 +0900844 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800846 mutex_lock(&sysfs_mutex);
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900847
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900848 error = 0;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700849 if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800850 (strcmp(sd->s_name, new_name) == 0))
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900851 goto out; /* nothing to rename */
852
Tejun Heo996b7372007-06-14 03:45:14 +0900853 error = -EEXIST;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700854 if (sysfs_find_dirent(new_parent_sd, new_ns, new_name))
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800855 goto out;
Tejun Heo996b7372007-06-14 03:45:14 +0900856
Eric W. Biederman0b4a4fe2008-07-03 18:05:28 -0700857 /* rename sysfs_dirent */
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800858 if (strcmp(sd->s_name, new_name) != 0) {
859 error = -ENOMEM;
860 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
861 if (!new_name)
862 goto out;
Tejun Heo996b7372007-06-14 03:45:14 +0900863
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800864 dup_name = sd->s_name;
865 sd->s_name = new_name;
866 }
867
Eric W. Biedermanf6d90b42011-11-01 07:06:17 -0700868 /* Move to the appropriate place in the appropriate directories rbtree. */
869 sysfs_unlink_sibling(sd);
870 sysfs_get(new_parent_sd);
871 sysfs_put(sd->s_parent);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700872 sd->s_ns = new_ns;
Eric W. Biedermanf6d90b42011-11-01 07:06:17 -0700873 sd->s_parent = new_parent_sd;
874 sysfs_link_sibling(sd);
Tejun Heo0c096b52007-06-14 03:45:15 +0900875
Tejun Heo996b7372007-06-14 03:45:14 +0900876 error = 0;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900877 out:
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800878 mutex_unlock(&sysfs_mutex);
879 kfree(dup_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 return error;
881}
882
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800883int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
884{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700885 struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
886 const void *new_ns = NULL;
887
888 if (sysfs_ns_type(parent_sd))
889 new_ns = kobj->ktype->namespace(kobj);
890
891 return sysfs_rename(kobj->sd, parent_sd, new_ns, new_name);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800892}
893
Tejun Heo51225032007-06-14 04:27:25 +0900894int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100895{
Tejun Heo51225032007-06-14 04:27:25 +0900896 struct sysfs_dirent *sd = kobj->sd;
897 struct sysfs_dirent *new_parent_sd;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700898 const void *new_ns = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100899
Tejun Heo51225032007-06-14 04:27:25 +0900900 BUG_ON(!sd->s_parent);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700901 if (sysfs_ns_type(sd->s_parent))
902 new_ns = kobj->ktype->namespace(kobj);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800903 new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
Cornelia Hucka6a83572009-10-06 15:33:35 +0200904 new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100905
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700906 return sysfs_rename(sd, new_parent_sd, new_ns, sd->s_name);
Cornelia Huck8a824722006-11-20 17:07:51 +0100907}
908
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909/* Relationship between s_mode and the DT_xxx types */
910static inline unsigned char dt_type(struct sysfs_dirent *sd)
911{
912 return (sd->s_mode >> 12) & 15;
913}
914
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800915static int sysfs_dir_release(struct inode *inode, struct file *filp)
916{
917 sysfs_put(filp->private_data);
918 return 0;
919}
920
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700921static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
922 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800923{
924 if (pos) {
925 int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
926 pos->s_parent == parent_sd &&
927 ino == pos->s_ino;
928 sysfs_put(pos);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700929 if (!valid)
930 pos = NULL;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800931 }
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700932 if (!pos && (ino > 1) && (ino < INT_MAX)) {
Mikulas Patockaa406f752011-07-25 17:57:03 -0400933 struct rb_node *p = parent_sd->s_dir.inode_tree.rb_node;
934 while (p) {
935#define node rb_entry(p, struct sysfs_dirent, inode_node)
936 if (ino < node->s_ino) {
937 pos = node;
938 p = node->inode_node.rb_left;
939 } else if (ino > node->s_ino) {
940 p = node->inode_node.rb_right;
941 } else {
942 pos = node;
943 break;
944 }
945#undef node
946 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800947 }
Eric W. Biedermanb9e27802011-10-25 05:38:41 -0700948 while (pos && pos->s_ns != ns) {
Mikulas Patockaa406f752011-07-25 17:57:03 -0400949 struct rb_node *p = rb_next(&pos->inode_node);
950 if (!p)
951 pos = NULL;
952 else
953 pos = rb_entry(p, struct sysfs_dirent, inode_node);
954 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800955 return pos;
956}
957
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700958static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
959 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800960{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700961 pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400962 if (pos) do {
963 struct rb_node *p = rb_next(&pos->inode_node);
964 if (!p)
965 pos = NULL;
966 else
967 pos = rb_entry(p, struct sysfs_dirent, inode_node);
Eric W. Biedermanb9e27802011-10-25 05:38:41 -0700968 } while (pos && pos->s_ns != ns);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800969 return pos;
970}
971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
973{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -0800974 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800976 struct sysfs_dirent *pos = filp->private_data;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700977 enum kobj_ns_type type;
978 const void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 ino_t ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700981 type = sysfs_ns_type(parent_sd);
982 ns = sysfs_info(dentry->d_sb)->ns[type];
983
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900984 if (filp->f_pos == 0) {
985 ino = parent_sd->s_ino;
986 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
987 filp->f_pos++;
988 }
989 if (filp->f_pos == 1) {
990 if (parent_sd->s_parent)
991 ino = parent_sd->s_parent->s_ino;
992 else
Eric Sandeendc351252007-06-11 14:02:45 +0900993 ino = parent_sd->s_ino;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900994 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 filp->f_pos++;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900996 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800997 mutex_lock(&sysfs_mutex);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700998 for (pos = sysfs_dir_pos(ns, parent_sd, filp->f_pos, pos);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800999 pos;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -07001000 pos = sysfs_dir_next_pos(ns, parent_sd, filp->f_pos, pos)) {
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001001 const char * name;
1002 unsigned int type;
1003 int len, ret;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001004
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001005 name = pos->s_name;
1006 len = strlen(name);
1007 ino = pos->s_ino;
1008 type = dt_type(pos);
1009 filp->f_pos = ino;
1010 filp->private_data = sysfs_get(pos);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001011
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001012 mutex_unlock(&sysfs_mutex);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001013 ret = filldir(dirent, name, len, filp->f_pos, ino, type);
1014 mutex_lock(&sysfs_mutex);
1015 if (ret < 0)
1016 break;
1017 }
1018 mutex_unlock(&sysfs_mutex);
1019 if ((filp->f_pos > 1) && !pos) { /* EOF */
1020 filp->f_pos = INT_MAX;
1021 filp->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023 return 0;
1024}
1025
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001027const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 .read = generic_read_dir,
1029 .readdir = sysfs_readdir,
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001030 .release = sysfs_dir_release,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +02001031 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032};