blob: 83bb9d1f30aac612c0d4b0c1d2c28fceee3878e7 [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. Biederman3ff195b2010-03-30 11:31:26 -0700406 if (sysfs_find_dirent(acxt->parent_sd, sd->s_ns, sd->s_name))
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200407 return -EEXIST;
408
409 sd->s_parent = sysfs_get(acxt->parent_sd);
410
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200411 sysfs_link_sibling(sd);
412
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800413 /* Update timestamps on the parent */
414 ps_iattr = acxt->parent_sd->s_iattr;
415 if (ps_iattr) {
416 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
417 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
418 }
419
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200420 return 0;
421}
422
423/**
Alex Chiang425cb022009-02-12 10:56:59 -0700424 * sysfs_pathname - return full path to sysfs dirent
425 * @sd: sysfs_dirent whose path we want
426 * @path: caller allocated buffer
427 *
428 * Gives the name "/" to the sysfs_root entry; any path returned
429 * is relative to wherever sysfs is mounted.
430 *
431 * XXX: does no error checking on @path size
432 */
433static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
434{
435 if (sd->s_parent) {
436 sysfs_pathname(sd->s_parent, path);
437 strcat(path, "/");
438 }
439 strcat(path, sd->s_name);
440 return path;
441}
442
443/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900444 * sysfs_add_one - add sysfs_dirent to parent
445 * @acxt: addrm context to use
446 * @sd: sysfs_dirent to be added
447 *
448 * Get @acxt->parent_sd and set sd->s_parent to it and increment
Tejun Heo181b2e42007-09-20 16:05:09 +0900449 * nlink of parent inode if @sd is a directory and link into the
450 * children list of the parent.
Tejun Heofb6896d2007-06-14 04:27:24 +0900451 *
452 * This function should be called between calls to
453 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
454 * passed the same @acxt as passed to sysfs_addrm_start().
455 *
456 * LOCKING:
457 * Determined by sysfs_addrm_start().
Tejun Heo23dc2792007-08-02 21:38:03 +0900458 *
459 * RETURNS:
460 * 0 on success, -EEXIST if entry with the given name already
461 * exists.
Tejun Heofb6896d2007-06-14 04:27:24 +0900462 */
Tejun Heo23dc2792007-08-02 21:38:03 +0900463int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
Tejun Heofb6896d2007-06-14 04:27:24 +0900464{
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200465 int ret;
Tejun Heo23dc2792007-08-02 21:38:03 +0900466
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200467 ret = __sysfs_add_one(acxt, sd);
Alex Chiang425cb022009-02-12 10:56:59 -0700468 if (ret == -EEXIST) {
469 char *path = kzalloc(PATH_MAX, GFP_KERNEL);
470 WARN(1, KERN_WARNING
471 "sysfs: cannot create duplicate filename '%s'\n",
472 (path == NULL) ? sd->s_name :
473 strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
474 sd->s_name));
475 kfree(path);
476 }
477
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200478 return ret;
Tejun Heofb6896d2007-06-14 04:27:24 +0900479}
480
481/**
482 * sysfs_remove_one - remove sysfs_dirent from parent
483 * @acxt: addrm context to use
Jean Delvare9fd5b1c2008-01-08 18:11:24 +0100484 * @sd: sysfs_dirent to be removed
Tejun Heofb6896d2007-06-14 04:27:24 +0900485 *
486 * Mark @sd removed and drop nlink of parent inode if @sd is a
Tejun Heo181b2e42007-09-20 16:05:09 +0900487 * directory. @sd is unlinked from the children list.
Tejun Heofb6896d2007-06-14 04:27:24 +0900488 *
489 * This function should be called between calls to
490 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
491 * passed the same @acxt as passed to sysfs_addrm_start().
492 *
493 * LOCKING:
494 * Determined by sysfs_addrm_start().
495 */
496void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
497{
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800498 struct sysfs_inode_attrs *ps_iattr;
499
Tejun Heo41fc1c22007-08-02 21:38:03 +0900500 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
501
502 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900503
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800504 /* Update timestamps on the parent */
505 ps_iattr = acxt->parent_sd->s_iattr;
506 if (ps_iattr) {
507 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
508 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
509 }
510
Tejun Heofb6896d2007-06-14 04:27:24 +0900511 sd->s_flags |= SYSFS_FLAG_REMOVED;
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400512 sd->u.removed_list = acxt->removed;
Tejun Heofb6896d2007-06-14 04:27:24 +0900513 acxt->removed = sd;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900514}
515
516/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900517 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
518 * @acxt: addrm context to finish up
519 *
520 * Finish up sysfs_dirent add/remove. Resources acquired by
521 * sysfs_addrm_start() are released and removed sysfs_dirents are
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800522 * cleaned up.
Tejun Heofb6896d2007-06-14 04:27:24 +0900523 *
524 * LOCKING:
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800525 * sysfs_mutex is released.
Tejun Heofb6896d2007-06-14 04:27:24 +0900526 */
Tejun Heo990e53f2007-08-02 21:38:03 +0900527void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
Tejun Heofb6896d2007-06-14 04:27:24 +0900528{
529 /* release resources acquired by sysfs_addrm_start() */
530 mutex_unlock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +0900531
532 /* kill removed sysfs_dirents */
533 while (acxt->removed) {
534 struct sysfs_dirent *sd = acxt->removed;
535
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400536 acxt->removed = sd->u.removed_list;
Tejun Heofb6896d2007-06-14 04:27:24 +0900537
Tejun Heofb6896d2007-06-14 04:27:24 +0900538 sysfs_deactivate(sd);
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800539 unmap_bin_file(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900540 sysfs_put(sd);
541 }
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700542}
543
Tejun Heof0b0af42007-06-14 04:27:22 +0900544/**
545 * sysfs_find_dirent - find sysfs_dirent with the given name
546 * @parent_sd: sysfs_dirent to search under
547 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530548 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900549 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530550 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900551 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900552 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900553 *
554 * RETURNS:
555 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530556 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900557struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700558 const void *ns,
Tejun Heof0b0af42007-06-14 04:27:22 +0900559 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530560{
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400561 struct rb_node *p = parent_sd->s_dir.name_tree.rb_node;
562 struct sysfs_dirent *found = NULL;
Maneesh Sonic5168652006-03-09 19:40:14 +0530563
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400564 while (p) {
565 int c;
566#define node rb_entry(p, struct sysfs_dirent, name_node)
567 c = strcmp(name, node->s_name);
568 if (c < 0) {
569 p = node->name_node.rb_left;
570 } else if (c > 0) {
571 p = node->name_node.rb_right;
572 } else {
573 found = node;
574 p = node->name_node.rb_left;
575 }
576#undef node
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700577 }
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400578
579 if (found && ns) {
580 while (found->s_ns && found->s_ns != ns) {
581 p = rb_next(&found->name_node);
582 if (!p)
583 return NULL;
584 found = rb_entry(p, struct sysfs_dirent, name_node);
585 if (strcmp(name, found->s_name))
586 return NULL;
587 }
588 }
589
590 return found;
Tejun Heof0b0af42007-06-14 04:27:22 +0900591}
Maneesh Sonic5168652006-03-09 19:40:14 +0530592
Tejun Heof0b0af42007-06-14 04:27:22 +0900593/**
594 * sysfs_get_dirent - find and get sysfs_dirent with the given name
595 * @parent_sd: sysfs_dirent to search under
596 * @name: name to look for
597 *
598 * Look for sysfs_dirent with name @name under @parent_sd and get
599 * it if found.
600 *
601 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900602 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900603 *
604 * RETURNS:
605 * Pointer to sysfs_dirent if found, NULL if not.
606 */
607struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700608 const void *ns,
Tejun Heof0b0af42007-06-14 04:27:22 +0900609 const unsigned char *name)
610{
611 struct sysfs_dirent *sd;
612
Tejun Heo3007e992007-06-14 04:27:23 +0900613 mutex_lock(&sysfs_mutex);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700614 sd = sysfs_find_dirent(parent_sd, ns, name);
Tejun Heof0b0af42007-06-14 04:27:22 +0900615 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900616 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900617
618 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530619}
Neil Brownf1282c82008-07-16 08:58:04 +1000620EXPORT_SYMBOL_GPL(sysfs_get_dirent);
Maneesh Sonic5168652006-03-09 19:40:14 +0530621
Tejun Heo608e2662007-06-14 04:27:22 +0900622static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700623 enum kobj_ns_type type, const void *ns, const char *name,
624 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900627 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900628 struct sysfs_dirent *sd;
Tejun Heo23dc2792007-08-02 21:38:03 +0900629 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
Tejun Heofc9f54b2007-06-14 03:45:17 +0900631 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900632 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900633 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900634 return -ENOMEM;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700635
636 sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
637 sd->s_ns = ns;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900638 sd->s_dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900639
Tejun Heo51225032007-06-14 04:27:25 +0900640 /* link in */
641 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo23dc2792007-08-02 21:38:03 +0900642 rc = sysfs_add_one(&acxt, sd);
643 sysfs_addrm_finish(&acxt);
Tejun Heo967e35d2007-07-18 16:38:11 +0900644
Tejun Heo23dc2792007-08-02 21:38:03 +0900645 if (rc == 0)
646 *p_sd = sd;
647 else
Tejun Heo967e35d2007-07-18 16:38:11 +0900648 sysfs_put(sd);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900649
Tejun Heo23dc2792007-08-02 21:38:03 +0900650 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
Tejun Heo608e2662007-06-14 04:27:22 +0900653int sysfs_create_subdir(struct kobject *kobj, const char *name,
654 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700656 return create_dir(kobj, kobj->sd,
657 KOBJ_NS_TYPE_NONE, NULL, name, p_sd);
658}
659
Serge E. Hallynbe867b12010-05-03 16:23:15 -0500660/**
661 * sysfs_read_ns_type: return associated ns_type
662 * @kobj: the kobject being queried
663 *
664 * Each kobject can be tagged with exactly one namespace type
665 * (i.e. network or user). Return the ns_type associated with
666 * this object if any
667 */
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700668static enum kobj_ns_type sysfs_read_ns_type(struct kobject *kobj)
669{
670 const struct kobj_ns_type_operations *ops;
671 enum kobj_ns_type type;
672
673 ops = kobj_child_ns_ops(kobj);
674 if (!ops)
675 return KOBJ_NS_TYPE_NONE;
676
677 type = ops->type;
678 BUG_ON(type <= KOBJ_NS_TYPE_NONE);
679 BUG_ON(type >= KOBJ_NS_TYPES);
680 BUG_ON(!kobj_ns_type_registered(type));
681
682 return type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
685/**
686 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 * @kobj: object we're creating directory for.
688 */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900689int sysfs_create_dir(struct kobject * kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700691 enum kobj_ns_type type;
Tejun Heo608e2662007-06-14 04:27:22 +0900692 struct sysfs_dirent *parent_sd, *sd;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700693 const void *ns = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 int error = 0;
695
696 BUG_ON(!kobj);
697
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900698 if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900699 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 else
Eric W. Biederman7d0c7d62007-08-20 21:36:30 +0900701 parent_sd = &sysfs_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700703 if (sysfs_ns_type(parent_sd))
704 ns = kobj->ktype->namespace(kobj);
705 type = sysfs_read_ns_type(kobj);
706
707 error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900709 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 return error;
711}
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
714 struct nameidata *nd)
715{
Tejun Heo6cb52142007-07-31 19:15:08 +0900716 struct dentry *ret = NULL;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700717 struct dentry *parent = dentry->d_parent;
718 struct sysfs_dirent *parent_sd = parent->d_fsdata;
Tejun Heoa7a04752007-08-02 21:38:02 +0900719 struct sysfs_dirent *sd;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900720 struct inode *inode;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700721 enum kobj_ns_type type;
722 const void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
Tejun Heo6cb52142007-07-31 19:15:08 +0900724 mutex_lock(&sysfs_mutex);
725
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700726 type = sysfs_ns_type(parent_sd);
727 ns = sysfs_info(dir->i_sb)->ns[type];
728
729 sd = sysfs_find_dirent(parent_sd, ns, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
Tejun Heofc9f54b2007-06-14 03:45:17 +0900731 /* no such entry */
Tejun Heoe49452c2008-01-16 12:06:14 +0900732 if (!sd) {
733 ret = ERR_PTR(-ENOENT);
Tejun Heo6cb52142007-07-31 19:15:08 +0900734 goto out_unlock;
Tejun Heoe49452c2008-01-16 12:06:14 +0900735 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900736
737 /* attach dentry and inode */
Eric W. Biedermanfac26222010-02-12 19:22:27 -0800738 inode = sysfs_get_inode(dir->i_sb, sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900739 if (!inode) {
740 ret = ERR_PTR(-ENOMEM);
741 goto out_unlock;
742 }
Tejun Heo3007e992007-06-14 04:27:23 +0900743
Tejun Heod6b4fd22007-09-20 16:05:11 +0900744 /* instantiate and hash dentry */
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800745 ret = d_find_alias(inode);
746 if (!ret) {
Nick Pigginfb045ad2011-01-07 17:49:55 +1100747 d_set_d_op(dentry, &sysfs_dentry_ops);
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800748 dentry->d_fsdata = sysfs_get(sd);
749 d_add(dentry, inode);
750 } else {
751 d_move(ret, dentry);
752 iput(inode);
753 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900754
Tejun Heo6cb52142007-07-31 19:15:08 +0900755 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900756 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900757 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758}
759
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800760const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 .lookup = sysfs_lookup,
Eric W. Biedermane61ab4a2009-11-20 16:08:53 -0800762 .permission = sysfs_permission,
Maneesh Soni988d1862005-05-31 10:39:14 +0530763 .setattr = sysfs_setattr,
Eric W. Biedermane61ab4a2009-11-20 16:08:53 -0800764 .getattr = sysfs_getattr,
David P. Quigleyddd29ec2009-09-09 14:25:37 -0400765 .setxattr = sysfs_setxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766};
767
Tejun Heo608e2662007-06-14 04:27:22 +0900768static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
Tejun Heofb6896d2007-06-14 04:27:24 +0900770 struct sysfs_addrm_cxt acxt;
771
772 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heofb6896d2007-06-14 04:27:24 +0900773 sysfs_remove_one(&acxt, sd);
774 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775}
776
Tejun Heo608e2662007-06-14 04:27:22 +0900777void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
Tejun Heo608e2662007-06-14 04:27:22 +0900779 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780}
781
782
Tejun Heo608e2662007-06-14 04:27:22 +0900783static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784{
Tejun Heofb6896d2007-06-14 04:27:24 +0900785 struct sysfs_addrm_cxt acxt;
Mikulas Patockaa406f752011-07-25 17:57:03 -0400786 struct rb_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Tejun Heo608e2662007-06-14 04:27:22 +0900788 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return;
790
Tejun Heo608e2662007-06-14 04:27:22 +0900791 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900792 sysfs_addrm_start(&acxt, dir_sd);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400793 pos = rb_first(&dir_sd->s_dir.inode_tree);
794 while (pos) {
795 struct sysfs_dirent *sd = rb_entry(pos, struct sysfs_dirent, inode_node);
796 pos = rb_next(pos);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900797 if (sysfs_type(sd) != SYSFS_DIR)
Tejun Heofb6896d2007-06-14 04:27:24 +0900798 sysfs_remove_one(&acxt, sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900800 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900801
Tejun Heo608e2662007-06-14 04:27:22 +0900802 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700803}
804
805/**
806 * sysfs_remove_dir - remove an object's directory.
807 * @kobj: object.
808 *
809 * The only thing special about this is that we remove any files in
810 * the directory before we remove the directory, and we've inlined
811 * what used to be sysfs_rmdir() below, instead of calling separately.
812 */
813
814void sysfs_remove_dir(struct kobject * kobj)
815{
Tejun Heo608e2662007-06-14 04:27:22 +0900816 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900817
Tejun Heo5f995322007-06-14 04:27:23 +0900818 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900819 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900820 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900821
Tejun Heo608e2662007-06-14 04:27:22 +0900822 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823}
824
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800825int sysfs_rename(struct sysfs_dirent *sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700826 struct sysfs_dirent *new_parent_sd, const void *new_ns,
827 const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828{
Tejun Heo51225032007-06-14 04:27:25 +0900829 const char *dup_name = NULL;
Tejun Heo996b7372007-06-14 03:45:14 +0900830 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800832 mutex_lock(&sysfs_mutex);
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900833
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900834 error = 0;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700835 if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800836 (strcmp(sd->s_name, new_name) == 0))
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900837 goto out; /* nothing to rename */
838
Tejun Heo996b7372007-06-14 03:45:14 +0900839 error = -EEXIST;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700840 if (sysfs_find_dirent(new_parent_sd, new_ns, new_name))
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800841 goto out;
Tejun Heo996b7372007-06-14 03:45:14 +0900842
Eric W. Biederman0b4a4fe2008-07-03 18:05:28 -0700843 /* rename sysfs_dirent */
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800844 if (strcmp(sd->s_name, new_name) != 0) {
845 error = -ENOMEM;
846 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
847 if (!new_name)
848 goto out;
Tejun Heo996b7372007-06-14 03:45:14 +0900849
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800850 dup_name = sd->s_name;
851 sd->s_name = new_name;
852 }
853
854 /* Remove from old parent's list and insert into new parent's list. */
855 if (sd->s_parent != new_parent_sd) {
856 sysfs_unlink_sibling(sd);
857 sysfs_get(new_parent_sd);
858 sysfs_put(sd->s_parent);
859 sd->s_parent = new_parent_sd;
860 sysfs_link_sibling(sd);
861 }
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700862 sd->s_ns = new_ns;
Tejun Heo0c096b52007-06-14 03:45:15 +0900863
Tejun Heo996b7372007-06-14 03:45:14 +0900864 error = 0;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900865 out:
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800866 mutex_unlock(&sysfs_mutex);
867 kfree(dup_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 return error;
869}
870
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800871int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
872{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700873 struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
874 const void *new_ns = NULL;
875
876 if (sysfs_ns_type(parent_sd))
877 new_ns = kobj->ktype->namespace(kobj);
878
879 return sysfs_rename(kobj->sd, parent_sd, new_ns, new_name);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800880}
881
Tejun Heo51225032007-06-14 04:27:25 +0900882int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100883{
Tejun Heo51225032007-06-14 04:27:25 +0900884 struct sysfs_dirent *sd = kobj->sd;
885 struct sysfs_dirent *new_parent_sd;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700886 const void *new_ns = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100887
Tejun Heo51225032007-06-14 04:27:25 +0900888 BUG_ON(!sd->s_parent);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700889 if (sysfs_ns_type(sd->s_parent))
890 new_ns = kobj->ktype->namespace(kobj);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800891 new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
Cornelia Hucka6a83572009-10-06 15:33:35 +0200892 new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100893
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700894 return sysfs_rename(sd, new_parent_sd, new_ns, sd->s_name);
Cornelia Huck8a824722006-11-20 17:07:51 +0100895}
896
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897/* Relationship between s_mode and the DT_xxx types */
898static inline unsigned char dt_type(struct sysfs_dirent *sd)
899{
900 return (sd->s_mode >> 12) & 15;
901}
902
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800903static int sysfs_dir_release(struct inode *inode, struct file *filp)
904{
905 sysfs_put(filp->private_data);
906 return 0;
907}
908
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700909static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
910 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800911{
912 if (pos) {
913 int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
914 pos->s_parent == parent_sd &&
915 ino == pos->s_ino;
916 sysfs_put(pos);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700917 if (!valid)
918 pos = NULL;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800919 }
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700920 if (!pos && (ino > 1) && (ino < INT_MAX)) {
Mikulas Patockaa406f752011-07-25 17:57:03 -0400921 struct rb_node *p = parent_sd->s_dir.inode_tree.rb_node;
922 while (p) {
923#define node rb_entry(p, struct sysfs_dirent, inode_node)
924 if (ino < node->s_ino) {
925 pos = node;
926 p = node->inode_node.rb_left;
927 } else if (ino > node->s_ino) {
928 p = node->inode_node.rb_right;
929 } else {
930 pos = node;
931 break;
932 }
933#undef node
934 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800935 }
Mikulas Patockaa406f752011-07-25 17:57:03 -0400936 while (pos && pos->s_ns && pos->s_ns != ns) {
937 struct rb_node *p = rb_next(&pos->inode_node);
938 if (!p)
939 pos = NULL;
940 else
941 pos = rb_entry(p, struct sysfs_dirent, inode_node);
942 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800943 return pos;
944}
945
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700946static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
947 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800948{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700949 pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400950 if (pos) do {
951 struct rb_node *p = rb_next(&pos->inode_node);
952 if (!p)
953 pos = NULL;
954 else
955 pos = rb_entry(p, struct sysfs_dirent, inode_node);
956 } while (pos && pos->s_ns && pos->s_ns != ns);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800957 return pos;
958}
959
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
961{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -0800962 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800964 struct sysfs_dirent *pos = filp->private_data;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700965 enum kobj_ns_type type;
966 const void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 ino_t ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700969 type = sysfs_ns_type(parent_sd);
970 ns = sysfs_info(dentry->d_sb)->ns[type];
971
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900972 if (filp->f_pos == 0) {
973 ino = parent_sd->s_ino;
974 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
975 filp->f_pos++;
976 }
977 if (filp->f_pos == 1) {
978 if (parent_sd->s_parent)
979 ino = parent_sd->s_parent->s_ino;
980 else
Eric Sandeendc351252007-06-11 14:02:45 +0900981 ino = parent_sd->s_ino;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900982 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 filp->f_pos++;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900984 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800985 mutex_lock(&sysfs_mutex);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700986 for (pos = sysfs_dir_pos(ns, parent_sd, filp->f_pos, pos);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800987 pos;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700988 pos = sysfs_dir_next_pos(ns, parent_sd, filp->f_pos, pos)) {
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800989 const char * name;
990 unsigned int type;
991 int len, ret;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900992
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800993 name = pos->s_name;
994 len = strlen(name);
995 ino = pos->s_ino;
996 type = dt_type(pos);
997 filp->f_pos = ino;
998 filp->private_data = sysfs_get(pos);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900999
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001000 mutex_unlock(&sysfs_mutex);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001001 ret = filldir(dirent, name, len, filp->f_pos, ino, type);
1002 mutex_lock(&sysfs_mutex);
1003 if (ret < 0)
1004 break;
1005 }
1006 mutex_unlock(&sysfs_mutex);
1007 if ((filp->f_pos > 1) && !pos) { /* EOF */
1008 filp->f_pos = INT_MAX;
1009 filp->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 }
1011 return 0;
1012}
1013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001015const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 .read = generic_read_dir,
1017 .readdir = sysfs_readdir,
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001018 .release = sysfs_dir_release,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +02001019 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020};