blob: 6b0bb00d4d2b6061add5a1f266371df257e5c4a9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Tejun Heo6d66f5c2007-09-20 17:31:38 +09002 * fs/sysfs/dir.c - sysfs core and dir operation implementation
3 *
4 * Copyright (c) 2001-3 Patrick Mochel
5 * Copyright (c) 2007 SUSE Linux Products GmbH
6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7 *
8 * This file is released under the GPLv2.
9 *
10 * Please see Documentation/filesystems/sysfs.txt for more information.
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
13#undef DEBUG
14
15#include <linux/fs.h>
16#include <linux/mount.h>
17#include <linux/module.h>
18#include <linux/kobject.h>
Christoph Hellwig5f45f1a2005-06-23 00:09:12 -070019#include <linux/namei.h>
Tejun Heo2b611bb2007-06-14 03:45:13 +090020#include <linux/idr.h>
Tejun Heo8619f972007-06-14 03:45:18 +090021#include <linux/completion.h>
Dave Young869512a2007-07-26 14:53:53 +000022#include <linux/mutex.h>
Robert P. J. Dayc6f87732008-03-13 22:41:52 -040023#include <linux/slab.h>
Eric W. Biederman4c3da222009-11-04 02:50:06 -080024#include <linux/security.h>
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080025#include <linux/hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "sysfs.h"
27
Tejun Heo3007e992007-06-14 04:27:23 +090028DEFINE_MUTEX(sysfs_mutex);
Roel Kluinf7a75f02007-10-16 23:30:25 -070029DEFINE_SPINLOCK(sysfs_assoc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080031#define to_sysfs_dirent(X) rb_entry((X), struct sysfs_dirent, s_rb);
32
Roel Kluinf7a75f02007-10-16 23:30:25 -070033static DEFINE_SPINLOCK(sysfs_ino_lock);
Tejun Heo2b611bb2007-06-14 03:45:13 +090034static DEFINE_IDA(sysfs_ino_ida);
35
Tejun Heob6b4a432007-06-14 03:45:18 +090036/**
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080037 * sysfs_name_hash
38 * @ns: Namespace tag to hash
39 * @name: Null terminated string to hash
40 *
41 * Returns 31 bit hash of ns + name (so it fits in an off_t )
42 */
43static unsigned int sysfs_name_hash(const void *ns, const char *name)
44{
45 unsigned long hash = init_name_hash();
46 unsigned int len = strlen(name);
47 while (len--)
48 hash = partial_name_hash(*name++, hash);
49 hash = ( end_name_hash(hash) ^ hash_ptr( (void *)ns, 31 ) );
50 hash &= 0x7fffffffU;
51 /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
52 if (hash < 1)
53 hash += 2;
54 if (hash >= INT_MAX)
55 hash = INT_MAX - 1;
56 return hash;
57}
58
59static int sysfs_name_compare(unsigned int hash, const void *ns,
60 const char *name, const struct sysfs_dirent *sd)
61{
62 if (hash != sd->s_hash)
63 return hash - sd->s_hash;
64 if (ns != sd->s_ns)
65 return ns - sd->s_ns;
66 return strcmp(name, sd->s_name);
67}
68
69static int sysfs_sd_compare(const struct sysfs_dirent *left,
70 const struct sysfs_dirent *right)
71{
72 return sysfs_name_compare(left->s_hash, left->s_ns, left->s_name,
73 right);
74}
75
76/**
77 * sysfs_link_subling - link sysfs_dirent into sibling rbtree
Tejun Heo0c73f182007-06-14 03:45:18 +090078 * @sd: sysfs_dirent of interest
79 *
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080080 * Link @sd into its sibling rbtree which starts from
Tejun Heobc747f32007-09-20 16:05:12 +090081 * sd->s_parent->s_dir.children.
Tejun Heo0c73f182007-06-14 03:45:18 +090082 *
83 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +090084 * mutex_lock(sysfs_mutex)
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080085 *
86 * RETURNS:
87 * 0 on susccess -EEXIST on failure.
Tejun Heo0c73f182007-06-14 03:45:18 +090088 */
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080089static int sysfs_link_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +090090{
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080091 struct rb_node **node = &sd->s_parent->s_dir.children.rb_node;
92 struct rb_node *parent = NULL;
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -040093
Greg Kroah-Hartman54d20f02012-03-08 13:03:10 -080094 if (sysfs_type(sd) == SYSFS_DIR)
95 sd->s_parent->s_dir.subdirs++;
96
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -080097 while (*node) {
98 struct sysfs_dirent *pos;
99 int result;
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400100
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800101 pos = to_sysfs_dirent(*node);
102 parent = *node;
103 result = sysfs_sd_compare(sd, pos);
104 if (result < 0)
105 node = &pos->s_rb.rb_left;
106 else if (result > 0)
107 node = &pos->s_rb.rb_right;
108 else
109 return -EEXIST;
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400110 }
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800111 /* add new node and rebalance the tree */
112 rb_link_node(&sd->s_rb, parent, node);
113 rb_insert_color(&sd->s_rb, &sd->s_parent->s_dir.children);
114 return 0;
Tejun Heo0c73f182007-06-14 03:45:18 +0900115}
116
117/**
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800118 * sysfs_unlink_sibling - unlink sysfs_dirent from sibling rbtree
Tejun Heo0c73f182007-06-14 03:45:18 +0900119 * @sd: sysfs_dirent of interest
120 *
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800121 * Unlink @sd from its sibling rbtree which starts from
Tejun Heobc747f32007-09-20 16:05:12 +0900122 * sd->s_parent->s_dir.children.
Tejun Heo0c73f182007-06-14 03:45:18 +0900123 *
124 * Locking:
Tejun Heo3007e992007-06-14 04:27:23 +0900125 * mutex_lock(sysfs_mutex)
Tejun Heo0c73f182007-06-14 03:45:18 +0900126 */
Tejun Heo41fc1c22007-08-02 21:38:03 +0900127static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
Tejun Heo0c73f182007-06-14 03:45:18 +0900128{
Greg Kroah-Hartman54d20f02012-03-08 13:03:10 -0800129 if (sysfs_type(sd) == SYSFS_DIR)
130 sd->s_parent->s_dir.subdirs--;
131
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800132 rb_erase(&sd->s_rb, &sd->s_parent->s_dir.children);
Tejun Heo0c73f182007-06-14 03:45:18 +0900133}
134
Alan Stern356c05d2012-05-14 13:30:03 -0400135#ifdef CONFIG_DEBUG_LOCK_ALLOC
136
137/* Test for attributes that want to ignore lockdep for read-locking */
138static bool ignore_lockdep(struct sysfs_dirent *sd)
139{
140 return sysfs_type(sd) == SYSFS_KOBJ_ATTR &&
141 sd->s_attr.attr->ignore_lockdep;
142}
143
144#else
145
146static inline bool ignore_lockdep(struct sysfs_dirent *sd)
147{
148 return true;
149}
150
151#endif
152
Tejun Heo0c73f182007-06-14 03:45:18 +0900153/**
Tejun Heob6b4a432007-06-14 03:45:18 +0900154 * sysfs_get_active - get an active reference to sysfs_dirent
155 * @sd: sysfs_dirent to get an active reference to
156 *
157 * Get an active reference of @sd. This function is noop if @sd
158 * is NULL.
159 *
160 * RETURNS:
161 * Pointer to @sd on success, NULL on failure.
162 */
Eric W. Biedermane72ceb82010-02-11 15:18:38 -0800163struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900164{
Tejun Heo8619f972007-06-14 03:45:18 +0900165 if (unlikely(!sd))
166 return NULL;
167
168 while (1) {
169 int v, t;
170
171 v = atomic_read(&sd->s_active);
172 if (unlikely(v < 0))
173 return NULL;
174
175 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
Alan Stern356c05d2012-05-14 13:30:03 -0400176 if (likely(t == v))
177 break;
Tejun Heo8619f972007-06-14 03:45:18 +0900178 if (t < 0)
179 return NULL;
180
181 cpu_relax();
Tejun Heob6b4a432007-06-14 03:45:18 +0900182 }
Alan Stern356c05d2012-05-14 13:30:03 -0400183
184 if (likely(!ignore_lockdep(sd)))
185 rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
186 return sd;
Tejun Heob6b4a432007-06-14 03:45:18 +0900187}
188
189/**
190 * sysfs_put_active - put an active reference to sysfs_dirent
191 * @sd: sysfs_dirent to put an active reference to
192 *
193 * Put an active reference to @sd. This function is noop if @sd
194 * is NULL.
195 */
Eric W. Biedermane72ceb82010-02-11 15:18:38 -0800196void sysfs_put_active(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900197{
Tejun Heo8619f972007-06-14 03:45:18 +0900198 int v;
199
200 if (unlikely(!sd))
201 return;
202
Alan Stern356c05d2012-05-14 13:30:03 -0400203 if (likely(!ignore_lockdep(sd)))
204 rwsem_release(&sd->dep_map, 1, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900205 v = atomic_dec_return(&sd->s_active);
206 if (likely(v != SD_DEACTIVATED_BIAS))
207 return;
208
209 /* atomic_dec_return() is a mb(), we'll always see the updated
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400210 * sd->u.completion.
Tejun Heo8619f972007-06-14 03:45:18 +0900211 */
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400212 complete(sd->u.completion);
Tejun Heob6b4a432007-06-14 03:45:18 +0900213}
214
215/**
Tejun Heob6b4a432007-06-14 03:45:18 +0900216 * sysfs_deactivate - deactivate sysfs_dirent
217 * @sd: sysfs_dirent to deactivate
218 *
Tejun Heo8619f972007-06-14 03:45:18 +0900219 * Deny new active references and drain existing ones.
Tejun Heob6b4a432007-06-14 03:45:18 +0900220 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900221static void sysfs_deactivate(struct sysfs_dirent *sd)
Tejun Heob6b4a432007-06-14 03:45:18 +0900222{
Tejun Heo8619f972007-06-14 03:45:18 +0900223 DECLARE_COMPLETION_ONSTACK(wait);
224 int v;
Tejun Heob6b4a432007-06-14 03:45:18 +0900225
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400226 BUG_ON(!(sd->s_flags & SYSFS_FLAG_REMOVED));
Eric W. Biedermana2db6842010-02-11 15:20:00 -0800227
228 if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
229 return;
230
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400231 sd->u.completion = (void *)&wait;
Tejun Heo8619f972007-06-14 03:45:18 +0900232
Eric W. Biederman846f9972010-01-02 13:37:12 -0800233 rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900234 /* atomic_add_return() is a mb(), put_active() will always see
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400235 * the updated sd->u.completion.
Tejun Heob6b4a432007-06-14 03:45:18 +0900236 */
Tejun Heo8619f972007-06-14 03:45:18 +0900237 v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
238
Eric W. Biederman846f9972010-01-02 13:37:12 -0800239 if (v != SD_DEACTIVATED_BIAS) {
240 lock_contended(&sd->dep_map, _RET_IP_);
Tejun Heo8619f972007-06-14 03:45:18 +0900241 wait_for_completion(&wait);
Eric W. Biederman846f9972010-01-02 13:37:12 -0800242 }
Tejun Heo8619f972007-06-14 03:45:18 +0900243
Eric W. Biederman846f9972010-01-02 13:37:12 -0800244 lock_acquired(&sd->dep_map, _RET_IP_);
245 rwsem_release(&sd->dep_map, 1, _RET_IP_);
Tejun Heob6b4a432007-06-14 03:45:18 +0900246}
247
Eric W. Biedermancafa6b52011-12-18 20:08:16 -0800248static int sysfs_alloc_ino(unsigned int *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
Eric W. Biedermancafa6b52011-12-18 20:08:16 -0800267static void sysfs_free_ino(unsigned int ino)
Tejun Heo2b611bb2007-06-14 03:45:13 +0900268{
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);
Eric W. Biederman4c3da222009-11-04 02:50:06 -0800288 if (sd->s_iattr && sd->s_iattr->ia_secdata)
289 security_release_secctx(sd->s_iattr->ia_secdata,
290 sd->s_iattr->ia_secdata_len);
Tejun Heofa7f9122007-06-14 03:45:13 +0900291 kfree(sd->s_iattr);
Tejun Heo2b611bb2007-06-14 03:45:13 +0900292 sysfs_free_ino(sd->s_ino);
Tejun Heofa7f9122007-06-14 03:45:13 +0900293 kmem_cache_free(sysfs_dir_cachep, sd);
Tejun Heo13b30862007-06-14 03:45:14 +0900294
295 sd = parent_sd;
296 if (sd && atomic_dec_and_test(&sd->s_count))
297 goto repeat;
Tejun Heofa7f9122007-06-14 03:45:13 +0900298}
299
Nick Pigginfe15ce42011-01-07 17:49:23 +1100300static int sysfs_dentry_delete(const struct dentry *dentry)
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800301{
302 struct sysfs_dirent *sd = dentry->d_fsdata;
Al Viro469796d2012-06-07 20:51:39 -0400303 return !(sd && !(sd->s_flags & SYSFS_FLAG_REMOVED));
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800304}
305
Al Viro0b728e12012-06-10 16:03:43 -0400306static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800307{
Nick Piggin34286d62011-01-07 17:49:57 +1100308 struct sysfs_dirent *sd;
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800309 int is_dir;
Glauber Costae5bcac62012-07-06 13:09:07 +0400310 int type;
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800311
Al Viro0b728e12012-06-10 16:03:43 -0400312 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +1100313 return -ECHILD;
314
315 sd = dentry->d_fsdata;
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800316 mutex_lock(&sysfs_mutex);
317
318 /* The sysfs dirent has been deleted */
319 if (sd->s_flags & SYSFS_FLAG_REMOVED)
320 goto out_bad;
321
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800322 /* The sysfs dirent has been moved? */
323 if (dentry->d_parent->d_fsdata != sd->s_parent)
324 goto out_bad;
325
326 /* The sysfs dirent has been renamed */
327 if (strcmp(dentry->d_name.name, sd->s_name) != 0)
328 goto out_bad;
329
Glauber Costae5bcac62012-07-06 13:09:07 +0400330 /* The sysfs dirent has been moved to a different namespace */
331 type = KOBJ_NS_TYPE_NONE;
Andrew Morton17f79be2012-07-09 16:13:36 -0700332 if (sd->s_parent) {
Glauber Costae5bcac62012-07-06 13:09:07 +0400333 type = sysfs_ns_type(sd->s_parent);
Andrew Morton17f79be2012-07-09 16:13:36 -0700334 if (type != KOBJ_NS_TYPE_NONE &&
335 sysfs_info(dentry->d_sb)->ns[type] != sd->s_ns)
336 goto out_bad;
337 }
Glauber Costae5bcac62012-07-06 13:09:07 +0400338
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800339 mutex_unlock(&sysfs_mutex);
340out_valid:
341 return 1;
342out_bad:
343 /* Remove the dentry from the dcache hashes.
344 * If this is a deleted dentry we use d_drop instead of d_delete
345 * so sysfs doesn't need to cope with negative dentries.
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800346 *
347 * If this is a dentry that has simply been renamed we
348 * use d_drop to remove it from the dcache lookup on its
349 * old parent. If this dentry persists later when a lookup
350 * is performed at its new name the dentry will be readded
351 * to the dcache hashes.
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800352 */
353 is_dir = (sysfs_type(sd) == SYSFS_DIR);
354 mutex_unlock(&sysfs_mutex);
355 if (is_dir) {
356 /* If we have submounts we must allow the vfs caches
357 * to lie about the state of the filesystem to prevent
358 * leaks and other nasty things.
359 */
360 if (have_submounts(dentry))
361 goto out_valid;
362 shrink_dcache_parent(dentry);
363 }
364 d_drop(dentry);
365 return 0;
366}
367
Al Viro469796d2012-06-07 20:51:39 -0400368static void sysfs_dentry_release(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
Al Viro469796d2012-06-07 20:51:39 -0400370 sysfs_put(dentry->d_fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Al Viro469796d2012-06-07 20:51:39 -0400373const struct dentry_operations sysfs_dentry_ops = {
Eric W. Biedermane8f077c2009-11-07 23:27:01 -0800374 .d_revalidate = sysfs_dentry_revalidate,
375 .d_delete = sysfs_dentry_delete,
Al Viro469796d2012-06-07 20:51:39 -0400376 .d_release = sysfs_dentry_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377};
378
Tejun Heo3e519032007-06-14 03:45:15 +0900379struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Tejun Heo0c096b52007-06-14 03:45:15 +0900381 char *dup_name = NULL;
Akinobu Mita01da2422007-07-14 11:03:35 +0900382 struct sysfs_dirent *sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900383
384 if (type & SYSFS_COPY_NAME) {
385 name = dup_name = kstrdup(name, GFP_KERNEL);
386 if (!name)
Akinobu Mita01da2422007-07-14 11:03:35 +0900387 return NULL;
Tejun Heo0c096b52007-06-14 03:45:15 +0900388 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800390 sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 if (!sd)
Akinobu Mita01da2422007-07-14 11:03:35 +0900392 goto err_out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Tejun Heo0c096b52007-06-14 03:45:15 +0900394 if (sysfs_alloc_ino(&sd->s_ino))
Akinobu Mita01da2422007-07-14 11:03:35 +0900395 goto err_out2;
Tejun Heo2b611bb2007-06-14 03:45:13 +0900396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 atomic_set(&sd->s_count, 1);
Tejun Heo8619f972007-06-14 03:45:18 +0900398 atomic_set(&sd->s_active, 0);
Tejun Heoa26cd722007-06-14 03:45:14 +0900399
Tejun Heo0c096b52007-06-14 03:45:15 +0900400 sd->s_name = name;
Tejun Heoa26cd722007-06-14 03:45:14 +0900401 sd->s_mode = mode;
Tejun Heob402d722007-06-14 04:27:21 +0900402 sd->s_flags = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
404 return sd;
Tejun Heo0c096b52007-06-14 03:45:15 +0900405
Akinobu Mita01da2422007-07-14 11:03:35 +0900406 err_out2:
Tejun Heo0c096b52007-06-14 03:45:15 +0900407 kmem_cache_free(sysfs_dir_cachep, sd);
Akinobu Mita01da2422007-07-14 11:03:35 +0900408 err_out1:
409 kfree(dup_name);
Tejun Heo0c096b52007-06-14 03:45:15 +0900410 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411}
412
Tejun Heo3007e992007-06-14 04:27:23 +0900413/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900414 * sysfs_addrm_start - prepare for sysfs_dirent add/remove
415 * @acxt: pointer to sysfs_addrm_cxt to be used
416 * @parent_sd: parent sysfs_dirent
Tejun Heo3007e992007-06-14 04:27:23 +0900417 *
Tejun Heofb6896d2007-06-14 04:27:24 +0900418 * This function is called when the caller is about to add or
419 * remove sysfs_dirent under @parent_sd. This function acquires
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800420 * sysfs_mutex. @acxt is used to keep and pass context to
Tejun Heofb6896d2007-06-14 04:27:24 +0900421 * other addrm functions.
Tejun Heo3007e992007-06-14 04:27:23 +0900422 *
423 * LOCKING:
Tejun Heofb6896d2007-06-14 04:27:24 +0900424 * Kernel thread context (may sleep). sysfs_mutex is locked on
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800425 * return.
Tejun Heo3007e992007-06-14 04:27:23 +0900426 */
Tejun Heofb6896d2007-06-14 04:27:24 +0900427void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
428 struct sysfs_dirent *parent_sd)
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700429{
Tejun Heofb6896d2007-06-14 04:27:24 +0900430 memset(acxt, 0, sizeof(*acxt));
431 acxt->parent_sd = parent_sd;
432
Tejun Heofb6896d2007-06-14 04:27:24 +0900433 mutex_lock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +0900434}
435
436/**
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200437 * __sysfs_add_one - add sysfs_dirent to parent without warning
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
442 * nlink of parent inode if @sd is a directory and link into the
443 * children list of the parent.
444 *
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().
451 *
452 * RETURNS:
453 * 0 on success, -EEXIST if entry with the given name already
454 * exists.
455 */
456int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
457{
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800458 struct sysfs_inode_attrs *ps_iattr;
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800459 int ret;
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800460
Eric W. Biederman903e21e2011-10-12 22:02:43 +0000461 if (!!sysfs_ns_type(acxt->parent_sd) != !!sd->s_ns) {
462 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
463 sysfs_ns_type(acxt->parent_sd)? "required": "invalid",
464 acxt->parent_sd->s_name, sd->s_name);
465 return -EINVAL;
466 }
467
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800468 sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200469 sd->s_parent = sysfs_get(acxt->parent_sd);
470
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800471 ret = sysfs_link_sibling(sd);
472 if (ret)
473 return ret;
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200474
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800475 /* Update timestamps on the parent */
476 ps_iattr = acxt->parent_sd->s_iattr;
477 if (ps_iattr) {
478 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
479 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
480 }
481
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200482 return 0;
483}
484
485/**
Alex Chiang425cb022009-02-12 10:56:59 -0700486 * sysfs_pathname - return full path to sysfs dirent
487 * @sd: sysfs_dirent whose path we want
488 * @path: caller allocated buffer
489 *
490 * Gives the name "/" to the sysfs_root entry; any path returned
491 * is relative to wherever sysfs is mounted.
492 *
493 * XXX: does no error checking on @path size
494 */
495static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
496{
497 if (sd->s_parent) {
498 sysfs_pathname(sd->s_parent, path);
499 strcat(path, "/");
500 }
501 strcat(path, sd->s_name);
502 return path;
503}
504
505/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900506 * sysfs_add_one - add sysfs_dirent to parent
507 * @acxt: addrm context to use
508 * @sd: sysfs_dirent to be added
509 *
510 * Get @acxt->parent_sd and set sd->s_parent to it and increment
Tejun Heo181b2e42007-09-20 16:05:09 +0900511 * nlink of parent inode if @sd is a directory and link into the
512 * children list of the parent.
Tejun Heofb6896d2007-06-14 04:27:24 +0900513 *
514 * This function should be called between calls to
515 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
516 * passed the same @acxt as passed to sysfs_addrm_start().
517 *
518 * LOCKING:
519 * Determined by sysfs_addrm_start().
Tejun Heo23dc2792007-08-02 21:38:03 +0900520 *
521 * RETURNS:
522 * 0 on success, -EEXIST if entry with the given name already
523 * exists.
Tejun Heofb6896d2007-06-14 04:27:24 +0900524 */
Tejun Heo23dc2792007-08-02 21:38:03 +0900525int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
Tejun Heofb6896d2007-06-14 04:27:24 +0900526{
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200527 int ret;
Tejun Heo23dc2792007-08-02 21:38:03 +0900528
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200529 ret = __sysfs_add_one(acxt, sd);
Alex Chiang425cb022009-02-12 10:56:59 -0700530 if (ret == -EEXIST) {
531 char *path = kzalloc(PATH_MAX, GFP_KERNEL);
532 WARN(1, KERN_WARNING
533 "sysfs: cannot create duplicate filename '%s'\n",
534 (path == NULL) ? sd->s_name :
535 strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
536 sd->s_name));
537 kfree(path);
538 }
539
Cornelia Huck36ce6da2008-06-10 11:09:08 +0200540 return ret;
Tejun Heofb6896d2007-06-14 04:27:24 +0900541}
542
543/**
544 * sysfs_remove_one - remove sysfs_dirent from parent
545 * @acxt: addrm context to use
Jean Delvare9fd5b1c2008-01-08 18:11:24 +0100546 * @sd: sysfs_dirent to be removed
Tejun Heofb6896d2007-06-14 04:27:24 +0900547 *
548 * Mark @sd removed and drop nlink of parent inode if @sd is a
Tejun Heo181b2e42007-09-20 16:05:09 +0900549 * directory. @sd is unlinked from the children list.
Tejun Heofb6896d2007-06-14 04:27:24 +0900550 *
551 * This function should be called between calls to
552 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
553 * passed the same @acxt as passed to sysfs_addrm_start().
554 *
555 * LOCKING:
556 * Determined by sysfs_addrm_start().
557 */
558void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
559{
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800560 struct sysfs_inode_attrs *ps_iattr;
561
Tejun Heo41fc1c22007-08-02 21:38:03 +0900562 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
563
564 sysfs_unlink_sibling(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900565
Eric W. Biederman6b0bfe92009-11-20 16:08:51 -0800566 /* Update timestamps on the parent */
567 ps_iattr = acxt->parent_sd->s_iattr;
568 if (ps_iattr) {
569 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
570 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
571 }
572
Tejun Heofb6896d2007-06-14 04:27:24 +0900573 sd->s_flags |= SYSFS_FLAG_REMOVED;
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400574 sd->u.removed_list = acxt->removed;
Tejun Heofb6896d2007-06-14 04:27:24 +0900575 acxt->removed = sd;
Tejun Heoa0edd7c2007-06-14 04:27:24 +0900576}
577
578/**
Tejun Heofb6896d2007-06-14 04:27:24 +0900579 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
580 * @acxt: addrm context to finish up
581 *
582 * Finish up sysfs_dirent add/remove. Resources acquired by
583 * sysfs_addrm_start() are released and removed sysfs_dirents are
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800584 * cleaned up.
Tejun Heofb6896d2007-06-14 04:27:24 +0900585 *
586 * LOCKING:
Eric W. Biedermana16bbc32009-11-20 16:08:55 -0800587 * sysfs_mutex is released.
Tejun Heofb6896d2007-06-14 04:27:24 +0900588 */
Tejun Heo990e53f2007-08-02 21:38:03 +0900589void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
Tejun Heofb6896d2007-06-14 04:27:24 +0900590{
591 /* release resources acquired by sysfs_addrm_start() */
592 mutex_unlock(&sysfs_mutex);
Tejun Heofb6896d2007-06-14 04:27:24 +0900593
594 /* kill removed sysfs_dirents */
595 while (acxt->removed) {
596 struct sysfs_dirent *sd = acxt->removed;
597
Mikulas Patocka58f2a4c2011-07-21 20:01:12 -0400598 acxt->removed = sd->u.removed_list;
Tejun Heofb6896d2007-06-14 04:27:24 +0900599
Tejun Heofb6896d2007-06-14 04:27:24 +0900600 sysfs_deactivate(sd);
Eric W. Biedermane0edd3c2009-03-04 11:57:20 -0800601 unmap_bin_file(sd);
Tejun Heofb6896d2007-06-14 04:27:24 +0900602 sysfs_put(sd);
603 }
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700604}
605
Tejun Heof0b0af42007-06-14 04:27:22 +0900606/**
607 * sysfs_find_dirent - find sysfs_dirent with the given name
608 * @parent_sd: sysfs_dirent to search under
609 * @name: name to look for
Maneesh Sonic5168652006-03-09 19:40:14 +0530610 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900611 * Look for sysfs_dirent with name @name under @parent_sd.
Maneesh Sonic5168652006-03-09 19:40:14 +0530612 *
Tejun Heof0b0af42007-06-14 04:27:22 +0900613 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900614 * mutex_lock(sysfs_mutex)
Tejun Heof0b0af42007-06-14 04:27:22 +0900615 *
616 * RETURNS:
617 * Pointer to sysfs_dirent if found, NULL if not.
Maneesh Sonic5168652006-03-09 19:40:14 +0530618 */
Tejun Heof0b0af42007-06-14 04:27:22 +0900619struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700620 const void *ns,
Tejun Heof0b0af42007-06-14 04:27:22 +0900621 const unsigned char *name)
Maneesh Sonic5168652006-03-09 19:40:14 +0530622{
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800623 struct rb_node *node = parent_sd->s_dir.children.rb_node;
624 unsigned int hash;
Maneesh Sonic5168652006-03-09 19:40:14 +0530625
Eric W. Biederman903e21e2011-10-12 22:02:43 +0000626 if (!!sysfs_ns_type(parent_sd) != !!ns) {
627 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
628 sysfs_ns_type(parent_sd)? "required": "invalid",
629 parent_sd->s_name, name);
630 return NULL;
631 }
632
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800633 hash = sysfs_name_hash(ns, name);
634 while (node) {
635 struct sysfs_dirent *sd;
636 int result;
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400637
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800638 sd = to_sysfs_dirent(node);
639 result = sysfs_name_compare(hash, ns, name, sd);
640 if (result < 0)
641 node = node->rb_left;
642 else if (result > 0)
643 node = node->rb_right;
644 else
645 return sd;
Mikulas Patocka4f72c0c2011-07-25 17:55:57 -0400646 }
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800647 return NULL;
Tejun Heof0b0af42007-06-14 04:27:22 +0900648}
Maneesh Sonic5168652006-03-09 19:40:14 +0530649
Tejun Heof0b0af42007-06-14 04:27:22 +0900650/**
651 * sysfs_get_dirent - find and get sysfs_dirent with the given name
652 * @parent_sd: sysfs_dirent to search under
653 * @name: name to look for
654 *
655 * Look for sysfs_dirent with name @name under @parent_sd and get
656 * it if found.
657 *
658 * LOCKING:
Tejun Heo3007e992007-06-14 04:27:23 +0900659 * Kernel thread context (may sleep). Grabs sysfs_mutex.
Tejun Heof0b0af42007-06-14 04:27:22 +0900660 *
661 * RETURNS:
662 * Pointer to sysfs_dirent if found, NULL if not.
663 */
664struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700665 const void *ns,
Tejun Heof0b0af42007-06-14 04:27:22 +0900666 const unsigned char *name)
667{
668 struct sysfs_dirent *sd;
669
Tejun Heo3007e992007-06-14 04:27:23 +0900670 mutex_lock(&sysfs_mutex);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700671 sd = sysfs_find_dirent(parent_sd, ns, name);
Tejun Heof0b0af42007-06-14 04:27:22 +0900672 sysfs_get(sd);
Tejun Heo3007e992007-06-14 04:27:23 +0900673 mutex_unlock(&sysfs_mutex);
Tejun Heof0b0af42007-06-14 04:27:22 +0900674
675 return sd;
Maneesh Sonic5168652006-03-09 19:40:14 +0530676}
Neil Brownf1282c82008-07-16 08:58:04 +1000677EXPORT_SYMBOL_GPL(sysfs_get_dirent);
Maneesh Sonic5168652006-03-09 19:40:14 +0530678
Tejun Heo608e2662007-06-14 04:27:22 +0900679static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700680 enum kobj_ns_type type, const void *ns, const char *name,
681 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
Tejun Heo51225032007-06-14 04:27:25 +0900684 struct sysfs_addrm_cxt acxt;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900685 struct sysfs_dirent *sd;
Tejun Heo23dc2792007-08-02 21:38:03 +0900686 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Tejun Heofc9f54b2007-06-14 03:45:17 +0900688 /* allocate */
Tejun Heo3e519032007-06-14 03:45:15 +0900689 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
Tejun Heoa26cd722007-06-14 03:45:14 +0900690 if (!sd)
Tejun Heo51225032007-06-14 04:27:25 +0900691 return -ENOMEM;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700692
693 sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
694 sd->s_ns = ns;
Tejun Heob1fc3d62007-09-20 16:05:11 +0900695 sd->s_dir.kobj = kobj;
Tejun Heodfeb9fb2007-06-14 03:45:14 +0900696
Tejun Heo51225032007-06-14 04:27:25 +0900697 /* link in */
698 sysfs_addrm_start(&acxt, parent_sd);
Tejun Heo23dc2792007-08-02 21:38:03 +0900699 rc = sysfs_add_one(&acxt, sd);
700 sysfs_addrm_finish(&acxt);
Tejun Heo967e35d2007-07-18 16:38:11 +0900701
Tejun Heo23dc2792007-08-02 21:38:03 +0900702 if (rc == 0)
703 *p_sd = sd;
704 else
Tejun Heo967e35d2007-07-18 16:38:11 +0900705 sysfs_put(sd);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900706
Tejun Heo23dc2792007-08-02 21:38:03 +0900707 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708}
709
Tejun Heo608e2662007-06-14 04:27:22 +0900710int sysfs_create_subdir(struct kobject *kobj, const char *name,
711 struct sysfs_dirent **p_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700713 return create_dir(kobj, kobj->sd,
714 KOBJ_NS_TYPE_NONE, NULL, name, p_sd);
715}
716
Serge E. Hallynbe867b12010-05-03 16:23:15 -0500717/**
718 * sysfs_read_ns_type: return associated ns_type
719 * @kobj: the kobject being queried
720 *
721 * Each kobject can be tagged with exactly one namespace type
722 * (i.e. network or user). Return the ns_type associated with
723 * this object if any
724 */
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700725static enum kobj_ns_type sysfs_read_ns_type(struct kobject *kobj)
726{
727 const struct kobj_ns_type_operations *ops;
728 enum kobj_ns_type type;
729
730 ops = kobj_child_ns_ops(kobj);
731 if (!ops)
732 return KOBJ_NS_TYPE_NONE;
733
734 type = ops->type;
735 BUG_ON(type <= KOBJ_NS_TYPE_NONE);
736 BUG_ON(type >= KOBJ_NS_TYPES);
737 BUG_ON(!kobj_ns_type_registered(type));
738
739 return type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740}
741
742/**
743 * sysfs_create_dir - create a directory for an object.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 * @kobj: object we're creating directory for.
745 */
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900746int sysfs_create_dir(struct kobject * kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700748 enum kobj_ns_type type;
Tejun Heo608e2662007-06-14 04:27:22 +0900749 struct sysfs_dirent *parent_sd, *sd;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700750 const void *ns = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 int error = 0;
752
753 BUG_ON(!kobj);
754
Eric W. Biederman90bc6132007-07-31 19:15:08 +0900755 if (kobj->parent)
Tejun Heo608e2662007-06-14 04:27:22 +0900756 parent_sd = kobj->parent->sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 else
Eric W. Biederman7d0c7d62007-08-20 21:36:30 +0900758 parent_sd = &sysfs_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Dan Williams3a198882012-04-06 13:41:06 -0700760 if (!parent_sd)
761 return -ENOENT;
762
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700763 if (sysfs_ns_type(parent_sd))
764 ns = kobj->ktype->namespace(kobj);
765 type = sysfs_read_ns_type(kobj);
766
767 error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if (!error)
Tejun Heo608e2662007-06-14 04:27:22 +0900769 kobj->sd = sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 return error;
771}
772
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400774 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775{
Tejun Heo6cb52142007-07-31 19:15:08 +0900776 struct dentry *ret = NULL;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700777 struct dentry *parent = dentry->d_parent;
778 struct sysfs_dirent *parent_sd = parent->d_fsdata;
Tejun Heoa7a04752007-08-02 21:38:02 +0900779 struct sysfs_dirent *sd;
Tejun Heofc9f54b2007-06-14 03:45:17 +0900780 struct inode *inode;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700781 enum kobj_ns_type type;
782 const void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Tejun Heo6cb52142007-07-31 19:15:08 +0900784 mutex_lock(&sysfs_mutex);
785
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700786 type = sysfs_ns_type(parent_sd);
787 ns = sysfs_info(dir->i_sb)->ns[type];
788
789 sd = sysfs_find_dirent(parent_sd, ns, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Tejun Heofc9f54b2007-06-14 03:45:17 +0900791 /* no such entry */
Tejun Heoe49452c2008-01-16 12:06:14 +0900792 if (!sd) {
793 ret = ERR_PTR(-ENOENT);
Tejun Heo6cb52142007-07-31 19:15:08 +0900794 goto out_unlock;
Tejun Heoe49452c2008-01-16 12:06:14 +0900795 }
Al Viro469796d2012-06-07 20:51:39 -0400796 dentry->d_fsdata = sysfs_get(sd);
Tejun Heofc9f54b2007-06-14 03:45:17 +0900797
798 /* attach dentry and inode */
Eric W. Biedermanfac26222010-02-12 19:22:27 -0800799 inode = sysfs_get_inode(dir->i_sb, sd);
Tejun Heo6cb52142007-07-31 19:15:08 +0900800 if (!inode) {
801 ret = ERR_PTR(-ENOMEM);
802 goto out_unlock;
803 }
Tejun Heo3007e992007-06-14 04:27:23 +0900804
Tejun Heod6b4fd22007-09-20 16:05:11 +0900805 /* instantiate and hash dentry */
Al Viroe77fb7c2012-06-07 20:56:54 -0400806 ret = d_materialise_unique(dentry, inode);
Tejun Heo6cb52142007-07-31 19:15:08 +0900807 out_unlock:
Tejun Heo3007e992007-06-14 04:27:23 +0900808 mutex_unlock(&sysfs_mutex);
Tejun Heo6cb52142007-07-31 19:15:08 +0900809 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800812const struct inode_operations sysfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 .lookup = sysfs_lookup,
Eric W. Biedermane61ab4a2009-11-20 16:08:53 -0800814 .permission = sysfs_permission,
Maneesh Soni988d1862005-05-31 10:39:14 +0530815 .setattr = sysfs_setattr,
Eric W. Biedermane61ab4a2009-11-20 16:08:53 -0800816 .getattr = sysfs_getattr,
David P. Quigleyddd29ec2009-09-09 14:25:37 -0400817 .setxattr = sysfs_setxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818};
819
Tejun Heo608e2662007-06-14 04:27:22 +0900820static void remove_dir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821{
Tejun Heofb6896d2007-06-14 04:27:24 +0900822 struct sysfs_addrm_cxt acxt;
823
824 sysfs_addrm_start(&acxt, sd->s_parent);
Tejun Heofb6896d2007-06-14 04:27:24 +0900825 sysfs_remove_one(&acxt, sd);
826 sysfs_addrm_finish(&acxt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827}
828
Tejun Heo608e2662007-06-14 04:27:22 +0900829void sysfs_remove_subdir(struct sysfs_dirent *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830{
Tejun Heo608e2662007-06-14 04:27:22 +0900831 remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832}
833
834
Tejun Heo608e2662007-06-14 04:27:22 +0900835static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
Tejun Heofb6896d2007-06-14 04:27:24 +0900837 struct sysfs_addrm_cxt acxt;
Mikulas Patockaa406f752011-07-25 17:57:03 -0400838 struct rb_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Tejun Heo608e2662007-06-14 04:27:22 +0900840 if (!dir_sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return;
842
Tejun Heo608e2662007-06-14 04:27:22 +0900843 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
Tejun Heofb6896d2007-06-14 04:27:24 +0900844 sysfs_addrm_start(&acxt, dir_sd);
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800845 pos = rb_first(&dir_sd->s_dir.children);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400846 while (pos) {
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800847 struct sysfs_dirent *sd = to_sysfs_dirent(pos);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400848 pos = rb_next(pos);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +0900849 if (sysfs_type(sd) != SYSFS_DIR)
Tejun Heofb6896d2007-06-14 04:27:24 +0900850 sysfs_remove_one(&acxt, sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 }
Tejun Heofb6896d2007-06-14 04:27:24 +0900852 sysfs_addrm_finish(&acxt);
Tejun Heo0ab66082007-06-14 03:45:16 +0900853
Tejun Heo608e2662007-06-14 04:27:22 +0900854 remove_dir(dir_sd);
Eric W. Biedermanb592fcf2007-01-24 12:35:52 -0700855}
856
857/**
858 * sysfs_remove_dir - remove an object's directory.
859 * @kobj: object.
860 *
861 * The only thing special about this is that we remove any files in
862 * the directory before we remove the directory, and we've inlined
863 * what used to be sysfs_rmdir() below, instead of calling separately.
864 */
865
866void sysfs_remove_dir(struct kobject * kobj)
867{
Tejun Heo608e2662007-06-14 04:27:22 +0900868 struct sysfs_dirent *sd = kobj->sd;
Tejun Heoaecdced2007-06-14 03:45:15 +0900869
Tejun Heo5f995322007-06-14 04:27:23 +0900870 spin_lock(&sysfs_assoc_lock);
Tejun Heo608e2662007-06-14 04:27:22 +0900871 kobj->sd = NULL;
Tejun Heo5f995322007-06-14 04:27:23 +0900872 spin_unlock(&sysfs_assoc_lock);
Tejun Heoaecdced2007-06-14 03:45:15 +0900873
Tejun Heo608e2662007-06-14 04:27:22 +0900874 __sysfs_remove_dir(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875}
876
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800877int sysfs_rename(struct sysfs_dirent *sd,
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700878 struct sysfs_dirent *new_parent_sd, const void *new_ns,
879 const char *new_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
Tejun Heo996b7372007-06-14 03:45:14 +0900881 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800883 mutex_lock(&sysfs_mutex);
Eric W. Biederman932ea2e2007-08-20 21:36:30 +0900884
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900885 error = 0;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700886 if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800887 (strcmp(sd->s_name, new_name) == 0))
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900888 goto out; /* nothing to rename */
889
Tejun Heo996b7372007-06-14 03:45:14 +0900890 error = -EEXIST;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700891 if (sysfs_find_dirent(new_parent_sd, new_ns, new_name))
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800892 goto out;
Tejun Heo996b7372007-06-14 03:45:14 +0900893
Eric W. Biederman0b4a4fe2008-07-03 18:05:28 -0700894 /* rename sysfs_dirent */
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800895 if (strcmp(sd->s_name, new_name) != 0) {
896 error = -ENOMEM;
Sasikantha babub4eafca2012-05-03 02:26:14 +0530897 new_name = kstrdup(new_name, GFP_KERNEL);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800898 if (!new_name)
899 goto out;
Tejun Heo996b7372007-06-14 03:45:14 +0900900
Sasikantha babub4eafca2012-05-03 02:26:14 +0530901 kfree(sd->s_name);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800902 sd->s_name = new_name;
903 }
904
Eric W. Biedermanf6d90b42011-11-01 07:06:17 -0700905 /* Move to the appropriate place in the appropriate directories rbtree. */
906 sysfs_unlink_sibling(sd);
907 sysfs_get(new_parent_sd);
908 sysfs_put(sd->s_parent);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700909 sd->s_ns = new_ns;
Tom Goff70fa4a62012-04-04 12:06:20 -0700910 sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
Eric W. Biedermanf6d90b42011-11-01 07:06:17 -0700911 sd->s_parent = new_parent_sd;
912 sysfs_link_sibling(sd);
Tejun Heo0c096b52007-06-14 03:45:15 +0900913
Tejun Heo996b7372007-06-14 03:45:14 +0900914 error = 0;
Eric W. Biederman9918f9a2007-08-20 21:36:31 +0900915 out:
Eric W. Biederman832b6af2009-11-20 16:08:56 -0800916 mutex_unlock(&sysfs_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 return error;
918}
919
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800920int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
921{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700922 struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
923 const void *new_ns = NULL;
924
925 if (sysfs_ns_type(parent_sd))
926 new_ns = kobj->ktype->namespace(kobj);
927
928 return sysfs_rename(kobj->sd, parent_sd, new_ns, new_name);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800929}
930
Tejun Heo51225032007-06-14 04:27:25 +0900931int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
Cornelia Huck8a824722006-11-20 17:07:51 +0100932{
Tejun Heo51225032007-06-14 04:27:25 +0900933 struct sysfs_dirent *sd = kobj->sd;
934 struct sysfs_dirent *new_parent_sd;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700935 const void *new_ns = NULL;
Cornelia Huck8a824722006-11-20 17:07:51 +0100936
Tejun Heo51225032007-06-14 04:27:25 +0900937 BUG_ON(!sd->s_parent);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700938 if (sysfs_ns_type(sd->s_parent))
939 new_ns = kobj->ktype->namespace(kobj);
Eric W. Biedermanca1bab32009-11-20 16:08:57 -0800940 new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
Cornelia Hucka6a83572009-10-06 15:33:35 +0200941 new_parent_kobj->sd : &sysfs_root;
Cornelia Huck8a824722006-11-20 17:07:51 +0100942
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700943 return sysfs_rename(sd, new_parent_sd, new_ns, sd->s_name);
Cornelia Huck8a824722006-11-20 17:07:51 +0100944}
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946/* Relationship between s_mode and the DT_xxx types */
947static inline unsigned char dt_type(struct sysfs_dirent *sd)
948{
949 return (sd->s_mode >> 12) & 15;
950}
951
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800952static int sysfs_dir_release(struct inode *inode, struct file *filp)
953{
954 sysfs_put(filp->private_data);
955 return 0;
956}
957
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700958static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800959 struct sysfs_dirent *parent_sd, loff_t hash, struct sysfs_dirent *pos)
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800960{
961 if (pos) {
962 int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
963 pos->s_parent == parent_sd &&
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800964 hash == pos->s_hash;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800965 sysfs_put(pos);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700966 if (!valid)
967 pos = NULL;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800968 }
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800969 if (!pos && (hash > 1) && (hash < INT_MAX)) {
970 struct rb_node *node = parent_sd->s_dir.children.rb_node;
971 while (node) {
972 pos = to_sysfs_dirent(node);
973
974 if (hash < pos->s_hash)
975 node = node->rb_left;
976 else if (hash > pos->s_hash)
977 node = node->rb_right;
978 else
Mikulas Patockaa406f752011-07-25 17:57:03 -0400979 break;
Mikulas Patockaa406f752011-07-25 17:57:03 -0400980 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800981 }
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800982 /* Skip over entries in the wrong namespace */
Eric W. Biedermanb9e2780d2011-10-25 05:38:41 -0700983 while (pos && pos->s_ns != ns) {
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800984 struct rb_node *node = rb_next(&pos->s_rb);
985 if (!node)
Mikulas Patockaa406f752011-07-25 17:57:03 -0400986 pos = NULL;
987 else
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800988 pos = to_sysfs_dirent(node);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400989 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800990 return pos;
991}
992
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700993static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
994 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
Eric W. Biederman1e5289c2010-01-01 14:43:53 -0800995{
Eric W. Biederman3ff195b2010-03-30 11:31:26 -0700996 pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
Mikulas Patockaa406f752011-07-25 17:57:03 -0400997 if (pos) do {
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -0800998 struct rb_node *node = rb_next(&pos->s_rb);
999 if (!node)
Mikulas Patockaa406f752011-07-25 17:57:03 -04001000 pos = NULL;
1001 else
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -08001002 pos = to_sysfs_dirent(node);
Eric W. Biedermanb9e2780d2011-10-25 05:38:41 -07001003 } while (pos && pos->s_ns != ns);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001004 return pos;
1005}
1006
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
1008{
Josef "Jeff" Sipekf427f5d2006-12-08 02:36:36 -08001009 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001011 struct sysfs_dirent *pos = filp->private_data;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -07001012 enum kobj_ns_type type;
1013 const void *ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 ino_t ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Eric W. Biederman3ff195b2010-03-30 11:31:26 -07001016 type = sysfs_ns_type(parent_sd);
1017 ns = sysfs_info(dentry->d_sb)->ns[type];
1018
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001019 if (filp->f_pos == 0) {
1020 ino = parent_sd->s_ino;
1021 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
1022 filp->f_pos++;
1023 }
1024 if (filp->f_pos == 1) {
1025 if (parent_sd->s_parent)
1026 ino = parent_sd->s_parent->s_ino;
1027 else
Eric Sandeendc351252007-06-11 14:02:45 +09001028 ino = parent_sd->s_ino;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001029 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 filp->f_pos++;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001031 }
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001032 mutex_lock(&sysfs_mutex);
Eric W. Biederman3ff195b2010-03-30 11:31:26 -07001033 for (pos = sysfs_dir_pos(ns, parent_sd, filp->f_pos, pos);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001034 pos;
Eric W. Biederman3ff195b2010-03-30 11:31:26 -07001035 pos = sysfs_dir_next_pos(ns, parent_sd, filp->f_pos, pos)) {
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001036 const char * name;
1037 unsigned int type;
1038 int len, ret;
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001039
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001040 name = pos->s_name;
1041 len = strlen(name);
1042 ino = pos->s_ino;
1043 type = dt_type(pos);
Eric W. Biederman4e4d6d82011-12-18 20:05:43 -08001044 filp->f_pos = pos->s_hash;
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001045 filp->private_data = sysfs_get(pos);
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001046
Eric W. Biederman3efa65b2007-08-20 21:36:30 +09001047 mutex_unlock(&sysfs_mutex);
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001048 ret = filldir(dirent, name, len, filp->f_pos, ino, type);
1049 mutex_lock(&sysfs_mutex);
1050 if (ret < 0)
1051 break;
1052 }
1053 mutex_unlock(&sysfs_mutex);
1054 if ((filp->f_pos > 1) && !pos) { /* EOF */
1055 filp->f_pos = INT_MAX;
1056 filp->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 }
1058 return 0;
1059}
1060
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001062const struct file_operations sysfs_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 .read = generic_read_dir,
1064 .readdir = sysfs_readdir,
Eric W. Biederman1e5289c2010-01-01 14:43:53 -08001065 .release = sysfs_dir_release,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +02001066 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067};