blob: 3a05a596e3b4de91dcb522401441b8dc8d959aa9 [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
305static struct dentry_operations sysfs_dentry_ops = {
306 .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/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900437 * sysfs_add_one - add sysfs_dirent to parent
438 * @acxt: addrm context to use
439 * @sd: sysfs_dirent to be added
440 *
441 * Get @acxt->parent_sd and set sd->s_parent to it and increment
Tejun Heo181b2e42007-09-20 16:05:09 +0900442 * nlink of parent inode if @sd is a directory and link into the
443 * children list of the parent.
Tejun Heofb6896d2007-06-14 04:27:24 +0900444 *
445 * This function should be called between calls to
446 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
447 * passed the same @acxt as passed to sysfs_addrm_start().
448 *
449 * LOCKING:
450 * Determined by sysfs_addrm_start().
Tejun Heo23dc2792007-08-02 21:38:03 +0900451 *
452 * RETURNS:
453 * 0 on success, -EEXIST if entry with the given name already
454 * exists.
Tejun Heofb6896d2007-06-14 04:27:24 +0900455 */
Tejun Heo23dc2792007-08-02 21:38:03 +0900456int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
Tejun Heofb6896d2007-06-14 04:27:24 +0900457{
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200458 int ret;
Tejun Heo23dc2792007-08-02 21:38:03 +0900459
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200460 ret = __sysfs_add_one(acxt, sd);
Arjan van de Ven99fcd772008-07-25 19:45:41 -0700461 WARN(ret == -EEXIST, KERN_WARNING "sysfs: duplicate filename '%s' "
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200462 "can not be created\n", sd->s_name);
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200463 return ret;
Tejun Heofb6896d2007-06-14 04:27:24 +0900464}
465
466/**
467 * sysfs_remove_one - remove sysfs_dirent from parent
468 * @acxt: addrm context to use
Jean Delvare9fd5b1c2008-01-08 18:11:24 +0100469 * @sd: sysfs_dirent to be removed
Tejun Heofb6896d2007-06-14 04:27:24 +0900470 *
471 * Mark @sd removed and drop nlink of parent inode if @sd is a
Tejun Heo181b2e42007-09-20 16:05:09 +0900472 * directory. @sd is unlinked from the children list.
Tejun Heofb6896d2007-06-14 04:27:24 +0900473 *
474 * This function should be called between calls to
475 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
476 * passed the same @acxt as passed to sysfs_addrm_start().
477 *
478 * LOCKING:
479 * Determined by sysfs_addrm_start().
480 */
481void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
482{
Tejun Heo41fc1c22007-08-02 21:38:03 +0900483 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
484
485 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900486
487 sd->s_flags |= SYSFS_FLAG_REMOVED;
488 sd->s_sibling = acxt->removed;
489 acxt->removed = sd;
490
491 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
492 drop_nlink(acxt->parent_inode);
493
494 acxt->cnt++;
495}
496
497/**
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900498 * sysfs_drop_dentry - drop dentry for the specified sysfs_dirent
499 * @sd: target sysfs_dirent
500 *
501 * Drop dentry for @sd. @sd must have been unlinked from its
502 * parent on entry to this function such that it can't be looked
503 * up anymore.
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900504 */
505static void sysfs_drop_dentry(struct sysfs_dirent *sd)
506{
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900507 struct inode *inode;
Eric W. Biederman89bec092007-08-20 21:36:30 +0900508 struct dentry *dentry;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900509
Eric W. Biederman89bec092007-08-20 21:36:30 +0900510 inode = ilookup(sysfs_sb, sd->s_ino);
511 if (!inode)
512 return;
513
514 /* Drop any existing dentries associated with sd.
515 *
516 * For the dentry to be properly freed we need to grab a
517 * reference to the dentry under the dcache lock, unhash it,
518 * and then put it. The playing with the dentry count allows
519 * dput to immediately free the dentry if it is not in use.
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900520 */
Eric W. Biederman89bec092007-08-20 21:36:30 +0900521repeat:
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900522 spin_lock(&dcache_lock);
Eric W. Biederman89bec092007-08-20 21:36:30 +0900523 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
524 if (d_unhashed(dentry))
525 continue;
526 dget_locked(dentry);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900527 spin_lock(&dentry->d_lock);
528 __d_drop(dentry);
529 spin_unlock(&dentry->d_lock);
Eric W. Biederman89bec092007-08-20 21:36:30 +0900530 spin_unlock(&dcache_lock);
531 dput(dentry);
532 goto repeat;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900533 }
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900534 spin_unlock(&dcache_lock);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900535
536 /* adjust nlink and update timestamp */
Eric W. Biederman89bec092007-08-20 21:36:30 +0900537 mutex_lock(&inode->i_mutex);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900538
Eric W. Biederman89bec092007-08-20 21:36:30 +0900539 inode->i_ctime = CURRENT_TIME;
540 drop_nlink(inode);
541 if (sysfs_type(sd) == SYSFS_DIR)
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900542 drop_nlink(inode);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900543
Eric W. Biederman89bec092007-08-20 21:36:30 +0900544 mutex_unlock(&inode->i_mutex);
545
546 iput(inode);
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900547}
548
549/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900550 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
551 * @acxt: addrm context to finish up
552 *
553 * Finish up sysfs_dirent add/remove. Resources acquired by
554 * sysfs_addrm_start() are released and removed sysfs_dirents are
555 * cleaned up. Timestamps on the parent inode are updated.
556 *
557 * LOCKING:
558 * All mutexes acquired by sysfs_addrm_start() are released.
Tejun Heofb6896d2007-06-14 04:27:24 +0900559 */
Tejun Heo990e53f2007-08-02 21:38:03 +0900560void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
Tejun Heofb6896d2007-06-14 04:27:24 +0900561{
562 /* release resources acquired by sysfs_addrm_start() */
563 mutex_unlock(&sysfs_mutex);
564 if (acxt->parent_inode) {
565 struct inode *inode = acxt->parent_inode;
566
567 /* if added/removed, update timestamps on the parent */
568 if (acxt->cnt)
569 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
570
571 mutex_unlock(&inode->i_mutex);
572 iput(inode);
Tejun Heo13b30862007-06-14 03:45:14 +0900573 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900574
575 /* kill removed sysfs_dirents */
576 while (acxt->removed) {
577 struct sysfs_dirent *sd = acxt->removed;
578
579 acxt->removed = sd->s_sibling;
580 sd->s_sibling = NULL;
581
582 sysfs_drop_dentry(sd);
583 sysfs_deactivate(sd);
584 sysfs_put(sd);
585 }
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700586}
587
Tejun Heof0b0af42007-06-14 04:27:22 +0900588/**
589 * sysfs_find_dirent - find sysfs_dirent with the given name
590 * @parent_sd: sysfs_dirent to search under
591 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530592 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900593 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530594 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900595 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900596 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900597 *
598 * RETURNS:
599 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530600 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900601struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
602 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530603{
Tejun Heof0b0af42007-06-14 04:27:22 +0900604 struct sysfs_dirent *sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530605
Tejun Heobc747f32007-09-20 16:05:12 +0900606 for (sd = parent_sd->s_dir.children; sd; sd = sd->s_sibling)
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900607 if (!strcmp(sd->s_name, name))
Tejun Heof0b0af42007-06-14 04:27:22 +0900608 return sd;
609 return NULL;
610}
Maneesh Sonic5168652006-03-09 19:40:14 +0530611
Tejun Heof0b0af42007-06-14 04:27:22 +0900612/**
613 * sysfs_get_dirent - find and get sysfs_dirent with the given name
614 * @parent_sd: sysfs_dirent to search under
615 * @name: name to look for
616 *
617 * Look for sysfs_dirent with name @name under @parent_sd and get
618 * it if found.
619 *
620 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900621 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900622 *
623 * RETURNS:
624 * Pointer to sysfs_dirent if found, NULL if not.
625 */
626struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
627 const unsigned char *name)
628{
629 struct sysfs_dirent *sd;
630
Tejun Heo3007e992007-06-14 04:27:23 +0900631 mutex_lock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900632 sd = sysfs_find_dirent(parent_sd, name);
633 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900634 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900635
636 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530637}
Neil Brownf1282c82008-07-16 08:58:04 +1000638EXPORT_SYMBOL_GPL(sysfs_get_dirent);
Maneesh Sonic5168652006-03-09 19:40:14 +0530639
Tejun Heo608e2662007-06-14 04:27:22 +0900640static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
641 const char *name, struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900644 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900645 struct sysfs_dirent *sd;
Tejun Heo23dc2792007-08-02 21:38:03 +0900646 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Tejun Heofc9f54b2007-06-14 03:45:17 +0900648 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900649 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900650 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900651 return -ENOMEM;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900652 sd->s_dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900653
Tejun Heo51225032007-06-14 04:27:25 +0900654 /* link in */
655 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo23dc2792007-08-02 21:38:03 +0900656 rc = sysfs_add_one(&acxt, sd);
657 sysfs_addrm_finish(&acxt);
Tejun Heo967e35d2007-07-18 16:38:11 +0900658
Tejun Heo23dc2792007-08-02 21:38:03 +0900659 if (rc == 0)
660 *p_sd = sd;
661 else
Tejun Heo967e35d2007-07-18 16:38:11 +0900662 sysfs_put(sd);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900663
Tejun Heo23dc2792007-08-02 21:38:03 +0900664 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665}
666
Tejun Heo608e2662007-06-14 04:27:22 +0900667int sysfs_create_subdir(struct kobject *kobj, const char *name,
668 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
Tejun Heo608e2662007-06-14 04:27:22 +0900670 return create_dir(kobj, kobj->sd, name, p_sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673/**
674 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 * @kobj: object we're creating directory for.
676 */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900677int sysfs_create_dir(struct kobject * kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
Tejun Heo608e2662007-06-14 04:27:22 +0900679 struct sysfs_dirent *parent_sd, *sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 int error = 0;
681
682 BUG_ON(!kobj);
683
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900684 if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900685 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 else
Eric W. Biederman7d0c7d62007-08-20 21:36:30 +0900687 parent_sd = &sysfs_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Tejun Heo608e2662007-06-14 04:27:22 +0900689 error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900691 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return error;
693}
694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
696 struct nameidata *nd)
697{
Tejun Heo6cb52142007-07-31 19:15:08 +0900698 struct dentry *ret = NULL;
Tejun Heoa7a04752007-08-02 21:38:02 +0900699 struct sysfs_dirent *parent_sd = dentry->d_parent->d_fsdata;
700 struct sysfs_dirent *sd;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900701 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Tejun Heo6cb52142007-07-31 19:15:08 +0900703 mutex_lock(&sysfs_mutex);
704
Eric W. Biederman94777e02007-08-20 21:36:30 +0900705 sd = sysfs_find_dirent(parent_sd, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Tejun Heofc9f54b2007-06-14 03:45:17 +0900707 /* no such entry */
Tejun Heoe49452c2008-01-16 12:06:14 +0900708 if (!sd) {
709 ret = ERR_PTR(-ENOENT);
Tejun Heo6cb52142007-07-31 19:15:08 +0900710 goto out_unlock;
Tejun Heoe49452c2008-01-16 12:06:14 +0900711 }
Tejun Heofc9f54b2007-06-14 03:45:17 +0900712
713 /* attach dentry and inode */
Tejun Heo8312a8d2007-06-14 03:45:17 +0900714 inode = sysfs_get_inode(sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900715 if (!inode) {
716 ret = ERR_PTR(-ENOMEM);
717 goto out_unlock;
718 }
Tejun Heo3007e992007-06-14 04:27:23 +0900719
Tejun Heod6b4fd22007-09-20 16:05:11 +0900720 /* instantiate and hash dentry */
721 dentry->d_op = &sysfs_dentry_ops;
722 dentry->d_fsdata = sysfs_get(sd);
Eric W. Biederman119dd522007-08-20 21:36:29 +0900723 d_instantiate(dentry, inode);
Tejun Heod6b4fd22007-09-20 16:05:11 +0900724 d_rehash(dentry);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900725
Tejun Heo6cb52142007-07-31 19:15:08 +0900726 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900727 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900728 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729}
730
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800731const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 .lookup = sysfs_lookup,
Maneesh Soni988d1862005-05-31 10:39:14 +0530733 .setattr = sysfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734};
735
Tejun Heo608e2662007-06-14 04:27:22 +0900736static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Tejun Heofb6896d2007-06-14 04:27:24 +0900738 struct sysfs_addrm_cxt acxt;
739
740 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heofb6896d2007-06-14 04:27:24 +0900741 sysfs_remove_one(&acxt, sd);
742 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743}
744
Tejun Heo608e2662007-06-14 04:27:22 +0900745void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Tejun Heo608e2662007-06-14 04:27:22 +0900747 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748}
749
750
Tejun Heo608e2662007-06-14 04:27:22 +0900751static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
Tejun Heofb6896d2007-06-14 04:27:24 +0900753 struct sysfs_addrm_cxt acxt;
Tejun Heo0c73f182007-06-14 03:45:18 +0900754 struct sysfs_dirent **pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Tejun Heo608e2662007-06-14 04:27:22 +0900756 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 return;
758
Tejun Heo608e2662007-06-14 04:27:22 +0900759 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900760 sysfs_addrm_start(&acxt, dir_sd);
Tejun Heobc747f32007-09-20 16:05:12 +0900761 pos = &dir_sd->s_dir.children;
Tejun Heo0c73f182007-06-14 03:45:18 +0900762 while (*pos) {
763 struct sysfs_dirent *sd = *pos;
764
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900765 if (sysfs_type(sd) != SYSFS_DIR)
Tejun Heofb6896d2007-06-14 04:27:24 +0900766 sysfs_remove_one(&acxt, sd);
Tejun Heo41fc1c22007-08-02 21:38:03 +0900767 else
Tejun Heo0c73f182007-06-14 03:45:18 +0900768 pos = &(*pos)->s_sibling;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900770 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900771
Tejun Heo608e2662007-06-14 04:27:22 +0900772 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700773}
774
775/**
776 * sysfs_remove_dir - remove an object's directory.
777 * @kobj: object.
778 *
779 * The only thing special about this is that we remove any files in
780 * the directory before we remove the directory, and we've inlined
781 * what used to be sysfs_rmdir() below, instead of calling separately.
782 */
783
784void sysfs_remove_dir(struct kobject * kobj)
785{
Tejun Heo608e2662007-06-14 04:27:22 +0900786 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900787
Tejun Heo5f995322007-06-14 04:27:23 +0900788 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900789 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900790 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900791
Tejun Heo608e2662007-06-14 04:27:22 +0900792 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793}
794
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900795int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796{
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900797 struct sysfs_dirent *sd = kobj->sd;
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900798 struct dentry *parent = NULL;
Tejun Heo51225032007-06-14 04:27:25 +0900799 struct dentry *old_dentry = NULL, *new_dentry = NULL;
800 const char *dup_name = NULL;
Tejun Heo996b7372007-06-14 03:45:14 +0900801 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900803 mutex_lock(&sysfs_rename_mutex);
804
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900805 error = 0;
806 if (strcmp(sd->s_name, new_name) == 0)
807 goto out; /* nothing to rename */
808
Tejun Heoff869de2007-08-02 21:38:02 +0900809 /* get the original dentry */
Tejun Heo51225032007-06-14 04:27:25 +0900810 old_dentry = sysfs_get_dentry(sd);
811 if (IS_ERR(old_dentry)) {
812 error = PTR_ERR(old_dentry);
Tejun Heo456ef152008-01-16 12:10:53 +0900813 old_dentry = NULL;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900814 goto out;
Tejun Heo51225032007-06-14 04:27:25 +0900815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
Tejun Heoff869de2007-08-02 21:38:02 +0900817 parent = old_dentry->d_parent;
Tejun Heo51225032007-06-14 04:27:25 +0900818
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900819 /* lock parent and get dentry for new name */
820 mutex_lock(&parent->d_inode->i_mutex);
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900821 mutex_lock(&sysfs_mutex);
Tejun Heo996b7372007-06-14 03:45:14 +0900822
823 error = -EEXIST;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900824 if (sysfs_find_dirent(sd->s_parent, new_name))
825 goto out_unlock;
826
827 error = -ENOMEM;
828 new_dentry = d_alloc_name(parent, new_name);
829 if (!new_dentry)
Tejun Heo51225032007-06-14 04:27:25 +0900830 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900831
Eric W. Biederman0b4a4fe2008-07-03 18:05:28 -0700832 /* rename sysfs_dirent */
Tejun Heo0c096b52007-06-14 03:45:15 +0900833 error = -ENOMEM;
834 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
835 if (!new_name)
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900836 goto out_unlock;
Tejun Heo996b7372007-06-14 03:45:14 +0900837
Tejun Heo51225032007-06-14 04:27:25 +0900838 dup_name = sd->s_name;
Tejun Heo0c096b52007-06-14 03:45:15 +0900839 sd->s_name = new_name;
840
Tejun Heoff869de2007-08-02 21:38:02 +0900841 /* rename */
Tejun Heo996b7372007-06-14 03:45:14 +0900842 d_add(new_dentry, NULL);
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900843 d_move(old_dentry, new_dentry);
Tejun Heo996b7372007-06-14 03:45:14 +0900844
Tejun Heo996b7372007-06-14 03:45:14 +0900845 error = 0;
Tejun Heo996b7372007-06-14 03:45:14 +0900846 out_unlock:
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900847 mutex_unlock(&sysfs_mutex);
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900848 mutex_unlock(&parent->d_inode->i_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900849 kfree(dup_name);
Tejun Heo51225032007-06-14 04:27:25 +0900850 dput(old_dentry);
851 dput(new_dentry);
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900852 out:
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900853 mutex_unlock(&sysfs_rename_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 return error;
855}
856
Tejun Heo51225032007-06-14 04:27:25 +0900857int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100858{
Tejun Heo51225032007-06-14 04:27:25 +0900859 struct sysfs_dirent *sd = kobj->sd;
860 struct sysfs_dirent *new_parent_sd;
861 struct dentry *old_parent, *new_parent = NULL;
862 struct dentry *old_dentry = NULL, *new_dentry = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100863 int error;
864
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900865 mutex_lock(&sysfs_rename_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900866 BUG_ON(!sd->s_parent);
867 new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100868
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900869 error = 0;
870 if (sd->s_parent == new_parent_sd)
871 goto out; /* nothing to move */
872
Tejun Heo51225032007-06-14 04:27:25 +0900873 /* get dentries */
874 old_dentry = sysfs_get_dentry(sd);
875 if (IS_ERR(old_dentry)) {
876 error = PTR_ERR(old_dentry);
Tejun Heo456ef152008-01-16 12:10:53 +0900877 old_dentry = NULL;
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900878 goto out;
Tejun Heo51225032007-06-14 04:27:25 +0900879 }
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900880 old_parent = old_dentry->d_parent;
Tejun Heo51225032007-06-14 04:27:25 +0900881
882 new_parent = sysfs_get_dentry(new_parent_sd);
883 if (IS_ERR(new_parent)) {
884 error = PTR_ERR(new_parent);
Tejun Heo456ef152008-01-16 12:10:53 +0900885 new_parent = NULL;
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900886 goto out;
Tejun Heo51225032007-06-14 04:27:25 +0900887 }
888
Cornelia Huck8a824722006-11-20 17:07:51 +0100889again:
Tejun Heo51225032007-06-14 04:27:25 +0900890 mutex_lock(&old_parent->d_inode->i_mutex);
891 if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
892 mutex_unlock(&old_parent->d_inode->i_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100893 goto again;
894 }
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900895 mutex_lock(&sysfs_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100896
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900897 error = -EEXIST;
898 if (sysfs_find_dirent(new_parent_sd, sd->s_name))
Tejun Heo51225032007-06-14 04:27:25 +0900899 goto out_unlock;
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900900
901 error = -ENOMEM;
902 new_dentry = d_alloc_name(new_parent, sd->s_name);
903 if (!new_dentry)
904 goto out_unlock;
905
906 error = 0;
Cornelia Huck8a824722006-11-20 17:07:51 +0100907 d_add(new_dentry, NULL);
Eric W. Biederman5a26b792007-08-20 21:36:30 +0900908 d_move(old_dentry, new_dentry);
Cornelia Huck8a824722006-11-20 17:07:51 +0100909
910 /* Remove from old parent's list and insert into new parent's list. */
Tejun Heo0c73f182007-06-14 03:45:18 +0900911 sysfs_unlink_sibling(sd);
Tejun Heo7f7cfff2007-06-14 03:45:17 +0900912 sysfs_get(new_parent_sd);
913 sysfs_put(sd->s_parent);
914 sd->s_parent = new_parent_sd;
Tejun Heo0c73f182007-06-14 03:45:18 +0900915 sysfs_link_sibling(sd);
Cornelia Huck8a824722006-11-20 17:07:51 +0100916
Tejun Heo51225032007-06-14 04:27:25 +0900917 out_unlock:
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900918 mutex_unlock(&sysfs_mutex);
Tejun Heo51225032007-06-14 04:27:25 +0900919 mutex_unlock(&new_parent->d_inode->i_mutex);
920 mutex_unlock(&old_parent->d_inode->i_mutex);
Eric W. Biederman45aaae92007-08-20 21:36:31 +0900921 out:
Tejun Heo51225032007-06-14 04:27:25 +0900922 dput(new_parent);
923 dput(old_dentry);
924 dput(new_dentry);
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900925 mutex_unlock(&sysfs_rename_mutex);
Cornelia Huck8a824722006-11-20 17:07:51 +0100926 return error;
927}
928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929/* Relationship between s_mode and the DT_xxx types */
930static inline unsigned char dt_type(struct sysfs_dirent *sd)
931{
932 return (sd->s_mode >> 12) & 15;
933}
934
935static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
936{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -0800937 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900939 struct sysfs_dirent *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 ino_t ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900942 if (filp->f_pos == 0) {
943 ino = parent_sd->s_ino;
944 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
945 filp->f_pos++;
946 }
947 if (filp->f_pos == 1) {
948 if (parent_sd->s_parent)
949 ino = parent_sd->s_parent->s_ino;
950 else
Eric Sandeendc351252007-06-11 14:02:45 +0900951 ino = parent_sd->s_ino;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900952 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 filp->f_pos++;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900954 }
955 if ((filp->f_pos > 1) && (filp->f_pos < INT_MAX)) {
956 mutex_lock(&sysfs_mutex);
957
958 /* Skip the dentries we have already reported */
Tejun Heobc747f32007-09-20 16:05:12 +0900959 pos = parent_sd->s_dir.children;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900960 while (pos && (filp->f_pos > pos->s_ino))
961 pos = pos->s_sibling;
962
963 for ( ; pos; pos = pos->s_sibling) {
964 const char * name;
965 int len;
966
967 name = pos->s_name;
968 len = strlen(name);
969 filp->f_pos = ino = pos->s_ino;
970
971 if (filldir(dirent, name, len, filp->f_pos, ino,
972 dt_type(pos)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 break;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900974 }
975 if (!pos)
976 filp->f_pos = INT_MAX;
977 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 }
979 return 0;
980}
981
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800983const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 .read = generic_read_dir,
985 .readdir = sysfs_readdir,
986};