blob: 9504d4cb63eb6c0340bef3e9359988f95b764e14 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * dir.c - Operations for sysfs directories.
3 */
4
5#undef DEBUG
6
7#include <linux/fs.h>
8#include <linux/mount.h>
9#include <linux/module.h>
10#include <linux/kobject.h>
Christoph Hellwig5f45f1a2005-06-23 00:09:12 -070011#include <linux/namei.h>
Tejun Heo2b611bb2007-06-14 03:45:13 +090012#include <linux/idr.h>
Tejun Heo8619f972007-06-14 03:45:18 +090013#include <linux/completion.h>
Dave Young869512a2007-07-26 14:53:53 +000014#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include "sysfs.h"
16
Tejun Heo3007e992007-06-14 04:27:23 +090017DEFINE_MUTEX(sysfs_mutex);
Tejun Heo5f995322007-06-14 04:27:23 +090018spinlock_t sysfs_assoc_lock = SPIN_LOCK_UNLOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Tejun Heo2b611bb2007-06-14 03:45:13 +090020static spinlock_t sysfs_ino_lock = SPIN_LOCK_UNLOCKED;
21static DEFINE_IDA(sysfs_ino_ida);
22
Tejun Heob6b4a432007-06-14 03:45:18 +090023/**
Tejun Heo0c73f182007-06-14 03:45:18 +090024 * sysfs_link_sibling - link sysfs_dirent into sibling list
25 * @sd: sysfs_dirent of interest
26 *
27 * Link @sd into its sibling list which starts from
28 * sd->s_parent->s_children.
29 *
30 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090031 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +090032 */
Tejun Heofb6896d2007-06-14 04:27:24 +090033void sysfs_link_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +090034{
35 struct sysfs_dirent *parent_sd = sd->s_parent;
36
37 BUG_ON(sd->s_sibling);
38 sd->s_sibling = parent_sd->s_children;
39 parent_sd->s_children = sd;
40}
41
42/**
43 * sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
44 * @sd: sysfs_dirent of interest
45 *
46 * Unlink @sd from its sibling list which starts from
47 * sd->s_parent->s_children.
48 *
49 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090050 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +090051 */
Tejun Heofb6896d2007-06-14 04:27:24 +090052void sysfs_unlink_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +090053{
54 struct sysfs_dirent **pos;
55
56 for (pos = &sd->s_parent->s_children; *pos; pos = &(*pos)->s_sibling) {
57 if (*pos == sd) {
58 *pos = sd->s_sibling;
59 sd->s_sibling = NULL;
60 break;
61 }
62 }
63}
64
65/**
Tejun Heo53e0ae92007-06-14 04:27:25 +090066 * sysfs_get_dentry - get dentry for the given sysfs_dirent
67 * @sd: sysfs_dirent of interest
68 *
69 * Get dentry for @sd. Dentry is looked up if currently not
70 * present. This function climbs sysfs_dirent tree till it
71 * reaches a sysfs_dirent with valid dentry attached and descends
72 * down from there looking up dentry for each step.
73 *
74 * LOCKING:
75 * Kernel thread context (may sleep)
76 *
77 * RETURNS:
78 * Pointer to found dentry on success, ERR_PTR() value on error.
79 */
80struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd)
81{
82 struct sysfs_dirent *cur;
83 struct dentry *parent_dentry, *dentry;
84 int i, depth;
85
86 /* Find the first parent which has valid s_dentry and get the
87 * dentry.
88 */
89 mutex_lock(&sysfs_mutex);
90 restart0:
91 spin_lock(&sysfs_assoc_lock);
92 restart1:
93 spin_lock(&dcache_lock);
94
95 dentry = NULL;
96 depth = 0;
97 cur = sd;
98 while (!cur->s_dentry || !cur->s_dentry->d_inode) {
99 if (cur->s_flags & SYSFS_FLAG_REMOVED) {
100 dentry = ERR_PTR(-ENOENT);
101 depth = 0;
102 break;
103 }
104 cur = cur->s_parent;
105 depth++;
106 }
107 if (!IS_ERR(dentry))
108 dentry = dget_locked(cur->s_dentry);
109
110 spin_unlock(&dcache_lock);
111 spin_unlock(&sysfs_assoc_lock);
112
113 /* from the found dentry, look up depth times */
114 while (depth--) {
115 /* find and get depth'th ancestor */
116 for (cur = sd, i = 0; cur && i < depth; i++)
117 cur = cur->s_parent;
118
119 /* This can happen if tree structure was modified due
120 * to move/rename. Restart.
121 */
122 if (i != depth) {
123 dput(dentry);
124 goto restart0;
125 }
126
127 sysfs_get(cur);
128
129 mutex_unlock(&sysfs_mutex);
130
131 /* look it up */
132 parent_dentry = dentry;
133 dentry = lookup_one_len_kern(cur->s_name, parent_dentry,
134 strlen(cur->s_name));
135 dput(parent_dentry);
136
137 if (IS_ERR(dentry)) {
138 sysfs_put(cur);
139 return dentry;
140 }
141
142 mutex_lock(&sysfs_mutex);
143 spin_lock(&sysfs_assoc_lock);
144
145 /* This, again, can happen if tree structure has
146 * changed and we looked up the wrong thing. Restart.
147 */
148 if (cur->s_dentry != dentry) {
149 dput(dentry);
150 sysfs_put(cur);
151 goto restart1;
152 }
153
154 spin_unlock(&sysfs_assoc_lock);
155
156 sysfs_put(cur);
157 }
158
159 mutex_unlock(&sysfs_mutex);
160 return dentry;
161}
162
163/**
Tejun Heob6b4a432007-06-14 03:45:18 +0900164 * sysfs_get_active - get an active reference to sysfs_dirent
165 * @sd: sysfs_dirent to get an active reference to
166 *
167 * Get an active reference of @sd. This function is noop if @sd
168 * is NULL.
169 *
170 * RETURNS:
171 * Pointer to @sd on success, NULL on failure.
172 */
173struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
174{
Tejun Heo8619f972007-06-14 03:45:18 +0900175 if (unlikely(!sd))
176 return NULL;
177
178 while (1) {
179 int v, t;
180
181 v = atomic_read(&sd->s_active);
182 if (unlikely(v < 0))
183 return NULL;
184
185 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
186 if (likely(t == v))
187 return sd;
188 if (t < 0)
189 return NULL;
190
191 cpu_relax();
Tejun Heob6b4a432007-06-14 03:45:18 +0900192 }
Tejun Heob6b4a432007-06-14 03:45:18 +0900193}
194
195/**
196 * sysfs_put_active - put an active reference to sysfs_dirent
197 * @sd: sysfs_dirent to put an active reference to
198 *
199 * Put an active reference to @sd. This function is noop if @sd
200 * is NULL.
201 */
202void sysfs_put_active(struct sysfs_dirent *sd)
203{
Tejun Heo8619f972007-06-14 03:45:18 +0900204 struct completion *cmpl;
205 int v;
206
207 if (unlikely(!sd))
208 return;
209
210 v = atomic_dec_return(&sd->s_active);
211 if (likely(v != SD_DEACTIVATED_BIAS))
212 return;
213
214 /* atomic_dec_return() is a mb(), we'll always see the updated
Tejun Heo0c73f182007-06-14 03:45:18 +0900215 * sd->s_sibling.
Tejun Heo8619f972007-06-14 03:45:18 +0900216 */
Tejun Heo0c73f182007-06-14 03:45:18 +0900217 cmpl = (void *)sd->s_sibling;
Tejun Heo8619f972007-06-14 03:45:18 +0900218 complete(cmpl);
Tejun Heob6b4a432007-06-14 03:45:18 +0900219}
220
221/**
222 * sysfs_get_active_two - get active references to sysfs_dirent and parent
223 * @sd: sysfs_dirent of interest
224 *
225 * Get active reference to @sd and its parent. Parent's active
226 * reference is grabbed first. This function is noop if @sd is
227 * NULL.
228 *
229 * RETURNS:
230 * Pointer to @sd on success, NULL on failure.
231 */
232struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd)
233{
234 if (sd) {
235 if (sd->s_parent && unlikely(!sysfs_get_active(sd->s_parent)))
236 return NULL;
237 if (unlikely(!sysfs_get_active(sd))) {
238 sysfs_put_active(sd->s_parent);
239 return NULL;
240 }
241 }
242 return sd;
243}
244
245/**
246 * sysfs_put_active_two - put active references to sysfs_dirent and parent
247 * @sd: sysfs_dirent of interest
248 *
249 * Put active references to @sd and its parent. This function is
250 * noop if @sd is NULL.
251 */
252void sysfs_put_active_two(struct sysfs_dirent *sd)
253{
254 if (sd) {
255 sysfs_put_active(sd);
256 sysfs_put_active(sd->s_parent);
257 }
258}
259
260/**
261 * sysfs_deactivate - deactivate sysfs_dirent
262 * @sd: sysfs_dirent to deactivate
263 *
Tejun Heo8619f972007-06-14 03:45:18 +0900264 * Deny new active references and drain existing ones.
Tejun Heob6b4a432007-06-14 03:45:18 +0900265 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900266static void sysfs_deactivate(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900267{
Tejun Heo8619f972007-06-14 03:45:18 +0900268 DECLARE_COMPLETION_ONSTACK(wait);
269 int v;
Tejun Heob6b4a432007-06-14 03:45:18 +0900270
Tejun Heo380e6fb2007-06-14 04:27:22 +0900271 BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
Tejun Heo0c73f182007-06-14 03:45:18 +0900272 sd->s_sibling = (void *)&wait;
Tejun Heo8619f972007-06-14 03:45:18 +0900273
274 /* atomic_add_return() is a mb(), put_active() will always see
Tejun Heo0c73f182007-06-14 03:45:18 +0900275 * the updated sd->s_sibling.
Tejun Heob6b4a432007-06-14 03:45:18 +0900276 */
Tejun Heo8619f972007-06-14 03:45:18 +0900277 v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
278
279 if (v != SD_DEACTIVATED_BIAS)
280 wait_for_completion(&wait);
281
Tejun Heo0c73f182007-06-14 03:45:18 +0900282 sd->s_sibling = NULL;
Tejun Heob6b4a432007-06-14 03:45:18 +0900283}
284
Tejun Heo42b37df2007-06-14 03:45:17 +0900285static int sysfs_alloc_ino(ino_t *pino)
Tejun Heo2b611bb2007-06-14 03:45:13 +0900286{
287 int ino, rc;
288
289 retry:
290 spin_lock(&sysfs_ino_lock);
291 rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
292 spin_unlock(&sysfs_ino_lock);
293
294 if (rc == -EAGAIN) {
295 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
296 goto retry;
297 rc = -ENOMEM;
298 }
299
300 *pino = ino;
301 return rc;
302}
303
304static void sysfs_free_ino(ino_t ino)
305{
306 spin_lock(&sysfs_ino_lock);
307 ida_remove(&sysfs_ino_ida, ino);
308 spin_unlock(&sysfs_ino_lock);
309}
310
Tejun Heofa7f9122007-06-14 03:45:13 +0900311void release_sysfs_dirent(struct sysfs_dirent * sd)
312{
Tejun Heo13b30862007-06-14 03:45:14 +0900313 struct sysfs_dirent *parent_sd;
314
315 repeat:
Tejun Heo3007e992007-06-14 04:27:23 +0900316 /* Moving/renaming is always done while holding reference.
317 * sd->s_parent won't change beneath us.
318 */
Tejun Heo13b30862007-06-14 03:45:14 +0900319 parent_sd = sd->s_parent;
320
Tejun Heob402d722007-06-14 04:27:21 +0900321 if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
Tejun Heo2b29ac22007-06-14 03:45:15 +0900322 sysfs_put(sd->s_elem.symlink.target_sd);
Tejun Heob402d722007-06-14 04:27:21 +0900323 if (sysfs_type(sd) & SYSFS_COPY_NAME)
Tejun Heo0c096b52007-06-14 03:45:15 +0900324 kfree(sd->s_name);
Tejun Heofa7f9122007-06-14 03:45:13 +0900325 kfree(sd->s_iattr);
Tejun Heo2b611bb2007-06-14 03:45:13 +0900326 sysfs_free_ino(sd->s_ino);
Tejun Heofa7f9122007-06-14 03:45:13 +0900327 kmem_cache_free(sysfs_dir_cachep, sd);
Tejun Heo13b30862007-06-14 03:45:14 +0900328
329 sd = parent_sd;
330 if (sd && atomic_dec_and_test(&sd->s_count))
331 goto repeat;
Tejun Heofa7f9122007-06-14 03:45:13 +0900332}
333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
335{
336 struct sysfs_dirent * sd = dentry->d_fsdata;
337
338 if (sd) {
Tejun Heo5f995322007-06-14 04:27:23 +0900339 /* sd->s_dentry is protected with sysfs_assoc_lock.
340 * This allows sysfs_drop_dentry() to dereference it.
Tejun Heodd14cbc2007-06-11 14:04:01 +0900341 */
Tejun Heo5f995322007-06-14 04:27:23 +0900342 spin_lock(&sysfs_assoc_lock);
Tejun Heodd14cbc2007-06-11 14:04:01 +0900343
344 /* The dentry might have been deleted or another
345 * lookup could have happened updating sd->s_dentry to
346 * point the new dentry. Ignore if it isn't pointing
347 * to this dentry.
348 */
349 if (sd->s_dentry == dentry)
350 sd->s_dentry = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900351 spin_unlock(&sysfs_assoc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 sysfs_put(sd);
353 }
354 iput(inode);
355}
356
357static struct dentry_operations sysfs_dentry_ops = {
358 .d_iput = sysfs_d_iput,
359};
360
Tejun Heo3e519032007-06-14 03:45:15 +0900361struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Tejun Heo0c096b52007-06-14 03:45:15 +0900363 char *dup_name = NULL;
Akinobu Mita01da2422007-07-14 11:03:35 +0900364 struct sysfs_dirent *sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900365
366 if (type & SYSFS_COPY_NAME) {
367 name = dup_name = kstrdup(name, GFP_KERNEL);
368 if (!name)
Akinobu Mita01da2422007-07-14 11:03:35 +0900369 return NULL;
Tejun Heo0c096b52007-06-14 03:45:15 +0900370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800372 sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (!sd)
Akinobu Mita01da2422007-07-14 11:03:35 +0900374 goto err_out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Tejun Heo0c096b52007-06-14 03:45:15 +0900376 if (sysfs_alloc_ino(&sd->s_ino))
Akinobu Mita01da2422007-07-14 11:03:35 +0900377 goto err_out2;
Tejun Heo2b611bb2007-06-14 03:45:13 +0900378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 atomic_set(&sd->s_count, 1);
Tejun Heo8619f972007-06-14 03:45:18 +0900380 atomic_set(&sd->s_active, 0);
Juha Yrjöläeea3f892006-08-03 19:06:25 +0300381 atomic_set(&sd->s_event, 1);
Tejun Heoa26cd722007-06-14 03:45:14 +0900382
Tejun Heo0c096b52007-06-14 03:45:15 +0900383 sd->s_name = name;
Tejun Heoa26cd722007-06-14 03:45:14 +0900384 sd->s_mode = mode;
Tejun Heob402d722007-06-14 04:27:21 +0900385 sd->s_flags = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
387 return sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900388
Akinobu Mita01da2422007-07-14 11:03:35 +0900389 err_out2:
Tejun Heo0c096b52007-06-14 03:45:15 +0900390 kmem_cache_free(sysfs_dir_cachep, sd);
Akinobu Mita01da2422007-07-14 11:03:35 +0900391 err_out1:
392 kfree(dup_name);
Tejun Heo0c096b52007-06-14 03:45:15 +0900393 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394}
395
Tejun Heo3007e992007-06-14 04:27:23 +0900396/**
397 * sysfs_attach_dentry - associate sysfs_dirent with dentry
398 * @sd: target sysfs_dirent
399 * @dentry: dentry to associate
400 *
401 * Associate @sd with @dentry. This is protected by
402 * sysfs_assoc_lock to avoid race with sysfs_d_iput().
403 *
404 * LOCKING:
405 * mutex_lock(sysfs_mutex)
406 */
Tejun Heo198a2a82007-06-14 03:45:16 +0900407static void sysfs_attach_dentry(struct sysfs_dirent *sd, struct dentry *dentry)
408{
409 dentry->d_op = &sysfs_dentry_ops;
410 dentry->d_fsdata = sysfs_get(sd);
411
412 /* protect sd->s_dentry against sysfs_d_iput */
Tejun Heo5f995322007-06-14 04:27:23 +0900413 spin_lock(&sysfs_assoc_lock);
Tejun Heo198a2a82007-06-14 03:45:16 +0900414 sd->s_dentry = dentry;
Tejun Heo5f995322007-06-14 04:27:23 +0900415 spin_unlock(&sysfs_assoc_lock);
Tejun Heo198a2a82007-06-14 03:45:16 +0900416
417 d_rehash(dentry);
418}
419
Tejun Heofb6896d2007-06-14 04:27:24 +0900420static int sysfs_ilookup_test(struct inode *inode, void *arg)
421{
422 struct sysfs_dirent *sd = arg;
423 return inode->i_ino == sd->s_ino;
424}
425
Tejun Heo3007e992007-06-14 04:27:23 +0900426/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900427 * sysfs_addrm_start - prepare for sysfs_dirent add/remove
428 * @acxt: pointer to sysfs_addrm_cxt to be used
429 * @parent_sd: parent sysfs_dirent
Tejun Heo3007e992007-06-14 04:27:23 +0900430 *
Tejun Heofb6896d2007-06-14 04:27:24 +0900431 * This function is called when the caller is about to add or
432 * remove sysfs_dirent under @parent_sd. This function acquires
433 * sysfs_mutex, grabs inode for @parent_sd if available and lock
434 * i_mutex of it. @acxt is used to keep and pass context to
435 * other addrm functions.
Tejun Heo3007e992007-06-14 04:27:23 +0900436 *
437 * LOCKING:
Tejun Heofb6896d2007-06-14 04:27:24 +0900438 * Kernel thread context (may sleep). sysfs_mutex is locked on
439 * return. i_mutex of parent inode is locked on return if
440 * available.
Tejun Heo3007e992007-06-14 04:27:23 +0900441 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900442void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
443 struct sysfs_dirent *parent_sd)
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700444{
Tejun Heofb6896d2007-06-14 04:27:24 +0900445 struct inode *inode;
Tejun Heoa26cd722007-06-14 03:45:14 +0900446
Tejun Heofb6896d2007-06-14 04:27:24 +0900447 memset(acxt, 0, sizeof(*acxt));
448 acxt->parent_sd = parent_sd;
449
450 /* Lookup parent inode. inode initialization and I_NEW
451 * clearing are protected by sysfs_mutex. By grabbing it and
452 * looking up with _nowait variant, inode state can be
453 * determined reliably.
454 */
455 mutex_lock(&sysfs_mutex);
456
457 inode = ilookup5_nowait(sysfs_sb, parent_sd->s_ino, sysfs_ilookup_test,
458 parent_sd);
459
460 if (inode && !(inode->i_state & I_NEW)) {
461 /* parent inode available */
462 acxt->parent_inode = inode;
463
464 /* sysfs_mutex is below i_mutex in lock hierarchy.
465 * First, trylock i_mutex. If fails, unlock
466 * sysfs_mutex and lock them in order.
467 */
468 if (!mutex_trylock(&inode->i_mutex)) {
469 mutex_unlock(&sysfs_mutex);
470 mutex_lock(&inode->i_mutex);
471 mutex_lock(&sysfs_mutex);
472 }
473 } else
474 iput(inode);
475}
476
477/**
478 * sysfs_add_one - add sysfs_dirent to parent
479 * @acxt: addrm context to use
480 * @sd: sysfs_dirent to be added
481 *
482 * Get @acxt->parent_sd and set sd->s_parent to it and increment
483 * nlink of parent inode if @sd is a directory. @sd is NOT
484 * linked into the children list of the parent. The caller
485 * should invoke sysfs_link_sibling() after this function
486 * completes if @sd needs to be on the children list.
487 *
488 * This function should be called between calls to
489 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
490 * passed the same @acxt as passed to sysfs_addrm_start().
491 *
492 * LOCKING:
493 * Determined by sysfs_addrm_start().
494 */
495void sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
496{
497 sd->s_parent = sysfs_get(acxt->parent_sd);
498
499 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
500 inc_nlink(acxt->parent_inode);
501
502 acxt->cnt++;
503}
504
505/**
506 * sysfs_remove_one - remove sysfs_dirent from parent
507 * @acxt: addrm context to use
508 * @sd: sysfs_dirent to be added
509 *
510 * Mark @sd removed and drop nlink of parent inode if @sd is a
511 * directory. @sd is NOT unlinked from the children list of the
512 * parent. The caller is repsonsible for removing @sd from the
513 * children list before calling this function.
514 *
515 * This function should be called between calls to
516 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
517 * passed the same @acxt as passed to sysfs_addrm_start().
518 *
519 * LOCKING:
520 * Determined by sysfs_addrm_start().
521 */
522void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
523{
524 BUG_ON(sd->s_sibling || (sd->s_flags & SYSFS_FLAG_REMOVED));
525
526 sd->s_flags |= SYSFS_FLAG_REMOVED;
527 sd->s_sibling = acxt->removed;
528 acxt->removed = sd;
529
530 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
531 drop_nlink(acxt->parent_inode);
532
533 acxt->cnt++;
534}
535
536/**
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900537 * sysfs_drop_dentry - drop dentry for the specified sysfs_dirent
538 * @sd: target sysfs_dirent
539 *
540 * Drop dentry for @sd. @sd must have been unlinked from its
541 * parent on entry to this function such that it can't be looked
542 * up anymore.
543 *
544 * @sd->s_dentry which is protected with sysfs_assoc_lock points
545 * to the currently associated dentry but we're not holding a
546 * reference to it and racing with dput(). Grab dcache_lock and
547 * verify dentry before dropping it. If @sd->s_dentry is NULL or
548 * dput() beats us, no need to bother.
549 */
550static void sysfs_drop_dentry(struct sysfs_dirent *sd)
551{
552 struct dentry *dentry = NULL;
553 struct inode *inode;
554
555 /* We're not holding a reference to ->s_dentry dentry but the
556 * field will stay valid as long as sysfs_assoc_lock is held.
557 */
558 spin_lock(&sysfs_assoc_lock);
559 spin_lock(&dcache_lock);
560
561 /* drop dentry if it's there and dput() didn't kill it yet */
562 if (sd->s_dentry && sd->s_dentry->d_inode) {
563 dentry = dget_locked(sd->s_dentry);
564 spin_lock(&dentry->d_lock);
565 __d_drop(dentry);
566 spin_unlock(&dentry->d_lock);
567 }
568
569 spin_unlock(&dcache_lock);
570 spin_unlock(&sysfs_assoc_lock);
571
Tejun Heo51225032007-06-14 04:27:25 +0900572 dput(dentry);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900573
574 /* adjust nlink and update timestamp */
575 inode = ilookup(sysfs_sb, sd->s_ino);
576 if (inode) {
577 mutex_lock(&inode->i_mutex);
578
579 inode->i_ctime = CURRENT_TIME;
580 drop_nlink(inode);
581 if (sysfs_type(sd) == SYSFS_DIR)
582 drop_nlink(inode);
583
584 mutex_unlock(&inode->i_mutex);
585 iput(inode);
586 }
587}
588
589/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900590 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
591 * @acxt: addrm context to finish up
592 *
593 * Finish up sysfs_dirent add/remove. Resources acquired by
594 * sysfs_addrm_start() are released and removed sysfs_dirents are
595 * cleaned up. Timestamps on the parent inode are updated.
596 *
597 * LOCKING:
598 * All mutexes acquired by sysfs_addrm_start() are released.
599 *
600 * RETURNS:
601 * Number of added/removed sysfs_dirents since sysfs_addrm_start().
602 */
603int sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
604{
605 /* release resources acquired by sysfs_addrm_start() */
606 mutex_unlock(&sysfs_mutex);
607 if (acxt->parent_inode) {
608 struct inode *inode = acxt->parent_inode;
609
610 /* if added/removed, update timestamps on the parent */
611 if (acxt->cnt)
612 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
613
614 mutex_unlock(&inode->i_mutex);
615 iput(inode);
Tejun Heo13b30862007-06-14 03:45:14 +0900616 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900617
618 /* kill removed sysfs_dirents */
619 while (acxt->removed) {
620 struct sysfs_dirent *sd = acxt->removed;
621
622 acxt->removed = sd->s_sibling;
623 sd->s_sibling = NULL;
624
625 sysfs_drop_dentry(sd);
626 sysfs_deactivate(sd);
627 sysfs_put(sd);
628 }
629
630 return acxt->cnt;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700631}
632
Tejun Heof0b0af42007-06-14 04:27:22 +0900633/**
634 * sysfs_find_dirent - find sysfs_dirent with the given name
635 * @parent_sd: sysfs_dirent to search under
636 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530637 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900638 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530639 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900640 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900641 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900642 *
643 * RETURNS:
644 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530645 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900646struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
647 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530648{
Tejun Heof0b0af42007-06-14 04:27:22 +0900649 struct sysfs_dirent *sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530650
Tejun Heof0b0af42007-06-14 04:27:22 +0900651 for (sd = parent_sd->s_children; sd; sd = sd->s_sibling)
652 if (sysfs_type(sd) && !strcmp(sd->s_name, name))
653 return sd;
654 return NULL;
655}
Maneesh Sonic5168652006-03-09 19:40:14 +0530656
Tejun Heof0b0af42007-06-14 04:27:22 +0900657/**
658 * sysfs_get_dirent - find and get sysfs_dirent with the given name
659 * @parent_sd: sysfs_dirent to search under
660 * @name: name to look for
661 *
662 * Look for sysfs_dirent with name @name under @parent_sd and get
663 * it if found.
664 *
665 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900666 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900667 *
668 * RETURNS:
669 * Pointer to sysfs_dirent if found, NULL if not.
670 */
671struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
672 const unsigned char *name)
673{
674 struct sysfs_dirent *sd;
675
Tejun Heo3007e992007-06-14 04:27:23 +0900676 mutex_lock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900677 sd = sysfs_find_dirent(parent_sd, name);
678 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900679 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900680
681 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530682}
683
Tejun Heo608e2662007-06-14 04:27:22 +0900684static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
685 const char *name, struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900688 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900689 struct sysfs_dirent *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Tejun Heofc9f54b2007-06-14 03:45:17 +0900691 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900692 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900693 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900694 return -ENOMEM;
Tejun Heo3e519032007-06-14 03:45:15 +0900695 sd->s_elem.dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900696
Tejun Heo51225032007-06-14 04:27:25 +0900697 /* link in */
698 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo967e35d2007-07-18 16:38:11 +0900699
Tejun Heo51225032007-06-14 04:27:25 +0900700 if (!sysfs_find_dirent(parent_sd, name)) {
701 sysfs_add_one(&acxt, sd);
702 sysfs_link_sibling(sd);
703 }
Tejun Heo967e35d2007-07-18 16:38:11 +0900704
705 if (!sysfs_addrm_finish(&acxt)) {
706 sysfs_put(sd);
707 return -EEXIST;
Tejun Heo8312a8d2007-06-14 03:45:17 +0900708 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900709
Tejun Heo967e35d2007-07-18 16:38:11 +0900710 *p_sd = sd;
711 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712}
713
Tejun Heo608e2662007-06-14 04:27:22 +0900714int sysfs_create_subdir(struct kobject *kobj, const char *name,
715 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
Tejun Heo608e2662007-06-14 04:27:22 +0900717 return create_dir(kobj, kobj->sd, name, p_sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
720/**
721 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 * @kobj: object we're creating directory for.
723 */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900724int sysfs_create_dir(struct kobject * kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
Tejun Heo608e2662007-06-14 04:27:22 +0900726 struct sysfs_dirent *parent_sd, *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 int error = 0;
728
729 BUG_ON(!kobj);
730
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900731 if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900732 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 else if (sysfs_mount && sysfs_mount->mnt_sb)
Tejun Heo608e2662007-06-14 04:27:22 +0900734 parent_sd = sysfs_mount->mnt_sb->s_root->d_fsdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 else
736 return -EFAULT;
737
Tejun Heo608e2662007-06-14 04:27:22 +0900738 error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900740 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 return error;
742}
743
Tejun Heo51225032007-06-14 04:27:25 +0900744static int sysfs_count_nlink(struct sysfs_dirent *sd)
745{
746 struct sysfs_dirent *child;
747 int nr = 0;
748
749 for (child = sd->s_children; child; child = child->s_sibling)
750 if (sysfs_type(child) == SYSFS_DIR)
751 nr++;
752 return nr + 2;
753}
754
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
756 struct nameidata *nd)
757{
Tejun Heo6cb52142007-07-31 19:15:08 +0900758 struct dentry *ret = NULL;
Tejun Heoa7a04752007-08-02 21:38:02 +0900759 struct sysfs_dirent *parent_sd = dentry->d_parent->d_fsdata;
760 struct sysfs_dirent *sd;
Tejun Heob402d722007-06-14 04:27:21 +0900761 struct bin_attribute *bin_attr;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900762 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Tejun Heo6cb52142007-07-31 19:15:08 +0900764 mutex_lock(&sysfs_mutex);
765
Tejun Heoa7a04752007-08-02 21:38:02 +0900766 for (sd = parent_sd->s_children; sd; sd = sd->s_sibling)
767 if (sysfs_type(sd) && !strcmp(sd->s_name, dentry->d_name.name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Tejun Heofc9f54b2007-06-14 03:45:17 +0900770 /* no such entry */
Tejun Heoa7a04752007-08-02 21:38:02 +0900771 if (!sd)
Tejun Heo6cb52142007-07-31 19:15:08 +0900772 goto out_unlock;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900773
774 /* attach dentry and inode */
Tejun Heo8312a8d2007-06-14 03:45:17 +0900775 inode = sysfs_get_inode(sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900776 if (!inode) {
777 ret = ERR_PTR(-ENOMEM);
778 goto out_unlock;
779 }
Tejun Heo3007e992007-06-14 04:27:23 +0900780
Tejun Heo8312a8d2007-06-14 03:45:17 +0900781 if (inode->i_state & I_NEW) {
782 /* initialize inode according to type */
Tejun Heob402d722007-06-14 04:27:21 +0900783 switch (sysfs_type(sd)) {
Tejun Heo51225032007-06-14 04:27:25 +0900784 case SYSFS_DIR:
785 inode->i_op = &sysfs_dir_inode_operations;
786 inode->i_fop = &sysfs_dir_operations;
787 inode->i_nlink = sysfs_count_nlink(sd);
788 break;
Tejun Heob402d722007-06-14 04:27:21 +0900789 case SYSFS_KOBJ_ATTR:
Tejun Heo8312a8d2007-06-14 03:45:17 +0900790 inode->i_size = PAGE_SIZE;
791 inode->i_fop = &sysfs_file_operations;
Tejun Heob402d722007-06-14 04:27:21 +0900792 break;
793 case SYSFS_KOBJ_BIN_ATTR:
794 bin_attr = sd->s_elem.bin_attr.bin_attr;
Tejun Heo8312a8d2007-06-14 03:45:17 +0900795 inode->i_size = bin_attr->size;
796 inode->i_fop = &bin_fops;
Tejun Heob402d722007-06-14 04:27:21 +0900797 break;
798 case SYSFS_KOBJ_LINK:
Tejun Heo8312a8d2007-06-14 03:45:17 +0900799 inode->i_op = &sysfs_symlink_inode_operations;
Tejun Heob402d722007-06-14 04:27:21 +0900800 break;
801 default:
802 BUG();
803 }
Tejun Heo8312a8d2007-06-14 03:45:17 +0900804 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900805
806 sysfs_instantiate(dentry, inode);
807 sysfs_attach_dentry(sd, dentry);
808
Tejun Heo6cb52142007-07-31 19:15:08 +0900809 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900810 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900811 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812}
813
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800814const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 .lookup = sysfs_lookup,
Maneesh Soni988d1862005-05-31 10:39:14 +0530816 .setattr = sysfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817};
818
Tejun Heo608e2662007-06-14 04:27:22 +0900819static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820{
Tejun Heofb6896d2007-06-14 04:27:24 +0900821 struct sysfs_addrm_cxt acxt;
822
823 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heo0c73f182007-06-14 03:45:18 +0900824 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900825 sysfs_remove_one(&acxt, sd);
826 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827}
828
Tejun Heo608e2662007-06-14 04:27:22 +0900829void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830{
Tejun Heo608e2662007-06-14 04:27:22 +0900831 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832}
833
834
Tejun Heo608e2662007-06-14 04:27:22 +0900835static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
Tejun Heofb6896d2007-06-14 04:27:24 +0900837 struct sysfs_addrm_cxt acxt;
Tejun Heo0c73f182007-06-14 03:45:18 +0900838 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Tejun Heo608e2662007-06-14 04:27:22 +0900840 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return;
842
Tejun Heo608e2662007-06-14 04:27:22 +0900843 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900844 sysfs_addrm_start(&acxt, dir_sd);
Tejun Heo608e2662007-06-14 04:27:22 +0900845 pos = &dir_sd->s_children;
Tejun Heo0c73f182007-06-14 03:45:18 +0900846 while (*pos) {
847 struct sysfs_dirent *sd = *pos;
848
Tejun Heo51225032007-06-14 04:27:25 +0900849 if (sysfs_type(sd) && sysfs_type(sd) != SYSFS_DIR) {
Tejun Heo0c73f182007-06-14 03:45:18 +0900850 *pos = sd->s_sibling;
Tejun Heofb6896d2007-06-14 04:27:24 +0900851 sd->s_sibling = NULL;
852 sysfs_remove_one(&acxt, sd);
Tejun Heo0c73f182007-06-14 03:45:18 +0900853 } else
854 pos = &(*pos)->s_sibling;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900856 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900857
Tejun Heo608e2662007-06-14 04:27:22 +0900858 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700859}
860
861/**
862 * sysfs_remove_dir - remove an object's directory.
863 * @kobj: object.
864 *
865 * The only thing special about this is that we remove any files in
866 * the directory before we remove the directory, and we've inlined
867 * what used to be sysfs_rmdir() below, instead of calling separately.
868 */
869
870void sysfs_remove_dir(struct kobject * kobj)
871{
Tejun Heo608e2662007-06-14 04:27:22 +0900872 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900873
Tejun Heo5f995322007-06-14 04:27:23 +0900874 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900875 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900876 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900877
Tejun Heo608e2662007-06-14 04:27:22 +0900878 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879}
880
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900881int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900883 struct sysfs_dirent *sd;
884 struct dentry *parent = NULL;
Tejun Heo51225032007-06-14 04:27:25 +0900885 struct dentry *old_dentry = NULL, *new_dentry = NULL;
886 const char *dup_name = NULL;
Tejun Heo996b7372007-06-14 03:45:14 +0900887 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
Tejun Heoff869de2007-08-02 21:38:02 +0900889 /* get the original dentry */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900890 sd = kobj->sd;
Tejun Heo51225032007-06-14 04:27:25 +0900891 old_dentry = sysfs_get_dentry(sd);
892 if (IS_ERR(old_dentry)) {
893 error = PTR_ERR(old_dentry);
894 goto out_dput;
895 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Tejun Heoff869de2007-08-02 21:38:02 +0900897 parent = old_dentry->d_parent;
Tejun Heo51225032007-06-14 04:27:25 +0900898
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900899 /* lock parent and get dentry for new name */
900 mutex_lock(&parent->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900902 new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
Tejun Heo996b7372007-06-14 03:45:14 +0900903 if (IS_ERR(new_dentry)) {
904 error = PTR_ERR(new_dentry);
905 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
Tejun Heo996b7372007-06-14 03:45:14 +0900907
Tejun Heo996b7372007-06-14 03:45:14 +0900908 error = -EINVAL;
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900909 if (old_dentry == new_dentry)
Tejun Heo51225032007-06-14 04:27:25 +0900910 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900911
912 error = -EEXIST;
913 if (new_dentry->d_inode)
Tejun Heo51225032007-06-14 04:27:25 +0900914 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900915
Tejun Heo0c096b52007-06-14 03:45:15 +0900916 /* rename kobject and sysfs_dirent */
917 error = -ENOMEM;
918 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
919 if (!new_name)
Tejun Heo996b7372007-06-14 03:45:14 +0900920 goto out_drop;
921
Tejun Heo0c096b52007-06-14 03:45:15 +0900922 error = kobject_set_name(kobj, "%s", new_name);
923 if (error)
Tejun Heo51225032007-06-14 04:27:25 +0900924 goto out_drop;
Tejun Heo0c096b52007-06-14 03:45:15 +0900925
Tejun Heo6cb52142007-07-31 19:15:08 +0900926 mutex_lock(&sysfs_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900927 dup_name = sd->s_name;
Tejun Heo0c096b52007-06-14 03:45:15 +0900928 sd->s_name = new_name;
Tejun Heoff869de2007-08-02 21:38:02 +0900929 mutex_unlock(&sysfs_mutex);
Tejun Heo0c096b52007-06-14 03:45:15 +0900930
Tejun Heoff869de2007-08-02 21:38:02 +0900931 /* rename */
Tejun Heo996b7372007-06-14 03:45:14 +0900932 d_add(new_dentry, NULL);
Tejun Heo608e2662007-06-14 04:27:22 +0900933 d_move(sd->s_dentry, new_dentry);
Tejun Heo996b7372007-06-14 03:45:14 +0900934
Tejun Heo996b7372007-06-14 03:45:14 +0900935 error = 0;
936 goto out_unlock;
937
938 out_drop:
939 d_drop(new_dentry);
Tejun Heo996b7372007-06-14 03:45:14 +0900940 out_unlock:
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900941 mutex_unlock(&parent->d_inode->i_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900942 out_dput:
943 kfree(dup_name);
Tejun Heo51225032007-06-14 04:27:25 +0900944 dput(old_dentry);
945 dput(new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 return error;
947}
948
Tejun Heo51225032007-06-14 04:27:25 +0900949int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100950{
Tejun Heo51225032007-06-14 04:27:25 +0900951 struct sysfs_dirent *sd = kobj->sd;
952 struct sysfs_dirent *new_parent_sd;
953 struct dentry *old_parent, *new_parent = NULL;
954 struct dentry *old_dentry = NULL, *new_dentry = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100955 int error;
956
Tejun Heo51225032007-06-14 04:27:25 +0900957 BUG_ON(!sd->s_parent);
958 new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100959
Tejun Heo51225032007-06-14 04:27:25 +0900960 /* get dentries */
961 old_dentry = sysfs_get_dentry(sd);
962 if (IS_ERR(old_dentry)) {
963 error = PTR_ERR(old_dentry);
964 goto out_dput;
965 }
966 old_parent = sd->s_parent->s_dentry;
967
968 new_parent = sysfs_get_dentry(new_parent_sd);
969 if (IS_ERR(new_parent)) {
970 error = PTR_ERR(new_parent);
971 goto out_dput;
972 }
973
974 if (old_parent->d_inode == new_parent->d_inode) {
975 error = 0;
976 goto out_dput; /* nothing to move */
977 }
Cornelia Huck8a824722006-11-20 17:07:51 +0100978again:
Tejun Heo51225032007-06-14 04:27:25 +0900979 mutex_lock(&old_parent->d_inode->i_mutex);
980 if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
981 mutex_unlock(&old_parent->d_inode->i_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100982 goto again;
983 }
984
Greg Kroah-Hartman19c38de2007-09-12 15:06:57 -0700985 new_dentry = lookup_one_len(kobject_name(kobj), new_parent, strlen(kobject_name(kobj)));
Cornelia Huck8a824722006-11-20 17:07:51 +0100986 if (IS_ERR(new_dentry)) {
987 error = PTR_ERR(new_dentry);
Tejun Heo51225032007-06-14 04:27:25 +0900988 goto out_unlock;
Cornelia Huck8a824722006-11-20 17:07:51 +0100989 } else
990 error = 0;
991 d_add(new_dentry, NULL);
Tejun Heo608e2662007-06-14 04:27:22 +0900992 d_move(sd->s_dentry, new_dentry);
Cornelia Huck8a824722006-11-20 17:07:51 +0100993 dput(new_dentry);
994
995 /* Remove from old parent's list and insert into new parent's list. */
Tejun Heo3007e992007-06-14 04:27:23 +0900996 mutex_lock(&sysfs_mutex);
997
Tejun Heo0c73f182007-06-14 03:45:18 +0900998 sysfs_unlink_sibling(sd);
Tejun Heo7f7cfff2007-06-14 03:45:17 +0900999 sysfs_get(new_parent_sd);
1000 sysfs_put(sd->s_parent);
1001 sd->s_parent = new_parent_sd;
Tejun Heo0c73f182007-06-14 03:45:18 +09001002 sysfs_link_sibling(sd);
Cornelia Huck8a824722006-11-20 17:07:51 +01001003
Tejun Heo3007e992007-06-14 04:27:23 +09001004 mutex_unlock(&sysfs_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +01001005
Tejun Heo51225032007-06-14 04:27:25 +09001006 out_unlock:
1007 mutex_unlock(&new_parent->d_inode->i_mutex);
1008 mutex_unlock(&old_parent->d_inode->i_mutex);
1009 out_dput:
1010 dput(new_parent);
1011 dput(old_dentry);
1012 dput(new_dentry);
Cornelia Huck8a824722006-11-20 17:07:51 +01001013 return error;
1014}
1015
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016static int sysfs_dir_open(struct inode *inode, struct file *file)
1017{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001018 struct dentry * dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Tejun Heoa26cd722007-06-14 03:45:14 +09001020 struct sysfs_dirent * sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
Tejun Heo3e519032007-06-14 03:45:15 +09001022 sd = sysfs_new_dirent("_DIR_", 0, 0);
Tejun Heo3007e992007-06-14 04:27:23 +09001023 if (sd) {
1024 mutex_lock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +09001025 sd->s_parent = sysfs_get(parent_sd);
1026 sysfs_link_sibling(sd);
Tejun Heo3007e992007-06-14 04:27:23 +09001027 mutex_unlock(&sysfs_mutex);
1028 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Tejun Heoa26cd722007-06-14 03:45:14 +09001030 file->private_data = sd;
1031 return sd ? 0 : -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032}
1033
1034static int sysfs_dir_close(struct inode *inode, struct file *file)
1035{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 struct sysfs_dirent * cursor = file->private_data;
1037
Tejun Heo3007e992007-06-14 04:27:23 +09001038 mutex_lock(&sysfs_mutex);
Tejun Heo0c73f182007-06-14 03:45:18 +09001039 sysfs_unlink_sibling(cursor);
Tejun Heo3007e992007-06-14 04:27:23 +09001040 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
1042 release_sysfs_dirent(cursor);
1043
1044 return 0;
1045}
1046
1047/* Relationship between s_mode and the DT_xxx types */
1048static inline unsigned char dt_type(struct sysfs_dirent *sd)
1049{
1050 return (sd->s_mode >> 12) & 15;
1051}
1052
1053static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
1054{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001055 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
1057 struct sysfs_dirent *cursor = filp->private_data;
Tejun Heo0c73f182007-06-14 03:45:18 +09001058 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 ino_t ino;
1060 int i = filp->f_pos;
1061
1062 switch (i) {
1063 case 0:
Eric Sandeendc351252007-06-11 14:02:45 +09001064 ino = parent_sd->s_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
1066 break;
1067 filp->f_pos++;
1068 i++;
1069 /* fallthrough */
1070 case 1:
Tejun Heo13b30862007-06-14 03:45:14 +09001071 if (parent_sd->s_parent)
1072 ino = parent_sd->s_parent->s_ino;
1073 else
1074 ino = parent_sd->s_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
1076 break;
1077 filp->f_pos++;
1078 i++;
1079 /* fallthrough */
1080 default:
Tejun Heo3007e992007-06-14 04:27:23 +09001081 mutex_lock(&sysfs_mutex);
1082
Tejun Heo0c73f182007-06-14 03:45:18 +09001083 pos = &parent_sd->s_children;
1084 while (*pos != cursor)
1085 pos = &(*pos)->s_sibling;
Akinobu Mita1bfba4e2006-06-26 00:24:40 -07001086
Tejun Heo0c73f182007-06-14 03:45:18 +09001087 /* unlink cursor */
1088 *pos = cursor->s_sibling;
1089
1090 if (filp->f_pos == 2)
1091 pos = &parent_sd->s_children;
1092
1093 for ( ; *pos; pos = &(*pos)->s_sibling) {
1094 struct sysfs_dirent *next = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 const char * name;
1096 int len;
1097
Tejun Heob402d722007-06-14 04:27:21 +09001098 if (!sysfs_type(next))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 continue;
1100
Tejun Heo0c096b52007-06-14 03:45:15 +09001101 name = next->s_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 len = strlen(name);
Eric Sandeendc351252007-06-11 14:02:45 +09001103 ino = next->s_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
1105 if (filldir(dirent, name, len, filp->f_pos, ino,
1106 dt_type(next)) < 0)
Tejun Heo0c73f182007-06-14 03:45:18 +09001107 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 filp->f_pos++;
1110 }
Tejun Heo0c73f182007-06-14 03:45:18 +09001111
1112 /* put cursor back in */
1113 cursor->s_sibling = *pos;
1114 *pos = cursor;
Tejun Heo3007e992007-06-14 04:27:23 +09001115
1116 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 }
1118 return 0;
1119}
1120
1121static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
1122{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001123 struct dentry * dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 switch (origin) {
1126 case 1:
1127 offset += file->f_pos;
1128 case 0:
1129 if (offset >= 0)
1130 break;
1131 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 return -EINVAL;
1133 }
1134 if (offset != file->f_pos) {
Tejun Heo3007e992007-06-14 04:27:23 +09001135 mutex_lock(&sysfs_mutex);
1136
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 file->f_pos = offset;
1138 if (file->f_pos >= 2) {
1139 struct sysfs_dirent *sd = dentry->d_fsdata;
1140 struct sysfs_dirent *cursor = file->private_data;
Tejun Heo0c73f182007-06-14 03:45:18 +09001141 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 loff_t n = file->f_pos - 2;
1143
Tejun Heo0c73f182007-06-14 03:45:18 +09001144 sysfs_unlink_sibling(cursor);
1145
1146 pos = &sd->s_children;
1147 while (n && *pos) {
1148 struct sysfs_dirent *next = *pos;
Tejun Heob402d722007-06-14 04:27:21 +09001149 if (sysfs_type(next))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 n--;
Tejun Heo0c73f182007-06-14 03:45:18 +09001151 pos = &(*pos)->s_sibling;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 }
Tejun Heo0c73f182007-06-14 03:45:18 +09001153
1154 cursor->s_sibling = *pos;
1155 *pos = cursor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 }
Tejun Heo3007e992007-06-14 04:27:23 +09001157
1158 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 }
Tejun Heo3007e992007-06-14 04:27:23 +09001160
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 return offset;
1162}
1163
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001164const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 .open = sysfs_dir_open,
1166 .release = sysfs_dir_close,
1167 .llseek = sysfs_dir_lseek,
1168 .read = generic_read_dir,
1169 .readdir = sysfs_readdir,
1170};