blob: 83e76b3813c9af674fb2c6fda9c2f891c89e0964 [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>
Oliver Neukum94bebf42006-12-20 10:52:44 +010014#include <asm/semaphore.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 /* dentries for shadowed inodes are pinned, unpin */
573 if (dentry && sysfs_is_shadowed_inode(dentry->d_inode))
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900574 dput(dentry);
Tejun Heo51225032007-06-14 04:27:25 +0900575 dput(dentry);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900576
577 /* adjust nlink and update timestamp */
578 inode = ilookup(sysfs_sb, sd->s_ino);
579 if (inode) {
580 mutex_lock(&inode->i_mutex);
581
582 inode->i_ctime = CURRENT_TIME;
583 drop_nlink(inode);
584 if (sysfs_type(sd) == SYSFS_DIR)
585 drop_nlink(inode);
586
587 mutex_unlock(&inode->i_mutex);
588 iput(inode);
589 }
590}
591
592/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900593 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
594 * @acxt: addrm context to finish up
595 *
596 * Finish up sysfs_dirent add/remove. Resources acquired by
597 * sysfs_addrm_start() are released and removed sysfs_dirents are
598 * cleaned up. Timestamps on the parent inode are updated.
599 *
600 * LOCKING:
601 * All mutexes acquired by sysfs_addrm_start() are released.
602 *
603 * RETURNS:
604 * Number of added/removed sysfs_dirents since sysfs_addrm_start().
605 */
606int sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
607{
608 /* release resources acquired by sysfs_addrm_start() */
609 mutex_unlock(&sysfs_mutex);
610 if (acxt->parent_inode) {
611 struct inode *inode = acxt->parent_inode;
612
613 /* if added/removed, update timestamps on the parent */
614 if (acxt->cnt)
615 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
616
617 mutex_unlock(&inode->i_mutex);
618 iput(inode);
Tejun Heo13b30862007-06-14 03:45:14 +0900619 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900620
621 /* kill removed sysfs_dirents */
622 while (acxt->removed) {
623 struct sysfs_dirent *sd = acxt->removed;
624
625 acxt->removed = sd->s_sibling;
626 sd->s_sibling = NULL;
627
628 sysfs_drop_dentry(sd);
629 sysfs_deactivate(sd);
630 sysfs_put(sd);
631 }
632
633 return acxt->cnt;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700634}
635
Tejun Heof0b0af42007-06-14 04:27:22 +0900636/**
637 * sysfs_find_dirent - find sysfs_dirent with the given name
638 * @parent_sd: sysfs_dirent to search under
639 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530640 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900641 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530642 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900643 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900644 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900645 *
646 * RETURNS:
647 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530648 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900649struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
650 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530651{
Tejun Heof0b0af42007-06-14 04:27:22 +0900652 struct sysfs_dirent *sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530653
Tejun Heof0b0af42007-06-14 04:27:22 +0900654 for (sd = parent_sd->s_children; sd; sd = sd->s_sibling)
655 if (sysfs_type(sd) && !strcmp(sd->s_name, name))
656 return sd;
657 return NULL;
658}
Maneesh Sonic5168652006-03-09 19:40:14 +0530659
Tejun Heof0b0af42007-06-14 04:27:22 +0900660/**
661 * sysfs_get_dirent - find and get sysfs_dirent with the given name
662 * @parent_sd: sysfs_dirent to search under
663 * @name: name to look for
664 *
665 * Look for sysfs_dirent with name @name under @parent_sd and get
666 * it if found.
667 *
668 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900669 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900670 *
671 * RETURNS:
672 * Pointer to sysfs_dirent if found, NULL if not.
673 */
674struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
675 const unsigned char *name)
676{
677 struct sysfs_dirent *sd;
678
Tejun Heo3007e992007-06-14 04:27:23 +0900679 mutex_lock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900680 sd = sysfs_find_dirent(parent_sd, name);
681 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900682 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900683
684 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530685}
686
Tejun Heo608e2662007-06-14 04:27:22 +0900687static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
688 const char *name, struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900691 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900692 struct sysfs_dirent *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Tejun Heofc9f54b2007-06-14 03:45:17 +0900694 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900695 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900696 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900697 return -ENOMEM;
Tejun Heo3e519032007-06-14 03:45:15 +0900698 sd->s_elem.dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900699
Tejun Heo51225032007-06-14 04:27:25 +0900700 /* link in */
701 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo967e35d2007-07-18 16:38:11 +0900702
Tejun Heo51225032007-06-14 04:27:25 +0900703 if (!sysfs_find_dirent(parent_sd, name)) {
704 sysfs_add_one(&acxt, sd);
705 sysfs_link_sibling(sd);
706 }
Tejun Heo967e35d2007-07-18 16:38:11 +0900707
708 if (!sysfs_addrm_finish(&acxt)) {
709 sysfs_put(sd);
710 return -EEXIST;
Tejun Heo8312a8d2007-06-14 03:45:17 +0900711 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900712
Tejun Heo967e35d2007-07-18 16:38:11 +0900713 *p_sd = sd;
714 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715}
716
Tejun Heo608e2662007-06-14 04:27:22 +0900717int sysfs_create_subdir(struct kobject *kobj, const char *name,
718 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
Tejun Heo608e2662007-06-14 04:27:22 +0900720 return create_dir(kobj, kobj->sd, name, p_sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721}
722
723/**
724 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 * @kobj: object we're creating directory for.
Tejun Heo608e2662007-06-14 04:27:22 +0900726 * @shadow_parent: parent object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 */
Tejun Heo608e2662007-06-14 04:27:22 +0900728int sysfs_create_dir(struct kobject *kobj,
729 struct sysfs_dirent *shadow_parent_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
Tejun Heo608e2662007-06-14 04:27:22 +0900731 struct sysfs_dirent *parent_sd, *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 int error = 0;
733
734 BUG_ON(!kobj);
735
Tejun Heo608e2662007-06-14 04:27:22 +0900736 if (shadow_parent_sd)
737 parent_sd = shadow_parent_sd;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700738 else if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900739 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 else if (sysfs_mount && sysfs_mount->mnt_sb)
Tejun Heo608e2662007-06-14 04:27:22 +0900741 parent_sd = sysfs_mount->mnt_sb->s_root->d_fsdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 else
743 return -EFAULT;
744
Tejun Heo608e2662007-06-14 04:27:22 +0900745 error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900747 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 return error;
749}
750
Tejun Heo51225032007-06-14 04:27:25 +0900751static int sysfs_count_nlink(struct sysfs_dirent *sd)
752{
753 struct sysfs_dirent *child;
754 int nr = 0;
755
756 for (child = sd->s_children; child; child = child->s_sibling)
757 if (sysfs_type(child) == SYSFS_DIR)
758 nr++;
759 return nr + 2;
760}
761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
763 struct nameidata *nd)
764{
Tejun Heo6cb52142007-07-31 19:15:08 +0900765 struct dentry *ret = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
767 struct sysfs_dirent * sd;
Tejun Heob402d722007-06-14 04:27:21 +0900768 struct bin_attribute *bin_attr;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900769 struct inode *inode;
770 int found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
Tejun Heo6cb52142007-07-31 19:15:08 +0900772 mutex_lock(&sysfs_mutex);
773
Tejun Heo0c73f182007-06-14 03:45:18 +0900774 for (sd = parent_sd->s_children; sd; sd = sd->s_sibling) {
Tejun Heo51225032007-06-14 04:27:25 +0900775 if (sysfs_type(sd) &&
Tejun Heofc9f54b2007-06-14 03:45:17 +0900776 !strcmp(sd->s_name, dentry->d_name.name)) {
777 found = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 break;
779 }
780 }
781
Tejun Heofc9f54b2007-06-14 03:45:17 +0900782 /* no such entry */
783 if (!found)
Tejun Heo6cb52142007-07-31 19:15:08 +0900784 goto out_unlock;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900785
786 /* attach dentry and inode */
Tejun Heo8312a8d2007-06-14 03:45:17 +0900787 inode = sysfs_get_inode(sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900788 if (!inode) {
789 ret = ERR_PTR(-ENOMEM);
790 goto out_unlock;
791 }
Tejun Heo3007e992007-06-14 04:27:23 +0900792
Tejun Heo8312a8d2007-06-14 03:45:17 +0900793 if (inode->i_state & I_NEW) {
794 /* initialize inode according to type */
Tejun Heob402d722007-06-14 04:27:21 +0900795 switch (sysfs_type(sd)) {
Tejun Heo51225032007-06-14 04:27:25 +0900796 case SYSFS_DIR:
797 inode->i_op = &sysfs_dir_inode_operations;
798 inode->i_fop = &sysfs_dir_operations;
799 inode->i_nlink = sysfs_count_nlink(sd);
800 break;
Tejun Heob402d722007-06-14 04:27:21 +0900801 case SYSFS_KOBJ_ATTR:
Tejun Heo8312a8d2007-06-14 03:45:17 +0900802 inode->i_size = PAGE_SIZE;
803 inode->i_fop = &sysfs_file_operations;
Tejun Heob402d722007-06-14 04:27:21 +0900804 break;
805 case SYSFS_KOBJ_BIN_ATTR:
806 bin_attr = sd->s_elem.bin_attr.bin_attr;
Tejun Heo8312a8d2007-06-14 03:45:17 +0900807 inode->i_size = bin_attr->size;
808 inode->i_fop = &bin_fops;
Tejun Heob402d722007-06-14 04:27:21 +0900809 break;
810 case SYSFS_KOBJ_LINK:
Tejun Heo8312a8d2007-06-14 03:45:17 +0900811 inode->i_op = &sysfs_symlink_inode_operations;
Tejun Heob402d722007-06-14 04:27:21 +0900812 break;
813 default:
814 BUG();
815 }
Tejun Heo8312a8d2007-06-14 03:45:17 +0900816 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900817
818 sysfs_instantiate(dentry, inode);
819 sysfs_attach_dentry(sd, dentry);
820
Tejun Heo6cb52142007-07-31 19:15:08 +0900821 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900822 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900823 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824}
825
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800826const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 .lookup = sysfs_lookup,
Maneesh Soni988d1862005-05-31 10:39:14 +0530828 .setattr = sysfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829};
830
Tejun Heo608e2662007-06-14 04:27:22 +0900831static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832{
Tejun Heofb6896d2007-06-14 04:27:24 +0900833 struct sysfs_addrm_cxt acxt;
834
835 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heo0c73f182007-06-14 03:45:18 +0900836 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900837 sysfs_remove_one(&acxt, sd);
838 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839}
840
Tejun Heo608e2662007-06-14 04:27:22 +0900841void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
Tejun Heo608e2662007-06-14 04:27:22 +0900843 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844}
845
846
Tejun Heo608e2662007-06-14 04:27:22 +0900847static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
Tejun Heofb6896d2007-06-14 04:27:24 +0900849 struct sysfs_addrm_cxt acxt;
Tejun Heo0c73f182007-06-14 03:45:18 +0900850 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Tejun Heo608e2662007-06-14 04:27:22 +0900852 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 return;
854
Tejun Heo608e2662007-06-14 04:27:22 +0900855 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900856 sysfs_addrm_start(&acxt, dir_sd);
Tejun Heo608e2662007-06-14 04:27:22 +0900857 pos = &dir_sd->s_children;
Tejun Heo0c73f182007-06-14 03:45:18 +0900858 while (*pos) {
859 struct sysfs_dirent *sd = *pos;
860
Tejun Heo51225032007-06-14 04:27:25 +0900861 if (sysfs_type(sd) && sysfs_type(sd) != SYSFS_DIR) {
Tejun Heo0c73f182007-06-14 03:45:18 +0900862 *pos = sd->s_sibling;
Tejun Heofb6896d2007-06-14 04:27:24 +0900863 sd->s_sibling = NULL;
864 sysfs_remove_one(&acxt, sd);
Tejun Heo0c73f182007-06-14 03:45:18 +0900865 } else
866 pos = &(*pos)->s_sibling;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900868 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900869
Tejun Heo608e2662007-06-14 04:27:22 +0900870 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700871}
872
873/**
874 * sysfs_remove_dir - remove an object's directory.
875 * @kobj: object.
876 *
877 * The only thing special about this is that we remove any files in
878 * the directory before we remove the directory, and we've inlined
879 * what used to be sysfs_rmdir() below, instead of calling separately.
880 */
881
882void sysfs_remove_dir(struct kobject * kobj)
883{
Tejun Heo608e2662007-06-14 04:27:22 +0900884 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900885
Tejun Heo5f995322007-06-14 04:27:23 +0900886 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900887 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900888 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900889
Tejun Heo608e2662007-06-14 04:27:22 +0900890 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891}
892
Tejun Heo608e2662007-06-14 04:27:22 +0900893int sysfs_rename_dir(struct kobject *kobj, struct sysfs_dirent *new_parent_sd,
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700894 const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895{
Tejun Heo608e2662007-06-14 04:27:22 +0900896 struct sysfs_dirent *sd = kobj->sd;
Tejun Heo51225032007-06-14 04:27:25 +0900897 struct dentry *new_parent = NULL;
898 struct dentry *old_dentry = NULL, *new_dentry = NULL;
899 const char *dup_name = NULL;
Tejun Heo996b7372007-06-14 03:45:14 +0900900 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
Tejun Heo51225032007-06-14 04:27:25 +0900902 /* get dentries */
903 old_dentry = sysfs_get_dentry(sd);
904 if (IS_ERR(old_dentry)) {
905 error = PTR_ERR(old_dentry);
906 goto out_dput;
907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
Tejun Heo51225032007-06-14 04:27:25 +0900909 new_parent = sysfs_get_dentry(new_parent_sd);
910 if (IS_ERR(new_parent)) {
911 error = PTR_ERR(new_parent);
912 goto out_dput;
913 }
914
915 /* lock new_parent and get dentry for new name */
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700916 mutex_lock(&new_parent->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700918 new_dentry = lookup_one_len(new_name, new_parent, strlen(new_name));
Tejun Heo996b7372007-06-14 03:45:14 +0900919 if (IS_ERR(new_dentry)) {
920 error = PTR_ERR(new_dentry);
921 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 }
Tejun Heo996b7372007-06-14 03:45:14 +0900923
924 /* By allowing two different directories with the same
925 * d_parent we allow this routine to move between different
926 * shadows of the same directory
927 */
928 error = -EINVAL;
Tejun Heo51225032007-06-14 04:27:25 +0900929 if (old_dentry->d_parent->d_inode != new_parent->d_inode ||
Tejun Heo996b7372007-06-14 03:45:14 +0900930 new_dentry->d_parent->d_inode != new_parent->d_inode ||
Tejun Heo51225032007-06-14 04:27:25 +0900931 old_dentry == new_dentry)
932 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900933
934 error = -EEXIST;
935 if (new_dentry->d_inode)
Tejun Heo51225032007-06-14 04:27:25 +0900936 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900937
Tejun Heo0c096b52007-06-14 03:45:15 +0900938 /* rename kobject and sysfs_dirent */
939 error = -ENOMEM;
940 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
941 if (!new_name)
Tejun Heo996b7372007-06-14 03:45:14 +0900942 goto out_drop;
943
Tejun Heo0c096b52007-06-14 03:45:15 +0900944 error = kobject_set_name(kobj, "%s", new_name);
945 if (error)
Tejun Heo51225032007-06-14 04:27:25 +0900946 goto out_drop;
Tejun Heo0c096b52007-06-14 03:45:15 +0900947
Tejun Heo6cb52142007-07-31 19:15:08 +0900948 mutex_lock(&sysfs_mutex);
949
Tejun Heo51225032007-06-14 04:27:25 +0900950 dup_name = sd->s_name;
Tejun Heo0c096b52007-06-14 03:45:15 +0900951 sd->s_name = new_name;
952
953 /* move under the new parent */
Tejun Heo996b7372007-06-14 03:45:14 +0900954 d_add(new_dentry, NULL);
Tejun Heo608e2662007-06-14 04:27:22 +0900955 d_move(sd->s_dentry, new_dentry);
Tejun Heo996b7372007-06-14 03:45:14 +0900956
Tejun Heo0c73f182007-06-14 03:45:18 +0900957 sysfs_unlink_sibling(sd);
Tejun Heo608e2662007-06-14 04:27:22 +0900958 sysfs_get(new_parent_sd);
Tejun Heo7f7cfff2007-06-14 03:45:17 +0900959 sysfs_put(sd->s_parent);
Tejun Heo608e2662007-06-14 04:27:22 +0900960 sd->s_parent = new_parent_sd;
Tejun Heo0c73f182007-06-14 03:45:18 +0900961 sysfs_link_sibling(sd);
Tejun Heo996b7372007-06-14 03:45:14 +0900962
Tejun Heo3007e992007-06-14 04:27:23 +0900963 mutex_unlock(&sysfs_mutex);
964
Tejun Heo996b7372007-06-14 03:45:14 +0900965 error = 0;
966 goto out_unlock;
967
968 out_drop:
969 d_drop(new_dentry);
Tejun Heo996b7372007-06-14 03:45:14 +0900970 out_unlock:
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700971 mutex_unlock(&new_parent->d_inode->i_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900972 out_dput:
973 kfree(dup_name);
974 dput(new_parent);
975 dput(old_dentry);
976 dput(new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 return error;
978}
979
Tejun Heo51225032007-06-14 04:27:25 +0900980int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100981{
Tejun Heo51225032007-06-14 04:27:25 +0900982 struct sysfs_dirent *sd = kobj->sd;
983 struct sysfs_dirent *new_parent_sd;
984 struct dentry *old_parent, *new_parent = NULL;
985 struct dentry *old_dentry = NULL, *new_dentry = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100986 int error;
987
Tejun Heo51225032007-06-14 04:27:25 +0900988 BUG_ON(!sd->s_parent);
989 new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100990
Tejun Heo51225032007-06-14 04:27:25 +0900991 /* get dentries */
992 old_dentry = sysfs_get_dentry(sd);
993 if (IS_ERR(old_dentry)) {
994 error = PTR_ERR(old_dentry);
995 goto out_dput;
996 }
997 old_parent = sd->s_parent->s_dentry;
998
999 new_parent = sysfs_get_dentry(new_parent_sd);
1000 if (IS_ERR(new_parent)) {
1001 error = PTR_ERR(new_parent);
1002 goto out_dput;
1003 }
1004
1005 if (old_parent->d_inode == new_parent->d_inode) {
1006 error = 0;
1007 goto out_dput; /* nothing to move */
1008 }
Cornelia Huck8a824722006-11-20 17:07:51 +01001009again:
Tejun Heo51225032007-06-14 04:27:25 +09001010 mutex_lock(&old_parent->d_inode->i_mutex);
1011 if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
1012 mutex_unlock(&old_parent->d_inode->i_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +01001013 goto again;
1014 }
1015
Tejun Heo51225032007-06-14 04:27:25 +09001016 new_dentry = lookup_one_len(kobj->name, new_parent, strlen(kobj->name));
Cornelia Huck8a824722006-11-20 17:07:51 +01001017 if (IS_ERR(new_dentry)) {
1018 error = PTR_ERR(new_dentry);
Tejun Heo51225032007-06-14 04:27:25 +09001019 goto out_unlock;
Cornelia Huck8a824722006-11-20 17:07:51 +01001020 } else
1021 error = 0;
1022 d_add(new_dentry, NULL);
Tejun Heo608e2662007-06-14 04:27:22 +09001023 d_move(sd->s_dentry, new_dentry);
Cornelia Huck8a824722006-11-20 17:07:51 +01001024 dput(new_dentry);
1025
1026 /* Remove from old parent's list and insert into new parent's list. */
Tejun Heo3007e992007-06-14 04:27:23 +09001027 mutex_lock(&sysfs_mutex);
1028
Tejun Heo0c73f182007-06-14 03:45:18 +09001029 sysfs_unlink_sibling(sd);
Tejun Heo7f7cfff2007-06-14 03:45:17 +09001030 sysfs_get(new_parent_sd);
1031 sysfs_put(sd->s_parent);
1032 sd->s_parent = new_parent_sd;
Tejun Heo0c73f182007-06-14 03:45:18 +09001033 sysfs_link_sibling(sd);
Cornelia Huck8a824722006-11-20 17:07:51 +01001034
Tejun Heo3007e992007-06-14 04:27:23 +09001035 mutex_unlock(&sysfs_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +01001036
Tejun Heo51225032007-06-14 04:27:25 +09001037 out_unlock:
1038 mutex_unlock(&new_parent->d_inode->i_mutex);
1039 mutex_unlock(&old_parent->d_inode->i_mutex);
1040 out_dput:
1041 dput(new_parent);
1042 dput(old_dentry);
1043 dput(new_dentry);
Cornelia Huck8a824722006-11-20 17:07:51 +01001044 return error;
1045}
1046
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047static int sysfs_dir_open(struct inode *inode, struct file *file)
1048{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001049 struct dentry * dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Tejun Heoa26cd722007-06-14 03:45:14 +09001051 struct sysfs_dirent * sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052
Tejun Heo3e519032007-06-14 03:45:15 +09001053 sd = sysfs_new_dirent("_DIR_", 0, 0);
Tejun Heo3007e992007-06-14 04:27:23 +09001054 if (sd) {
1055 mutex_lock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +09001056 sd->s_parent = sysfs_get(parent_sd);
1057 sysfs_link_sibling(sd);
Tejun Heo3007e992007-06-14 04:27:23 +09001058 mutex_unlock(&sysfs_mutex);
1059 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
Tejun Heoa26cd722007-06-14 03:45:14 +09001061 file->private_data = sd;
1062 return sd ? 0 : -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063}
1064
1065static int sysfs_dir_close(struct inode *inode, struct file *file)
1066{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 struct sysfs_dirent * cursor = file->private_data;
1068
Tejun Heo3007e992007-06-14 04:27:23 +09001069 mutex_lock(&sysfs_mutex);
Tejun Heo0c73f182007-06-14 03:45:18 +09001070 sysfs_unlink_sibling(cursor);
Tejun Heo3007e992007-06-14 04:27:23 +09001071 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
1073 release_sysfs_dirent(cursor);
1074
1075 return 0;
1076}
1077
1078/* Relationship between s_mode and the DT_xxx types */
1079static inline unsigned char dt_type(struct sysfs_dirent *sd)
1080{
1081 return (sd->s_mode >> 12) & 15;
1082}
1083
1084static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
1085{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001086 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
1088 struct sysfs_dirent *cursor = filp->private_data;
Tejun Heo0c73f182007-06-14 03:45:18 +09001089 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 ino_t ino;
1091 int i = filp->f_pos;
1092
1093 switch (i) {
1094 case 0:
Eric Sandeendc351252007-06-11 14:02:45 +09001095 ino = parent_sd->s_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
1097 break;
1098 filp->f_pos++;
1099 i++;
1100 /* fallthrough */
1101 case 1:
Tejun Heo13b30862007-06-14 03:45:14 +09001102 if (parent_sd->s_parent)
1103 ino = parent_sd->s_parent->s_ino;
1104 else
1105 ino = parent_sd->s_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
1107 break;
1108 filp->f_pos++;
1109 i++;
1110 /* fallthrough */
1111 default:
Tejun Heo3007e992007-06-14 04:27:23 +09001112 mutex_lock(&sysfs_mutex);
1113
Tejun Heo0c73f182007-06-14 03:45:18 +09001114 pos = &parent_sd->s_children;
1115 while (*pos != cursor)
1116 pos = &(*pos)->s_sibling;
Akinobu Mita1bfba4e2006-06-26 00:24:40 -07001117
Tejun Heo0c73f182007-06-14 03:45:18 +09001118 /* unlink cursor */
1119 *pos = cursor->s_sibling;
1120
1121 if (filp->f_pos == 2)
1122 pos = &parent_sd->s_children;
1123
1124 for ( ; *pos; pos = &(*pos)->s_sibling) {
1125 struct sysfs_dirent *next = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 const char * name;
1127 int len;
1128
Tejun Heob402d722007-06-14 04:27:21 +09001129 if (!sysfs_type(next))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 continue;
1131
Tejun Heo0c096b52007-06-14 03:45:15 +09001132 name = next->s_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 len = strlen(name);
Eric Sandeendc351252007-06-11 14:02:45 +09001134 ino = next->s_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
1136 if (filldir(dirent, name, len, filp->f_pos, ino,
1137 dt_type(next)) < 0)
Tejun Heo0c73f182007-06-14 03:45:18 +09001138 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 filp->f_pos++;
1141 }
Tejun Heo0c73f182007-06-14 03:45:18 +09001142
1143 /* put cursor back in */
1144 cursor->s_sibling = *pos;
1145 *pos = cursor;
Tejun Heo3007e992007-06-14 04:27:23 +09001146
1147 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 }
1149 return 0;
1150}
1151
1152static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
1153{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001154 struct dentry * dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 switch (origin) {
1157 case 1:
1158 offset += file->f_pos;
1159 case 0:
1160 if (offset >= 0)
1161 break;
1162 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 return -EINVAL;
1164 }
1165 if (offset != file->f_pos) {
Tejun Heo3007e992007-06-14 04:27:23 +09001166 mutex_lock(&sysfs_mutex);
1167
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 file->f_pos = offset;
1169 if (file->f_pos >= 2) {
1170 struct sysfs_dirent *sd = dentry->d_fsdata;
1171 struct sysfs_dirent *cursor = file->private_data;
Tejun Heo0c73f182007-06-14 03:45:18 +09001172 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 loff_t n = file->f_pos - 2;
1174
Tejun Heo0c73f182007-06-14 03:45:18 +09001175 sysfs_unlink_sibling(cursor);
1176
1177 pos = &sd->s_children;
1178 while (n && *pos) {
1179 struct sysfs_dirent *next = *pos;
Tejun Heob402d722007-06-14 04:27:21 +09001180 if (sysfs_type(next))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 n--;
Tejun Heo0c73f182007-06-14 03:45:18 +09001182 pos = &(*pos)->s_sibling;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
Tejun Heo0c73f182007-06-14 03:45:18 +09001184
1185 cursor->s_sibling = *pos;
1186 *pos = cursor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 }
Tejun Heo3007e992007-06-14 04:27:23 +09001188
1189 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 }
Tejun Heo3007e992007-06-14 04:27:23 +09001191
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 return offset;
1193}
1194
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001195
1196/**
1197 * sysfs_make_shadowed_dir - Setup so a directory can be shadowed
1198 * @kobj: object we're creating shadow of.
1199 */
1200
1201int sysfs_make_shadowed_dir(struct kobject *kobj,
1202 void * (*follow_link)(struct dentry *, struct nameidata *))
1203{
Tejun Heo51225032007-06-14 04:27:25 +09001204 struct dentry *dentry;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001205 struct inode *inode;
1206 struct inode_operations *i_op;
1207
Tejun Heo51225032007-06-14 04:27:25 +09001208 /* get dentry for @kobj->sd, dentry of a shadowed dir is pinned */
1209 dentry = sysfs_get_dentry(kobj->sd);
1210 if (IS_ERR(dentry))
1211 return PTR_ERR(dentry);
1212
1213 inode = dentry->d_inode;
1214 if (inode->i_op != &sysfs_dir_inode_operations) {
1215 dput(dentry);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001216 return -EINVAL;
Tejun Heo51225032007-06-14 04:27:25 +09001217 }
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001218
1219 i_op = kmalloc(sizeof(*i_op), GFP_KERNEL);
1220 if (!i_op)
1221 return -ENOMEM;
1222
1223 memcpy(i_op, &sysfs_dir_inode_operations, sizeof(*i_op));
1224 i_op->follow_link = follow_link;
1225
1226 /* Locking of inode->i_op?
1227 * Since setting i_op is a single word write and they
1228 * are atomic we should be ok here.
1229 */
1230 inode->i_op = i_op;
1231 return 0;
1232}
1233
1234/**
1235 * sysfs_create_shadow_dir - create a shadow directory for an object.
1236 * @kobj: object we're creating directory for.
1237 *
1238 * sysfs_make_shadowed_dir must already have been called on this
1239 * directory.
1240 */
1241
Tejun Heo608e2662007-06-14 04:27:22 +09001242struct sysfs_dirent *sysfs_create_shadow_dir(struct kobject *kobj)
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001243{
Tejun Heo51225032007-06-14 04:27:25 +09001244 struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
1245 struct dentry *dir, *parent, *shadow;
1246 struct inode *inode;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001247 struct sysfs_dirent *sd;
Tejun Heofb6896d2007-06-14 04:27:24 +09001248 struct sysfs_addrm_cxt acxt;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001249
Tejun Heo51225032007-06-14 04:27:25 +09001250 dir = sysfs_get_dentry(kobj->sd);
1251 if (IS_ERR(dir)) {
1252 sd = (void *)dir;
1253 goto out;
1254 }
1255 parent = dir->d_parent;
1256
1257 inode = dir->d_inode;
Tejun Heo608e2662007-06-14 04:27:22 +09001258 sd = ERR_PTR(-EINVAL);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001259 if (!sysfs_is_shadowed_inode(inode))
Tejun Heo51225032007-06-14 04:27:25 +09001260 goto out_dput;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001261
1262 shadow = d_alloc(parent, &dir->d_name);
1263 if (!shadow)
1264 goto nomem;
1265
Tejun Heo3e519032007-06-14 03:45:15 +09001266 sd = sysfs_new_dirent("_SHADOW_", inode->i_mode, SYSFS_DIR);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001267 if (!sd)
1268 goto nomem;
Tejun Heo3e519032007-06-14 03:45:15 +09001269 sd->s_elem.dir.kobj = kobj;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001270
Tejun Heofb6896d2007-06-14 04:27:24 +09001271 sysfs_addrm_start(&acxt, parent_sd);
1272
1273 /* add but don't link into children list */
1274 sysfs_add_one(&acxt, sd);
1275
1276 /* attach and instantiate dentry */
1277 sysfs_attach_dentry(sd, shadow);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001278 d_instantiate(shadow, igrab(inode));
Tejun Heofb6896d2007-06-14 04:27:24 +09001279 inc_nlink(inode); /* tj: synchronization? */
1280
1281 sysfs_addrm_finish(&acxt);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001282
1283 dget(shadow); /* Extra count - pin the dentry in core */
1284
Tejun Heo51225032007-06-14 04:27:25 +09001285 goto out_dput;
1286
1287 nomem:
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001288 dput(shadow);
Tejun Heo608e2662007-06-14 04:27:22 +09001289 sd = ERR_PTR(-ENOMEM);
Tejun Heo51225032007-06-14 04:27:25 +09001290 out_dput:
1291 dput(dir);
1292 out:
1293 return sd;
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001294}
1295
1296/**
1297 * sysfs_remove_shadow_dir - remove an object's directory.
Tejun Heo608e2662007-06-14 04:27:22 +09001298 * @shadow_sd: sysfs_dirent of shadow directory
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001299 *
1300 * The only thing special about this is that we remove any files in
1301 * the directory before we remove the directory, and we've inlined
1302 * what used to be sysfs_rmdir() below, instead of calling separately.
1303 */
1304
Tejun Heo608e2662007-06-14 04:27:22 +09001305void sysfs_remove_shadow_dir(struct sysfs_dirent *shadow_sd)
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001306{
Tejun Heo608e2662007-06-14 04:27:22 +09001307 __sysfs_remove_dir(shadow_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -07001308}
1309
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001310const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 .open = sysfs_dir_open,
1312 .release = sysfs_dir_close,
1313 .llseek = sysfs_dir_lseek,
1314 .read = generic_read_dir,
1315 .readdir = sysfs_readdir,
1316};