blob: d88d0fac9fa5f185afd13b1f36b11f58baec672d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Tejun Heo6d66f5c2007-09-20 17:31:38 +09002 * fs/sysfs/dir.c - sysfs core and dir operation implementation
3 *
4 * Copyright (c) 2001-3 Patrick Mochel
5 * Copyright (c) 2007 SUSE Linux Products GmbH
6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7 *
8 * This file is released under the GPLv2.
9 *
10 * Please see Documentation/filesystems/sysfs.txt for more information.
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
13#undef DEBUG
14
15#include <linux/fs.h>
16#include <linux/mount.h>
17#include <linux/module.h>
18#include <linux/kobject.h>
Christoph Hellwig5f45f1a2005-06-23 00:09:12 -070019#include <linux/namei.h>
Tejun Heo2b611bb2007-06-14 03:45:13 +090020#include <linux/idr.h>
Tejun Heo8619f972007-06-14 03:45:18 +090021#include <linux/completion.h>
Dave Young869512a2007-07-26 14:53:53 +000022#include <linux/mutex.h>
Robert P. J. Dayc6f87732008-03-13 22:41:52 -040023#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "sysfs.h"
25
Tejun Heo3007e992007-06-14 04:27:23 +090026DEFINE_MUTEX(sysfs_mutex);
Eric W. Biederman932ea2e2007-08-20 21:36:30 +090027DEFINE_MUTEX(sysfs_rename_mutex);
Roel Kluinf7a75f02007-10-16 23:30:25 -070028DEFINE_SPINLOCK(sysfs_assoc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Roel Kluinf7a75f02007-10-16 23:30:25 -070030static DEFINE_SPINLOCK(sysfs_ino_lock);
Tejun Heo2b611bb2007-06-14 03:45:13 +090031static DEFINE_IDA(sysfs_ino_ida);
32
Tejun Heob6b4a432007-06-14 03:45:18 +090033/**
Tejun Heo0c73f182007-06-14 03:45:18 +090034 * sysfs_link_sibling - link sysfs_dirent into sibling list
35 * @sd: sysfs_dirent of interest
36 *
37 * Link @sd into its sibling list which starts from
Tejun Heobc747f32007-09-20 16:05:12 +090038 * sd->s_parent->s_dir.children.
Tejun Heo0c73f182007-06-14 03:45:18 +090039 *
40 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090041 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +090042 */
Tejun Heo41fc1c22007-08-02 21:38:03 +090043static void sysfs_link_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +090044{
45 struct sysfs_dirent *parent_sd = sd->s_parent;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +090046 struct sysfs_dirent **pos;
Tejun Heo0c73f182007-06-14 03:45:18 +090047
48 BUG_ON(sd->s_sibling);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +090049
50 /* Store directory entries in order by ino. This allows
51 * readdir to properly restart without having to add a
Tejun Heobc747f32007-09-20 16:05:12 +090052 * cursor into the s_dir.children list.
Eric W. Biederman3efa65b2007-08-20 21:36:30 +090053 */
Tejun Heobc747f32007-09-20 16:05:12 +090054 for (pos = &parent_sd->s_dir.children; *pos; pos = &(*pos)->s_sibling) {
Eric W. Biederman3efa65b2007-08-20 21:36:30 +090055 if (sd->s_ino < (*pos)->s_ino)
56 break;
57 }
58 sd->s_sibling = *pos;
59 *pos = sd;
Tejun Heo0c73f182007-06-14 03:45:18 +090060}
61
62/**
63 * sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
64 * @sd: sysfs_dirent of interest
65 *
66 * Unlink @sd from its sibling list which starts from
Tejun Heobc747f32007-09-20 16:05:12 +090067 * sd->s_parent->s_dir.children.
Tejun Heo0c73f182007-06-14 03:45:18 +090068 *
69 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090070 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +090071 */
Tejun Heo41fc1c22007-08-02 21:38:03 +090072static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +090073{
74 struct sysfs_dirent **pos;
75
Tejun Heobc747f32007-09-20 16:05:12 +090076 for (pos = &sd->s_parent->s_dir.children; *pos;
77 pos = &(*pos)->s_sibling) {
Tejun Heo0c73f182007-06-14 03:45:18 +090078 if (*pos == sd) {
79 *pos = sd->s_sibling;
80 sd->s_sibling = NULL;
81 break;
82 }
83 }
84}
85
86/**
Tejun Heo53e0ae92007-06-14 04:27:25 +090087 * sysfs_get_dentry - get dentry for the given sysfs_dirent
88 * @sd: sysfs_dirent of interest
89 *
90 * Get dentry for @sd. Dentry is looked up if currently not
Tejun Heoe0712bb2007-08-20 21:36:30 +090091 * present. This function descends from the root looking up
92 * dentry for each step.
Tejun Heo53e0ae92007-06-14 04:27:25 +090093 *
94 * LOCKING:
Eric W. Biederman932ea2e2007-08-20 21:36:30 +090095 * mutex_lock(sysfs_rename_mutex)
Tejun Heo53e0ae92007-06-14 04:27:25 +090096 *
97 * RETURNS:
98 * Pointer to found dentry on success, ERR_PTR() value on error.
99 */
100struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd)
101{
Tejun Heoe0712bb2007-08-20 21:36:30 +0900102 struct dentry *dentry = dget(sysfs_sb->s_root);
Tejun Heo53e0ae92007-06-14 04:27:25 +0900103
Tejun Heoe0712bb2007-08-20 21:36:30 +0900104 while (dentry->d_fsdata != sd) {
105 struct sysfs_dirent *cur;
106 struct dentry *parent;
Tejun Heo53e0ae92007-06-14 04:27:25 +0900107
Tejun Heoe0712bb2007-08-20 21:36:30 +0900108 /* find the first ancestor which hasn't been looked up */
109 cur = sd;
110 while (cur->s_parent != dentry->d_fsdata)
Tejun Heo53e0ae92007-06-14 04:27:25 +0900111 cur = cur->s_parent;
112
Tejun Heo53e0ae92007-06-14 04:27:25 +0900113 /* look it up */
Tejun Heoe0712bb2007-08-20 21:36:30 +0900114 parent = dentry;
115 mutex_lock(&parent->d_inode->i_mutex);
Christoph Hellwigeead1912007-10-16 23:25:38 -0700116 dentry = lookup_one_noperm(cur->s_name, parent);
Tejun Heoe0712bb2007-08-20 21:36:30 +0900117 mutex_unlock(&parent->d_inode->i_mutex);
118 dput(parent);
Tejun Heo53e0ae92007-06-14 04:27:25 +0900119
Tejun Heoe0712bb2007-08-20 21:36:30 +0900120 if (IS_ERR(dentry))
121 break;
Tejun Heo53e0ae92007-06-14 04:27:25 +0900122 }
Tejun Heo53e0ae92007-06-14 04:27:25 +0900123 return dentry;
124}
125
126/**
Tejun Heob6b4a432007-06-14 03:45:18 +0900127 * sysfs_get_active - get an active reference to sysfs_dirent
128 * @sd: sysfs_dirent to get an active reference to
129 *
130 * Get an active reference of @sd. This function is noop if @sd
131 * is NULL.
132 *
133 * RETURNS:
134 * Pointer to @sd on success, NULL on failure.
135 */
Adrian Bunk78e9d362007-10-24 18:23:32 +0200136static struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900137{
Tejun Heo8619f972007-06-14 03:45:18 +0900138 if (unlikely(!sd))
139 return NULL;
140
141 while (1) {
142 int v, t;
143
144 v = atomic_read(&sd->s_active);
145 if (unlikely(v < 0))
146 return NULL;
147
148 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
149 if (likely(t == v))
150 return sd;
151 if (t < 0)
152 return NULL;
153
154 cpu_relax();
Tejun Heob6b4a432007-06-14 03:45:18 +0900155 }
Tejun Heob6b4a432007-06-14 03:45:18 +0900156}
157
158/**
159 * sysfs_put_active - put an active reference to sysfs_dirent
160 * @sd: sysfs_dirent to put an active reference to
161 *
162 * Put an active reference to @sd. This function is noop if @sd
163 * is NULL.
164 */
Adrian Bunk78e9d362007-10-24 18:23:32 +0200165static void sysfs_put_active(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900166{
Tejun Heo8619f972007-06-14 03:45:18 +0900167 struct completion *cmpl;
168 int v;
169
170 if (unlikely(!sd))
171 return;
172
173 v = atomic_dec_return(&sd->s_active);
174 if (likely(v != SD_DEACTIVATED_BIAS))
175 return;
176
177 /* atomic_dec_return() is a mb(), we'll always see the updated
Tejun Heo0c73f182007-06-14 03:45:18 +0900178 * sd->s_sibling.
Tejun Heo8619f972007-06-14 03:45:18 +0900179 */
Tejun Heo0c73f182007-06-14 03:45:18 +0900180 cmpl = (void *)sd->s_sibling;
Tejun Heo8619f972007-06-14 03:45:18 +0900181 complete(cmpl);
Tejun Heob6b4a432007-06-14 03:45:18 +0900182}
183
184/**
185 * sysfs_get_active_two - get active references to sysfs_dirent and parent
186 * @sd: sysfs_dirent of interest
187 *
188 * Get active reference to @sd and its parent. Parent's active
189 * reference is grabbed first. This function is noop if @sd is
190 * NULL.
191 *
192 * RETURNS:
193 * Pointer to @sd on success, NULL on failure.
194 */
195struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd)
196{
197 if (sd) {
198 if (sd->s_parent && unlikely(!sysfs_get_active(sd->s_parent)))
199 return NULL;
200 if (unlikely(!sysfs_get_active(sd))) {
201 sysfs_put_active(sd->s_parent);
202 return NULL;
203 }
204 }
205 return sd;
206}
207
208/**
209 * sysfs_put_active_two - put active references to sysfs_dirent and parent
210 * @sd: sysfs_dirent of interest
211 *
212 * Put active references to @sd and its parent. This function is
213 * noop if @sd is NULL.
214 */
215void sysfs_put_active_two(struct sysfs_dirent *sd)
216{
217 if (sd) {
218 sysfs_put_active(sd);
219 sysfs_put_active(sd->s_parent);
220 }
221}
222
223/**
224 * sysfs_deactivate - deactivate sysfs_dirent
225 * @sd: sysfs_dirent to deactivate
226 *
Tejun Heo8619f972007-06-14 03:45:18 +0900227 * Deny new active references and drain existing ones.
Tejun Heob6b4a432007-06-14 03:45:18 +0900228 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900229static void sysfs_deactivate(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900230{
Tejun Heo8619f972007-06-14 03:45:18 +0900231 DECLARE_COMPLETION_ONSTACK(wait);
232 int v;
Tejun Heob6b4a432007-06-14 03:45:18 +0900233
Tejun Heo380e6fb2007-06-14 04:27:22 +0900234 BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
Tejun Heo0c73f182007-06-14 03:45:18 +0900235 sd->s_sibling = (void *)&wait;
Tejun Heo8619f972007-06-14 03:45:18 +0900236
237 /* atomic_add_return() is a mb(), put_active() will always see
Tejun Heo0c73f182007-06-14 03:45:18 +0900238 * the updated sd->s_sibling.
Tejun Heob6b4a432007-06-14 03:45:18 +0900239 */
Tejun Heo8619f972007-06-14 03:45:18 +0900240 v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
241
242 if (v != SD_DEACTIVATED_BIAS)
243 wait_for_completion(&wait);
244
Tejun Heo0c73f182007-06-14 03:45:18 +0900245 sd->s_sibling = NULL;
Tejun Heob6b4a432007-06-14 03:45:18 +0900246}
247
Tejun Heo42b37df2007-06-14 03:45:17 +0900248static int sysfs_alloc_ino(ino_t *pino)
Tejun Heo2b611bb2007-06-14 03:45:13 +0900249{
250 int ino, rc;
251
252 retry:
253 spin_lock(&sysfs_ino_lock);
254 rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
255 spin_unlock(&sysfs_ino_lock);
256
257 if (rc == -EAGAIN) {
258 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
259 goto retry;
260 rc = -ENOMEM;
261 }
262
263 *pino = ino;
264 return rc;
265}
266
267static void sysfs_free_ino(ino_t ino)
268{
269 spin_lock(&sysfs_ino_lock);
270 ida_remove(&sysfs_ino_ida, ino);
271 spin_unlock(&sysfs_ino_lock);
272}
273
Tejun Heofa7f9122007-06-14 03:45:13 +0900274void release_sysfs_dirent(struct sysfs_dirent * sd)
275{
Tejun Heo13b30862007-06-14 03:45:14 +0900276 struct sysfs_dirent *parent_sd;
277
278 repeat:
Tejun Heo3007e992007-06-14 04:27:23 +0900279 /* Moving/renaming is always done while holding reference.
280 * sd->s_parent won't change beneath us.
281 */
Tejun Heo13b30862007-06-14 03:45:14 +0900282 parent_sd = sd->s_parent;
283
Tejun Heob402d722007-06-14 04:27:21 +0900284 if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
Tejun Heob1fc3d62007-09-20 16:05:11 +0900285 sysfs_put(sd->s_symlink.target_sd);
Tejun Heob402d722007-06-14 04:27:21 +0900286 if (sysfs_type(sd) & SYSFS_COPY_NAME)
Tejun Heo0c096b52007-06-14 03:45:15 +0900287 kfree(sd->s_name);
Tejun Heofa7f9122007-06-14 03:45:13 +0900288 kfree(sd->s_iattr);
Tejun Heo2b611bb2007-06-14 03:45:13 +0900289 sysfs_free_ino(sd->s_ino);
Tejun Heofa7f9122007-06-14 03:45:13 +0900290 kmem_cache_free(sysfs_dir_cachep, sd);
Tejun Heo13b30862007-06-14 03:45:14 +0900291
292 sd = parent_sd;
293 if (sd && atomic_dec_and_test(&sd->s_count))
294 goto repeat;
Tejun Heofa7f9122007-06-14 03:45:13 +0900295}
296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
298{
299 struct sysfs_dirent * sd = dentry->d_fsdata;
300
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900301 sysfs_put(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 iput(inode);
303}
304
Al Viroee1ec322009-02-20 06:01:46 +0000305static const struct dentry_operations sysfs_dentry_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 .d_iput = sysfs_d_iput,
307};
308
Tejun Heo3e519032007-06-14 03:45:15 +0900309struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
Tejun Heo0c096b52007-06-14 03:45:15 +0900311 char *dup_name = NULL;
Akinobu Mita01da2422007-07-14 11:03:35 +0900312 struct sysfs_dirent *sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900313
314 if (type & SYSFS_COPY_NAME) {
315 name = dup_name = kstrdup(name, GFP_KERNEL);
316 if (!name)
Akinobu Mita01da2422007-07-14 11:03:35 +0900317 return NULL;
Tejun Heo0c096b52007-06-14 03:45:15 +0900318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800320 sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 if (!sd)
Akinobu Mita01da2422007-07-14 11:03:35 +0900322 goto err_out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Tejun Heo0c096b52007-06-14 03:45:15 +0900324 if (sysfs_alloc_ino(&sd->s_ino))
Akinobu Mita01da2422007-07-14 11:03:35 +0900325 goto err_out2;
Tejun Heo2b611bb2007-06-14 03:45:13 +0900326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 atomic_set(&sd->s_count, 1);
Tejun Heo8619f972007-06-14 03:45:18 +0900328 atomic_set(&sd->s_active, 0);
Tejun Heoa26cd722007-06-14 03:45:14 +0900329
Tejun Heo0c096b52007-06-14 03:45:15 +0900330 sd->s_name = name;
Tejun Heoa26cd722007-06-14 03:45:14 +0900331 sd->s_mode = mode;
Tejun Heob402d722007-06-14 04:27:21 +0900332 sd->s_flags = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 return sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900335
Akinobu Mita01da2422007-07-14 11:03:35 +0900336 err_out2:
Tejun Heo0c096b52007-06-14 03:45:15 +0900337 kmem_cache_free(sysfs_dir_cachep, sd);
Akinobu Mita01da2422007-07-14 11:03:35 +0900338 err_out1:
339 kfree(dup_name);
Tejun Heo0c096b52007-06-14 03:45:15 +0900340 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341}
342
Tejun Heofb6896d2007-06-14 04:27:24 +0900343static int sysfs_ilookup_test(struct inode *inode, void *arg)
344{
345 struct sysfs_dirent *sd = arg;
346 return inode->i_ino == sd->s_ino;
347}
348
Tejun Heo3007e992007-06-14 04:27:23 +0900349/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900350 * sysfs_addrm_start - prepare for sysfs_dirent add/remove
351 * @acxt: pointer to sysfs_addrm_cxt to be used
352 * @parent_sd: parent sysfs_dirent
Tejun Heo3007e992007-06-14 04:27:23 +0900353 *
Tejun Heofb6896d2007-06-14 04:27:24 +0900354 * This function is called when the caller is about to add or
355 * remove sysfs_dirent under @parent_sd. This function acquires
356 * sysfs_mutex, grabs inode for @parent_sd if available and lock
357 * i_mutex of it. @acxt is used to keep and pass context to
358 * other addrm functions.
Tejun Heo3007e992007-06-14 04:27:23 +0900359 *
360 * LOCKING:
Tejun Heofb6896d2007-06-14 04:27:24 +0900361 * Kernel thread context (may sleep). sysfs_mutex is locked on
362 * return. i_mutex of parent inode is locked on return if
363 * available.
Tejun Heo3007e992007-06-14 04:27:23 +0900364 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900365void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
366 struct sysfs_dirent *parent_sd)
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700367{
Tejun Heofb6896d2007-06-14 04:27:24 +0900368 struct inode *inode;
Tejun Heoa26cd722007-06-14 03:45:14 +0900369
Tejun Heofb6896d2007-06-14 04:27:24 +0900370 memset(acxt, 0, sizeof(*acxt));
371 acxt->parent_sd = parent_sd;
372
Tejun Heo45c076c2008-09-28 07:48:08 +0900373 /* Lookup parent inode. inode initialization is protected by
374 * sysfs_mutex, so inode existence can be determined by
375 * looking up inode while holding sysfs_mutex.
Tejun Heofb6896d2007-06-14 04:27:24 +0900376 */
377 mutex_lock(&sysfs_mutex);
378
Tejun Heo45c076c2008-09-28 07:48:08 +0900379 inode = ilookup5(sysfs_sb, parent_sd->s_ino, sysfs_ilookup_test,
380 parent_sd);
381 if (inode) {
382 WARN_ON(inode->i_state & I_NEW);
Tejun Heofb6896d2007-06-14 04:27:24 +0900383
Tejun Heofb6896d2007-06-14 04:27:24 +0900384 /* parent inode available */
385 acxt->parent_inode = inode;
386
387 /* sysfs_mutex is below i_mutex in lock hierarchy.
388 * First, trylock i_mutex. If fails, unlock
389 * sysfs_mutex and lock them in order.
390 */
391 if (!mutex_trylock(&inode->i_mutex)) {
392 mutex_unlock(&sysfs_mutex);
393 mutex_lock(&inode->i_mutex);
394 mutex_lock(&sysfs_mutex);
395 }
Tejun Heo45c076c2008-09-28 07:48:08 +0900396 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900397}
398
399/**
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200400 * __sysfs_add_one - add sysfs_dirent to parent without warning
401 * @acxt: addrm context to use
402 * @sd: sysfs_dirent to be added
403 *
404 * Get @acxt->parent_sd and set sd->s_parent to it and increment
405 * nlink of parent inode if @sd is a directory and link into the
406 * children list of the parent.
407 *
408 * This function should be called between calls to
409 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
410 * passed the same @acxt as passed to sysfs_addrm_start().
411 *
412 * LOCKING:
413 * Determined by sysfs_addrm_start().
414 *
415 * RETURNS:
416 * 0 on success, -EEXIST if entry with the given name already
417 * exists.
418 */
419int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
420{
421 if (sysfs_find_dirent(acxt->parent_sd, sd->s_name))
422 return -EEXIST;
423
424 sd->s_parent = sysfs_get(acxt->parent_sd);
425
426 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
427 inc_nlink(acxt->parent_inode);
428
429 acxt->cnt++;
430
431 sysfs_link_sibling(sd);
432
433 return 0;
434}
435
436/**
Alex Chiang425cb022009-02-12 10:56:59 -0700437 * sysfs_pathname - return full path to sysfs dirent
438 * @sd: sysfs_dirent whose path we want
439 * @path: caller allocated buffer
440 *
441 * Gives the name "/" to the sysfs_root entry; any path returned
442 * is relative to wherever sysfs is mounted.
443 *
444 * XXX: does no error checking on @path size
445 */
446static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
447{
448 if (sd->s_parent) {
449 sysfs_pathname(sd->s_parent, path);
450 strcat(path, "/");
451 }
452 strcat(path, sd->s_name);
453 return path;
454}
455
456/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900457 * sysfs_add_one - add sysfs_dirent to parent
458 * @acxt: addrm context to use
459 * @sd: sysfs_dirent to be added
460 *
461 * Get @acxt->parent_sd and set sd->s_parent to it and increment
Tejun Heo181b2e42007-09-20 16:05:09 +0900462 * nlink of parent inode if @sd is a directory and link into the
463 * children list of the parent.
Tejun Heofb6896d2007-06-14 04:27:24 +0900464 *
465 * This function should be called between calls to
466 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
467 * passed the same @acxt as passed to sysfs_addrm_start().
468 *
469 * LOCKING:
470 * Determined by sysfs_addrm_start().
Tejun Heo23dc2792007-08-02 21:38:03 +0900471 *
472 * RETURNS:
473 * 0 on success, -EEXIST if entry with the given name already
474 * exists.
Tejun Heofb6896d2007-06-14 04:27:24 +0900475 */
Tejun Heo23dc2792007-08-02 21:38:03 +0900476int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
Tejun Heofb6896d2007-06-14 04:27:24 +0900477{
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200478 int ret;
Tejun Heo23dc2792007-08-02 21:38:03 +0900479
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200480 ret = __sysfs_add_one(acxt, sd);
Alex Chiang425cb022009-02-12 10:56:59 -0700481 if (ret == -EEXIST) {
482 char *path = kzalloc(PATH_MAX, GFP_KERNEL);
483 WARN(1, KERN_WARNING
484 "sysfs: cannot create duplicate filename '%s'\n",
485 (path == NULL) ? sd->s_name :
486 strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
487 sd->s_name));
488 kfree(path);
489 }
490
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200491 return ret;
Tejun Heofb6896d2007-06-14 04:27:24 +0900492}
493
494/**
495 * sysfs_remove_one - remove sysfs_dirent from parent
496 * @acxt: addrm context to use
Jean Delvare9fd5b1c2008-01-08 18:11:24 +0100497 * @sd: sysfs_dirent to be removed
Tejun Heofb6896d2007-06-14 04:27:24 +0900498 *
499 * Mark @sd removed and drop nlink of parent inode if @sd is a
Tejun Heo181b2e42007-09-20 16:05:09 +0900500 * directory. @sd is unlinked from the children list.
Tejun Heofb6896d2007-06-14 04:27:24 +0900501 *
502 * This function should be called between calls to
503 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
504 * passed the same @acxt as passed to sysfs_addrm_start().
505 *
506 * LOCKING:
507 * Determined by sysfs_addrm_start().
508 */
509void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
510{
Tejun Heo41fc1c22007-08-02 21:38:03 +0900511 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
512
513 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900514
515 sd->s_flags |= SYSFS_FLAG_REMOVED;
516 sd->s_sibling = acxt->removed;
517 acxt->removed = sd;
518
519 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
520 drop_nlink(acxt->parent_inode);
521
522 acxt->cnt++;
523}
524
525/**
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900526 * sysfs_drop_dentry - drop dentry for the specified sysfs_dirent
527 * @sd: target sysfs_dirent
528 *
529 * Drop dentry for @sd. @sd must have been unlinked from its
530 * parent on entry to this function such that it can't be looked
531 * up anymore.
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900532 */
533static void sysfs_drop_dentry(struct sysfs_dirent *sd)
534{
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900535 struct inode *inode;
Eric W. Biederman89bec092007-08-20 21:36:30 +0900536 struct dentry *dentry;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900537
Eric W. Biederman89bec092007-08-20 21:36:30 +0900538 inode = ilookup(sysfs_sb, sd->s_ino);
539 if (!inode)
540 return;
541
542 /* Drop any existing dentries associated with sd.
543 *
544 * For the dentry to be properly freed we need to grab a
545 * reference to the dentry under the dcache lock, unhash it,
546 * and then put it. The playing with the dentry count allows
547 * dput to immediately free the dentry if it is not in use.
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900548 */
Eric W. Biederman89bec092007-08-20 21:36:30 +0900549repeat:
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900550 spin_lock(&dcache_lock);
Eric W. Biederman89bec092007-08-20 21:36:30 +0900551 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
552 if (d_unhashed(dentry))
553 continue;
554 dget_locked(dentry);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900555 spin_lock(&dentry->d_lock);
556 __d_drop(dentry);
557 spin_unlock(&dentry->d_lock);
Eric W. Biederman89bec092007-08-20 21:36:30 +0900558 spin_unlock(&dcache_lock);
559 dput(dentry);
560 goto repeat;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900561 }
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900562 spin_unlock(&dcache_lock);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900563
564 /* adjust nlink and update timestamp */
Eric W. Biederman89bec092007-08-20 21:36:30 +0900565 mutex_lock(&inode->i_mutex);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900566
Eric W. Biederman89bec092007-08-20 21:36:30 +0900567 inode->i_ctime = CURRENT_TIME;
568 drop_nlink(inode);
569 if (sysfs_type(sd) == SYSFS_DIR)
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900570 drop_nlink(inode);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900571
Eric W. Biederman89bec092007-08-20 21:36:30 +0900572 mutex_unlock(&inode->i_mutex);
573
574 iput(inode);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900575}
576
577/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900578 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
579 * @acxt: addrm context to finish up
580 *
581 * Finish up sysfs_dirent add/remove. Resources acquired by
582 * sysfs_addrm_start() are released and removed sysfs_dirents are
583 * cleaned up. Timestamps on the parent inode are updated.
584 *
585 * LOCKING:
586 * All mutexes acquired by sysfs_addrm_start() are released.
Tejun Heofb6896d2007-06-14 04:27:24 +0900587 */
Tejun Heo990e53f2007-08-02 21:38:03 +0900588void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
Tejun Heofb6896d2007-06-14 04:27:24 +0900589{
590 /* release resources acquired by sysfs_addrm_start() */
591 mutex_unlock(&sysfs_mutex);
592 if (acxt->parent_inode) {
593 struct inode *inode = acxt->parent_inode;
594
595 /* if added/removed, update timestamps on the parent */
596 if (acxt->cnt)
597 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
598
599 mutex_unlock(&inode->i_mutex);
600 iput(inode);
Tejun Heo13b30862007-06-14 03:45:14 +0900601 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900602
603 /* kill removed sysfs_dirents */
604 while (acxt->removed) {
605 struct sysfs_dirent *sd = acxt->removed;
606
607 acxt->removed = sd->s_sibling;
608 sd->s_sibling = NULL;
609
610 sysfs_drop_dentry(sd);
611 sysfs_deactivate(sd);
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800612 unmap_bin_file(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900613 sysfs_put(sd);
614 }
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700615}
616
Tejun Heof0b0af42007-06-14 04:27:22 +0900617/**
618 * sysfs_find_dirent - find sysfs_dirent with the given name
619 * @parent_sd: sysfs_dirent to search under
620 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530621 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900622 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530623 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900624 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900625 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900626 *
627 * RETURNS:
628 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530629 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900630struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
631 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530632{
Tejun Heof0b0af42007-06-14 04:27:22 +0900633 struct sysfs_dirent *sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530634
Tejun Heobc747f32007-09-20 16:05:12 +0900635 for (sd = parent_sd->s_dir.children; sd; sd = sd->s_sibling)
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900636 if (!strcmp(sd->s_name, name))
Tejun Heof0b0af42007-06-14 04:27:22 +0900637 return sd;
638 return NULL;
639}
Maneesh Sonic5168652006-03-09 19:40:14 +0530640
Tejun Heof0b0af42007-06-14 04:27:22 +0900641/**
642 * sysfs_get_dirent - find and get sysfs_dirent with the given name
643 * @parent_sd: sysfs_dirent to search under
644 * @name: name to look for
645 *
646 * Look for sysfs_dirent with name @name under @parent_sd and get
647 * it if found.
648 *
649 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900650 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900651 *
652 * RETURNS:
653 * Pointer to sysfs_dirent if found, NULL if not.
654 */
655struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
656 const unsigned char *name)
657{
658 struct sysfs_dirent *sd;
659
Tejun Heo3007e992007-06-14 04:27:23 +0900660 mutex_lock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900661 sd = sysfs_find_dirent(parent_sd, name);
662 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900663 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900664
665 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530666}
Neil Brownf1282c82008-07-16 08:58:04 +1000667EXPORT_SYMBOL_GPL(sysfs_get_dirent);
Maneesh Sonic5168652006-03-09 19:40:14 +0530668
Tejun Heo608e2662007-06-14 04:27:22 +0900669static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
670 const char *name, struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900673 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900674 struct sysfs_dirent *sd;
Tejun Heo23dc2792007-08-02 21:38:03 +0900675 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Tejun Heofc9f54b2007-06-14 03:45:17 +0900677 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900678 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900679 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900680 return -ENOMEM;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900681 sd->s_dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900682
Tejun Heo51225032007-06-14 04:27:25 +0900683 /* link in */
684 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo23dc2792007-08-02 21:38:03 +0900685 rc = sysfs_add_one(&acxt, sd);
686 sysfs_addrm_finish(&acxt);
Tejun Heo967e35d2007-07-18 16:38:11 +0900687
Tejun Heo23dc2792007-08-02 21:38:03 +0900688 if (rc == 0)
689 *p_sd = sd;
690 else
Tejun Heo967e35d2007-07-18 16:38:11 +0900691 sysfs_put(sd);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900692
Tejun Heo23dc2792007-08-02 21:38:03 +0900693 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
695
Tejun Heo608e2662007-06-14 04:27:22 +0900696int sysfs_create_subdir(struct kobject *kobj, const char *name,
697 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698{
Tejun Heo608e2662007-06-14 04:27:22 +0900699 return create_dir(kobj, kobj->sd, name, p_sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
702/**
703 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 * @kobj: object we're creating directory for.
705 */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900706int sysfs_create_dir(struct kobject * kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
Tejun Heo608e2662007-06-14 04:27:22 +0900708 struct sysfs_dirent *parent_sd, *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 int error = 0;
710
711 BUG_ON(!kobj);
712
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900713 if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900714 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 else
Eric W. Biederman7d0c7d62007-08-20 21:36:30 +0900716 parent_sd = &sysfs_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Tejun Heo608e2662007-06-14 04:27:22 +0900718 error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900720 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 return error;
722}
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
725 struct nameidata *nd)
726{
Tejun Heo6cb52142007-07-31 19:15:08 +0900727 struct dentry *ret = NULL;
Tejun Heoa7a04752007-08-02 21:38:02 +0900728 struct sysfs_dirent *parent_sd = dentry->d_parent->d_fsdata;
729 struct sysfs_dirent *sd;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900730 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Tejun Heo6cb52142007-07-31 19:15:08 +0900732 mutex_lock(&sysfs_mutex);
733
Eric W. Biederman94777e02007-08-20 21:36:30 +0900734 sd = sysfs_find_dirent(parent_sd, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Tejun Heofc9f54b2007-06-14 03:45:17 +0900736 /* no such entry */
Tejun Heoe49452c2008-01-16 12:06:14 +0900737 if (!sd) {
738 ret = ERR_PTR(-ENOENT);
Tejun Heo6cb52142007-07-31 19:15:08 +0900739 goto out_unlock;
Tejun Heoe49452c2008-01-16 12:06:14 +0900740 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900741
742 /* attach dentry and inode */
Tejun Heo8312a8d2007-06-14 03:45:17 +0900743 inode = sysfs_get_inode(sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900744 if (!inode) {
745 ret = ERR_PTR(-ENOMEM);
746 goto out_unlock;
747 }
Tejun Heo3007e992007-06-14 04:27:23 +0900748
Tejun Heod6b4fd22007-09-20 16:05:11 +0900749 /* instantiate and hash dentry */
750 dentry->d_op = &sysfs_dentry_ops;
751 dentry->d_fsdata = sysfs_get(sd);
Eric W. Biederman119dd522007-08-20 21:36:29 +0900752 d_instantiate(dentry, inode);
Tejun Heod6b4fd22007-09-20 16:05:11 +0900753 d_rehash(dentry);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900754
Tejun Heo6cb52142007-07-31 19:15:08 +0900755 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900756 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900757 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758}
759
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800760const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 .lookup = sysfs_lookup,
Maneesh Soni988d1862005-05-31 10:39:14 +0530762 .setattr = sysfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763};
764
Tejun Heo608e2662007-06-14 04:27:22 +0900765static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766{
Tejun Heofb6896d2007-06-14 04:27:24 +0900767 struct sysfs_addrm_cxt acxt;
768
769 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heofb6896d2007-06-14 04:27:24 +0900770 sysfs_remove_one(&acxt, sd);
771 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772}
773
Tejun Heo608e2662007-06-14 04:27:22 +0900774void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775{
Tejun Heo608e2662007-06-14 04:27:22 +0900776 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777}
778
779
Tejun Heo608e2662007-06-14 04:27:22 +0900780static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781{
Tejun Heofb6896d2007-06-14 04:27:24 +0900782 struct sysfs_addrm_cxt acxt;
Tejun Heo0c73f182007-06-14 03:45:18 +0900783 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Tejun Heo608e2662007-06-14 04:27:22 +0900785 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 return;
787
Tejun Heo608e2662007-06-14 04:27:22 +0900788 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900789 sysfs_addrm_start(&acxt, dir_sd);
Tejun Heobc747f32007-09-20 16:05:12 +0900790 pos = &dir_sd->s_dir.children;
Tejun Heo0c73f182007-06-14 03:45:18 +0900791 while (*pos) {
792 struct sysfs_dirent *sd = *pos;
793
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900794 if (sysfs_type(sd) != SYSFS_DIR)
Tejun Heofb6896d2007-06-14 04:27:24 +0900795 sysfs_remove_one(&acxt, sd);
Tejun Heo41fc1c22007-08-02 21:38:03 +0900796 else
Tejun Heo0c73f182007-06-14 03:45:18 +0900797 pos = &(*pos)->s_sibling;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900799 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900800
Tejun Heo608e2662007-06-14 04:27:22 +0900801 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700802}
803
804/**
805 * sysfs_remove_dir - remove an object's directory.
806 * @kobj: object.
807 *
808 * The only thing special about this is that we remove any files in
809 * the directory before we remove the directory, and we've inlined
810 * what used to be sysfs_rmdir() below, instead of calling separately.
811 */
812
813void sysfs_remove_dir(struct kobject * kobj)
814{
Tejun Heo608e2662007-06-14 04:27:22 +0900815 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900816
Tejun Heo5f995322007-06-14 04:27:23 +0900817 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900818 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900819 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900820
Tejun Heo608e2662007-06-14 04:27:22 +0900821 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822}
823
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900824int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825{
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900826 struct sysfs_dirent *sd = kobj->sd;
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900827 struct dentry *parent = NULL;
Tejun Heo51225032007-06-14 04:27:25 +0900828 struct dentry *old_dentry = NULL, *new_dentry = NULL;
829 const char *dup_name = NULL;
Tejun Heo996b7372007-06-14 03:45:14 +0900830 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900832 mutex_lock(&sysfs_rename_mutex);
833
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900834 error = 0;
835 if (strcmp(sd->s_name, new_name) == 0)
836 goto out; /* nothing to rename */
837
Tejun Heoff869de2007-08-02 21:38:02 +0900838 /* get the original dentry */
Tejun Heo51225032007-06-14 04:27:25 +0900839 old_dentry = sysfs_get_dentry(sd);
840 if (IS_ERR(old_dentry)) {
841 error = PTR_ERR(old_dentry);
Tejun Heo456ef152008-01-16 12:10:53 +0900842 old_dentry = NULL;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900843 goto out;
Tejun Heo51225032007-06-14 04:27:25 +0900844 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Tejun Heoff869de2007-08-02 21:38:02 +0900846 parent = old_dentry->d_parent;
Tejun Heo51225032007-06-14 04:27:25 +0900847
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900848 /* lock parent and get dentry for new name */
849 mutex_lock(&parent->d_inode->i_mutex);
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900850 mutex_lock(&sysfs_mutex);
Tejun Heo996b7372007-06-14 03:45:14 +0900851
852 error = -EEXIST;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900853 if (sysfs_find_dirent(sd->s_parent, new_name))
854 goto out_unlock;
855
856 error = -ENOMEM;
857 new_dentry = d_alloc_name(parent, new_name);
858 if (!new_dentry)
Tejun Heo51225032007-06-14 04:27:25 +0900859 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900860
Eric W. Biederman0b4a4fe2008-07-03 18:05:28 -0700861 /* rename sysfs_dirent */
Tejun Heo0c096b52007-06-14 03:45:15 +0900862 error = -ENOMEM;
863 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
864 if (!new_name)
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900865 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900866
Tejun Heo51225032007-06-14 04:27:25 +0900867 dup_name = sd->s_name;
Tejun Heo0c096b52007-06-14 03:45:15 +0900868 sd->s_name = new_name;
869
Tejun Heoff869de2007-08-02 21:38:02 +0900870 /* rename */
Tejun Heo996b7372007-06-14 03:45:14 +0900871 d_add(new_dentry, NULL);
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900872 d_move(old_dentry, new_dentry);
Tejun Heo996b7372007-06-14 03:45:14 +0900873
Tejun Heo996b7372007-06-14 03:45:14 +0900874 error = 0;
Tejun Heo996b7372007-06-14 03:45:14 +0900875 out_unlock:
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900876 mutex_unlock(&sysfs_mutex);
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900877 mutex_unlock(&parent->d_inode->i_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900878 kfree(dup_name);
Tejun Heo51225032007-06-14 04:27:25 +0900879 dput(old_dentry);
880 dput(new_dentry);
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900881 out:
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900882 mutex_unlock(&sysfs_rename_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 return error;
884}
885
Tejun Heo51225032007-06-14 04:27:25 +0900886int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100887{
Tejun Heo51225032007-06-14 04:27:25 +0900888 struct sysfs_dirent *sd = kobj->sd;
889 struct sysfs_dirent *new_parent_sd;
890 struct dentry *old_parent, *new_parent = NULL;
891 struct dentry *old_dentry = NULL, *new_dentry = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100892 int error;
893
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900894 mutex_lock(&sysfs_rename_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900895 BUG_ON(!sd->s_parent);
896 new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100897
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900898 error = 0;
899 if (sd->s_parent == new_parent_sd)
900 goto out; /* nothing to move */
901
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);
Tejun Heo456ef152008-01-16 12:10:53 +0900906 old_dentry = NULL;
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900907 goto out;
Tejun Heo51225032007-06-14 04:27:25 +0900908 }
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900909 old_parent = old_dentry->d_parent;
Tejun Heo51225032007-06-14 04:27:25 +0900910
911 new_parent = sysfs_get_dentry(new_parent_sd);
912 if (IS_ERR(new_parent)) {
913 error = PTR_ERR(new_parent);
Tejun Heo456ef152008-01-16 12:10:53 +0900914 new_parent = NULL;
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900915 goto out;
Tejun Heo51225032007-06-14 04:27:25 +0900916 }
917
Cornelia Huck8a824722006-11-20 17:07:51 +0100918again:
Tejun Heo51225032007-06-14 04:27:25 +0900919 mutex_lock(&old_parent->d_inode->i_mutex);
920 if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
921 mutex_unlock(&old_parent->d_inode->i_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100922 goto again;
923 }
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900924 mutex_lock(&sysfs_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100925
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900926 error = -EEXIST;
927 if (sysfs_find_dirent(new_parent_sd, sd->s_name))
Tejun Heo51225032007-06-14 04:27:25 +0900928 goto out_unlock;
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900929
930 error = -ENOMEM;
931 new_dentry = d_alloc_name(new_parent, sd->s_name);
932 if (!new_dentry)
933 goto out_unlock;
934
935 error = 0;
Cornelia Huck8a824722006-11-20 17:07:51 +0100936 d_add(new_dentry, NULL);
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900937 d_move(old_dentry, new_dentry);
Cornelia Huck8a824722006-11-20 17:07:51 +0100938
939 /* Remove from old parent's list and insert into new parent's list. */
Tejun Heo0c73f182007-06-14 03:45:18 +0900940 sysfs_unlink_sibling(sd);
Tejun Heo7f7cfff2007-06-14 03:45:17 +0900941 sysfs_get(new_parent_sd);
942 sysfs_put(sd->s_parent);
943 sd->s_parent = new_parent_sd;
Tejun Heo0c73f182007-06-14 03:45:18 +0900944 sysfs_link_sibling(sd);
Cornelia Huck8a824722006-11-20 17:07:51 +0100945
Tejun Heo51225032007-06-14 04:27:25 +0900946 out_unlock:
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900947 mutex_unlock(&sysfs_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900948 mutex_unlock(&new_parent->d_inode->i_mutex);
949 mutex_unlock(&old_parent->d_inode->i_mutex);
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900950 out:
Tejun Heo51225032007-06-14 04:27:25 +0900951 dput(new_parent);
952 dput(old_dentry);
953 dput(new_dentry);
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900954 mutex_unlock(&sysfs_rename_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100955 return error;
956}
957
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958/* Relationship between s_mode and the DT_xxx types */
959static inline unsigned char dt_type(struct sysfs_dirent *sd)
960{
961 return (sd->s_mode >> 12) & 15;
962}
963
964static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
965{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -0800966 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900968 struct sysfs_dirent *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 ino_t ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900971 if (filp->f_pos == 0) {
972 ino = parent_sd->s_ino;
973 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
974 filp->f_pos++;
975 }
976 if (filp->f_pos == 1) {
977 if (parent_sd->s_parent)
978 ino = parent_sd->s_parent->s_ino;
979 else
Eric Sandeendc351252007-06-11 14:02:45 +0900980 ino = parent_sd->s_ino;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900981 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 filp->f_pos++;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900983 }
984 if ((filp->f_pos > 1) && (filp->f_pos < INT_MAX)) {
985 mutex_lock(&sysfs_mutex);
986
987 /* Skip the dentries we have already reported */
Tejun Heobc747f32007-09-20 16:05:12 +0900988 pos = parent_sd->s_dir.children;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900989 while (pos && (filp->f_pos > pos->s_ino))
990 pos = pos->s_sibling;
991
992 for ( ; pos; pos = pos->s_sibling) {
993 const char * name;
994 int len;
995
996 name = pos->s_name;
997 len = strlen(name);
998 filp->f_pos = ino = pos->s_ino;
999
1000 if (filldir(dirent, name, len, filp->f_pos, ino,
1001 dt_type(pos)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 break;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001003 }
1004 if (!pos)
1005 filp->f_pos = INT_MAX;
1006 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 }
1008 return 0;
1009}
1010
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001012const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 .read = generic_read_dir,
1014 .readdir = sysfs_readdir,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +02001015 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016};