KVM: Ensure all vcpus are consistent with in-kernel irqchip settings
[zen-stable.git] / fs / sysfs / dir.c
blob7fdf6a7b743663fe44a78ea12f9c9ec30eecfe5b
1 /*
2 * fs/sysfs/dir.c - sysfs core and dir operation implementation
4 * Copyright (c) 2001-3 Patrick Mochel
5 * Copyright (c) 2007 SUSE Linux Products GmbH
6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
8 * This file is released under the GPLv2.
10 * Please see Documentation/filesystems/sysfs.txt for more information.
13 #undef DEBUG
15 #include <linux/fs.h>
16 #include <linux/mount.h>
17 #include <linux/module.h>
18 #include <linux/kobject.h>
19 #include <linux/namei.h>
20 #include <linux/idr.h>
21 #include <linux/completion.h>
22 #include <linux/mutex.h>
23 #include <linux/slab.h>
24 #include <linux/security.h>
25 #include "sysfs.h"
27 DEFINE_MUTEX(sysfs_mutex);
28 DEFINE_SPINLOCK(sysfs_assoc_lock);
30 static DEFINE_SPINLOCK(sysfs_ino_lock);
31 static DEFINE_IDA(sysfs_ino_ida);
33 /**
34 * sysfs_link_sibling - link sysfs_dirent into sibling list
35 * @sd: sysfs_dirent of interest
37 * Link @sd into its sibling list which starts from
38 * sd->s_parent->s_dir.children.
40 * Locking:
41 * mutex_lock(sysfs_mutex)
43 static void sysfs_link_sibling(struct sysfs_dirent *sd)
45 struct sysfs_dirent *parent_sd = sd->s_parent;
47 struct rb_node **p;
48 struct rb_node *parent;
50 if (sysfs_type(sd) == SYSFS_DIR)
51 parent_sd->s_dir.subdirs++;
53 p = &parent_sd->s_dir.inode_tree.rb_node;
54 parent = NULL;
55 while (*p) {
56 parent = *p;
57 #define node rb_entry(parent, struct sysfs_dirent, inode_node)
58 if (sd->s_ino < node->s_ino) {
59 p = &node->inode_node.rb_left;
60 } else if (sd->s_ino > node->s_ino) {
61 p = &node->inode_node.rb_right;
62 } else {
63 printk(KERN_CRIT "sysfs: inserting duplicate inode '%lx'\n",
64 (unsigned long) sd->s_ino);
65 BUG();
67 #undef node
69 rb_link_node(&sd->inode_node, parent, p);
70 rb_insert_color(&sd->inode_node, &parent_sd->s_dir.inode_tree);
72 p = &parent_sd->s_dir.name_tree.rb_node;
73 parent = NULL;
74 while (*p) {
75 int c;
76 parent = *p;
77 #define node rb_entry(parent, struct sysfs_dirent, name_node)
78 c = strcmp(sd->s_name, node->s_name);
79 if (c < 0) {
80 p = &node->name_node.rb_left;
81 } else {
82 p = &node->name_node.rb_right;
84 #undef node
86 rb_link_node(&sd->name_node, parent, p);
87 rb_insert_color(&sd->name_node, &parent_sd->s_dir.name_tree);
90 /**
91 * sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
92 * @sd: sysfs_dirent of interest
94 * Unlink @sd from its sibling list which starts from
95 * sd->s_parent->s_dir.children.
97 * Locking:
98 * mutex_lock(sysfs_mutex)
100 static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
102 if (sysfs_type(sd) == SYSFS_DIR)
103 sd->s_parent->s_dir.subdirs--;
105 rb_erase(&sd->inode_node, &sd->s_parent->s_dir.inode_tree);
106 rb_erase(&sd->name_node, &sd->s_parent->s_dir.name_tree);
110 * sysfs_get_active - get an active reference to sysfs_dirent
111 * @sd: sysfs_dirent to get an active reference to
113 * Get an active reference of @sd. This function is noop if @sd
114 * is NULL.
116 * RETURNS:
117 * Pointer to @sd on success, NULL on failure.
119 struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
121 if (unlikely(!sd))
122 return NULL;
124 while (1) {
125 int v, t;
127 v = atomic_read(&sd->s_active);
128 if (unlikely(v < 0))
129 return NULL;
131 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
132 if (likely(t == v)) {
133 rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
134 return sd;
136 if (t < 0)
137 return NULL;
139 cpu_relax();
144 * sysfs_put_active - put an active reference to sysfs_dirent
145 * @sd: sysfs_dirent to put an active reference to
147 * Put an active reference to @sd. This function is noop if @sd
148 * is NULL.
150 void sysfs_put_active(struct sysfs_dirent *sd)
152 int v;
154 if (unlikely(!sd))
155 return;
157 rwsem_release(&sd->dep_map, 1, _RET_IP_);
158 v = atomic_dec_return(&sd->s_active);
159 if (likely(v != SD_DEACTIVATED_BIAS))
160 return;
162 /* atomic_dec_return() is a mb(), we'll always see the updated
163 * sd->u.completion.
165 complete(sd->u.completion);
169 * sysfs_deactivate - deactivate sysfs_dirent
170 * @sd: sysfs_dirent to deactivate
172 * Deny new active references and drain existing ones.
174 static void sysfs_deactivate(struct sysfs_dirent *sd)
176 DECLARE_COMPLETION_ONSTACK(wait);
177 int v;
179 BUG_ON(!(sd->s_flags & SYSFS_FLAG_REMOVED));
181 if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
182 return;
184 sd->u.completion = (void *)&wait;
186 rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
187 /* atomic_add_return() is a mb(), put_active() will always see
188 * the updated sd->u.completion.
190 v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
192 if (v != SD_DEACTIVATED_BIAS) {
193 lock_contended(&sd->dep_map, _RET_IP_);
194 wait_for_completion(&wait);
197 lock_acquired(&sd->dep_map, _RET_IP_);
198 rwsem_release(&sd->dep_map, 1, _RET_IP_);
201 static int sysfs_alloc_ino(ino_t *pino)
203 int ino, rc;
205 retry:
206 spin_lock(&sysfs_ino_lock);
207 rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
208 spin_unlock(&sysfs_ino_lock);
210 if (rc == -EAGAIN) {
211 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
212 goto retry;
213 rc = -ENOMEM;
216 *pino = ino;
217 return rc;
220 static void sysfs_free_ino(ino_t ino)
222 spin_lock(&sysfs_ino_lock);
223 ida_remove(&sysfs_ino_ida, ino);
224 spin_unlock(&sysfs_ino_lock);
227 void release_sysfs_dirent(struct sysfs_dirent * sd)
229 struct sysfs_dirent *parent_sd;
231 repeat:
232 /* Moving/renaming is always done while holding reference.
233 * sd->s_parent won't change beneath us.
235 parent_sd = sd->s_parent;
237 if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
238 sysfs_put(sd->s_symlink.target_sd);
239 if (sysfs_type(sd) & SYSFS_COPY_NAME)
240 kfree(sd->s_name);
241 if (sd->s_iattr && sd->s_iattr->ia_secdata)
242 security_release_secctx(sd->s_iattr->ia_secdata,
243 sd->s_iattr->ia_secdata_len);
244 kfree(sd->s_iattr);
245 sysfs_free_ino(sd->s_ino);
246 kmem_cache_free(sysfs_dir_cachep, sd);
248 sd = parent_sd;
249 if (sd && atomic_dec_and_test(&sd->s_count))
250 goto repeat;
253 static int sysfs_dentry_delete(const struct dentry *dentry)
255 struct sysfs_dirent *sd = dentry->d_fsdata;
256 return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
259 static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
261 struct sysfs_dirent *sd;
262 int is_dir;
264 if (nd->flags & LOOKUP_RCU)
265 return -ECHILD;
267 sd = dentry->d_fsdata;
268 mutex_lock(&sysfs_mutex);
270 /* The sysfs dirent has been deleted */
271 if (sd->s_flags & SYSFS_FLAG_REMOVED)
272 goto out_bad;
274 /* The sysfs dirent has been moved? */
275 if (dentry->d_parent->d_fsdata != sd->s_parent)
276 goto out_bad;
278 /* The sysfs dirent has been renamed */
279 if (strcmp(dentry->d_name.name, sd->s_name) != 0)
280 goto out_bad;
282 mutex_unlock(&sysfs_mutex);
283 out_valid:
284 return 1;
285 out_bad:
286 /* Remove the dentry from the dcache hashes.
287 * If this is a deleted dentry we use d_drop instead of d_delete
288 * so sysfs doesn't need to cope with negative dentries.
290 * If this is a dentry that has simply been renamed we
291 * use d_drop to remove it from the dcache lookup on its
292 * old parent. If this dentry persists later when a lookup
293 * is performed at its new name the dentry will be readded
294 * to the dcache hashes.
296 is_dir = (sysfs_type(sd) == SYSFS_DIR);
297 mutex_unlock(&sysfs_mutex);
298 if (is_dir) {
299 /* If we have submounts we must allow the vfs caches
300 * to lie about the state of the filesystem to prevent
301 * leaks and other nasty things.
303 if (have_submounts(dentry))
304 goto out_valid;
305 shrink_dcache_parent(dentry);
307 d_drop(dentry);
308 return 0;
311 static void sysfs_dentry_iput(struct dentry *dentry, struct inode *inode)
313 struct sysfs_dirent * sd = dentry->d_fsdata;
315 sysfs_put(sd);
316 iput(inode);
319 static const struct dentry_operations sysfs_dentry_ops = {
320 .d_revalidate = sysfs_dentry_revalidate,
321 .d_delete = sysfs_dentry_delete,
322 .d_iput = sysfs_dentry_iput,
325 struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
327 char *dup_name = NULL;
328 struct sysfs_dirent *sd;
330 if (type & SYSFS_COPY_NAME) {
331 name = dup_name = kstrdup(name, GFP_KERNEL);
332 if (!name)
333 return NULL;
336 sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
337 if (!sd)
338 goto err_out1;
340 if (sysfs_alloc_ino(&sd->s_ino))
341 goto err_out2;
343 atomic_set(&sd->s_count, 1);
344 atomic_set(&sd->s_active, 0);
346 sd->s_name = name;
347 sd->s_mode = mode;
348 sd->s_flags = type;
350 return sd;
352 err_out2:
353 kmem_cache_free(sysfs_dir_cachep, sd);
354 err_out1:
355 kfree(dup_name);
356 return NULL;
360 * sysfs_addrm_start - prepare for sysfs_dirent add/remove
361 * @acxt: pointer to sysfs_addrm_cxt to be used
362 * @parent_sd: parent sysfs_dirent
364 * This function is called when the caller is about to add or
365 * remove sysfs_dirent under @parent_sd. This function acquires
366 * sysfs_mutex. @acxt is used to keep and pass context to
367 * other addrm functions.
369 * LOCKING:
370 * Kernel thread context (may sleep). sysfs_mutex is locked on
371 * return.
373 void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
374 struct sysfs_dirent *parent_sd)
376 memset(acxt, 0, sizeof(*acxt));
377 acxt->parent_sd = parent_sd;
379 mutex_lock(&sysfs_mutex);
383 * __sysfs_add_one - add sysfs_dirent to parent without warning
384 * @acxt: addrm context to use
385 * @sd: sysfs_dirent to be added
387 * Get @acxt->parent_sd and set sd->s_parent to it and increment
388 * nlink of parent inode if @sd is a directory and link into the
389 * children list of the parent.
391 * This function should be called between calls to
392 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
393 * passed the same @acxt as passed to sysfs_addrm_start().
395 * LOCKING:
396 * Determined by sysfs_addrm_start().
398 * RETURNS:
399 * 0 on success, -EEXIST if entry with the given name already
400 * exists.
402 int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
404 struct sysfs_inode_attrs *ps_iattr;
406 if (!!sysfs_ns_type(acxt->parent_sd) != !!sd->s_ns) {
407 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
408 sysfs_ns_type(acxt->parent_sd)? "required": "invalid",
409 acxt->parent_sd->s_name, sd->s_name);
410 return -EINVAL;
413 if (sysfs_find_dirent(acxt->parent_sd, sd->s_ns, sd->s_name))
414 return -EEXIST;
416 sd->s_parent = sysfs_get(acxt->parent_sd);
418 sysfs_link_sibling(sd);
420 /* Update timestamps on the parent */
421 ps_iattr = acxt->parent_sd->s_iattr;
422 if (ps_iattr) {
423 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
424 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
427 return 0;
431 * sysfs_pathname - return full path to sysfs dirent
432 * @sd: sysfs_dirent whose path we want
433 * @path: caller allocated buffer
435 * Gives the name "/" to the sysfs_root entry; any path returned
436 * is relative to wherever sysfs is mounted.
438 * XXX: does no error checking on @path size
440 static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
442 if (sd->s_parent) {
443 sysfs_pathname(sd->s_parent, path);
444 strcat(path, "/");
446 strcat(path, sd->s_name);
447 return path;
451 * sysfs_add_one - add sysfs_dirent to parent
452 * @acxt: addrm context to use
453 * @sd: sysfs_dirent to be added
455 * Get @acxt->parent_sd and set sd->s_parent to it and increment
456 * nlink of parent inode if @sd is a directory and link into the
457 * children list of the parent.
459 * This function should be called between calls to
460 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
461 * passed the same @acxt as passed to sysfs_addrm_start().
463 * LOCKING:
464 * Determined by sysfs_addrm_start().
466 * RETURNS:
467 * 0 on success, -EEXIST if entry with the given name already
468 * exists.
470 int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
472 int ret;
474 ret = __sysfs_add_one(acxt, sd);
475 if (ret == -EEXIST) {
476 char *path = kzalloc(PATH_MAX, GFP_KERNEL);
477 WARN(1, KERN_WARNING
478 "sysfs: cannot create duplicate filename '%s'\n",
479 (path == NULL) ? sd->s_name :
480 strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
481 sd->s_name));
482 kfree(path);
485 return ret;
489 * sysfs_remove_one - remove sysfs_dirent from parent
490 * @acxt: addrm context to use
491 * @sd: sysfs_dirent to be removed
493 * Mark @sd removed and drop nlink of parent inode if @sd is a
494 * directory. @sd is unlinked from the children list.
496 * This function should be called between calls to
497 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
498 * passed the same @acxt as passed to sysfs_addrm_start().
500 * LOCKING:
501 * Determined by sysfs_addrm_start().
503 void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
505 struct sysfs_inode_attrs *ps_iattr;
507 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
509 sysfs_unlink_sibling(sd);
511 /* Update timestamps on the parent */
512 ps_iattr = acxt->parent_sd->s_iattr;
513 if (ps_iattr) {
514 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
515 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
518 sd->s_flags |= SYSFS_FLAG_REMOVED;
519 sd->u.removed_list = acxt->removed;
520 acxt->removed = sd;
524 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
525 * @acxt: addrm context to finish up
527 * Finish up sysfs_dirent add/remove. Resources acquired by
528 * sysfs_addrm_start() are released and removed sysfs_dirents are
529 * cleaned up.
531 * LOCKING:
532 * sysfs_mutex is released.
534 void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
536 /* release resources acquired by sysfs_addrm_start() */
537 mutex_unlock(&sysfs_mutex);
539 /* kill removed sysfs_dirents */
540 while (acxt->removed) {
541 struct sysfs_dirent *sd = acxt->removed;
543 acxt->removed = sd->u.removed_list;
545 sysfs_deactivate(sd);
546 unmap_bin_file(sd);
547 sysfs_put(sd);
552 * sysfs_find_dirent - find sysfs_dirent with the given name
553 * @parent_sd: sysfs_dirent to search under
554 * @name: name to look for
556 * Look for sysfs_dirent with name @name under @parent_sd.
558 * LOCKING:
559 * mutex_lock(sysfs_mutex)
561 * RETURNS:
562 * Pointer to sysfs_dirent if found, NULL if not.
564 struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
565 const void *ns,
566 const unsigned char *name)
568 struct rb_node *p = parent_sd->s_dir.name_tree.rb_node;
569 struct sysfs_dirent *found = NULL;
571 if (!!sysfs_ns_type(parent_sd) != !!ns) {
572 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
573 sysfs_ns_type(parent_sd)? "required": "invalid",
574 parent_sd->s_name, name);
575 return NULL;
578 while (p) {
579 int c;
580 #define node rb_entry(p, struct sysfs_dirent, name_node)
581 c = strcmp(name, node->s_name);
582 if (c < 0) {
583 p = node->name_node.rb_left;
584 } else if (c > 0) {
585 p = node->name_node.rb_right;
586 } else {
587 found = node;
588 p = node->name_node.rb_left;
590 #undef node
593 if (found) {
594 while (found->s_ns != ns) {
595 p = rb_next(&found->name_node);
596 if (!p)
597 return NULL;
598 found = rb_entry(p, struct sysfs_dirent, name_node);
599 if (strcmp(name, found->s_name))
600 return NULL;
604 return found;
608 * sysfs_get_dirent - find and get sysfs_dirent with the given name
609 * @parent_sd: sysfs_dirent to search under
610 * @name: name to look for
612 * Look for sysfs_dirent with name @name under @parent_sd and get
613 * it if found.
615 * LOCKING:
616 * Kernel thread context (may sleep). Grabs sysfs_mutex.
618 * RETURNS:
619 * Pointer to sysfs_dirent if found, NULL if not.
621 struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
622 const void *ns,
623 const unsigned char *name)
625 struct sysfs_dirent *sd;
627 mutex_lock(&sysfs_mutex);
628 sd = sysfs_find_dirent(parent_sd, ns, name);
629 sysfs_get(sd);
630 mutex_unlock(&sysfs_mutex);
632 return sd;
634 EXPORT_SYMBOL_GPL(sysfs_get_dirent);
636 static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
637 enum kobj_ns_type type, const void *ns, const char *name,
638 struct sysfs_dirent **p_sd)
640 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
641 struct sysfs_addrm_cxt acxt;
642 struct sysfs_dirent *sd;
643 int rc;
645 /* allocate */
646 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
647 if (!sd)
648 return -ENOMEM;
650 sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
651 sd->s_ns = ns;
652 sd->s_dir.kobj = kobj;
654 /* link in */
655 sysfs_addrm_start(&acxt, parent_sd);
656 rc = sysfs_add_one(&acxt, sd);
657 sysfs_addrm_finish(&acxt);
659 if (rc == 0)
660 *p_sd = sd;
661 else
662 sysfs_put(sd);
664 return rc;
667 int sysfs_create_subdir(struct kobject *kobj, const char *name,
668 struct sysfs_dirent **p_sd)
670 return create_dir(kobj, kobj->sd,
671 KOBJ_NS_TYPE_NONE, NULL, name, p_sd);
675 * sysfs_read_ns_type: return associated ns_type
676 * @kobj: the kobject being queried
678 * Each kobject can be tagged with exactly one namespace type
679 * (i.e. network or user). Return the ns_type associated with
680 * this object if any
682 static enum kobj_ns_type sysfs_read_ns_type(struct kobject *kobj)
684 const struct kobj_ns_type_operations *ops;
685 enum kobj_ns_type type;
687 ops = kobj_child_ns_ops(kobj);
688 if (!ops)
689 return KOBJ_NS_TYPE_NONE;
691 type = ops->type;
692 BUG_ON(type <= KOBJ_NS_TYPE_NONE);
693 BUG_ON(type >= KOBJ_NS_TYPES);
694 BUG_ON(!kobj_ns_type_registered(type));
696 return type;
700 * sysfs_create_dir - create a directory for an object.
701 * @kobj: object we're creating directory for.
703 int sysfs_create_dir(struct kobject * kobj)
705 enum kobj_ns_type type;
706 struct sysfs_dirent *parent_sd, *sd;
707 const void *ns = NULL;
708 int error = 0;
710 BUG_ON(!kobj);
712 if (kobj->parent)
713 parent_sd = kobj->parent->sd;
714 else
715 parent_sd = &sysfs_root;
717 if (sysfs_ns_type(parent_sd))
718 ns = kobj->ktype->namespace(kobj);
719 type = sysfs_read_ns_type(kobj);
721 error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
722 if (!error)
723 kobj->sd = sd;
724 return error;
727 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
728 struct nameidata *nd)
730 struct dentry *ret = NULL;
731 struct dentry *parent = dentry->d_parent;
732 struct sysfs_dirent *parent_sd = parent->d_fsdata;
733 struct sysfs_dirent *sd;
734 struct inode *inode;
735 enum kobj_ns_type type;
736 const void *ns;
738 mutex_lock(&sysfs_mutex);
740 type = sysfs_ns_type(parent_sd);
741 ns = sysfs_info(dir->i_sb)->ns[type];
743 sd = sysfs_find_dirent(parent_sd, ns, dentry->d_name.name);
745 /* no such entry */
746 if (!sd) {
747 ret = ERR_PTR(-ENOENT);
748 goto out_unlock;
751 /* attach dentry and inode */
752 inode = sysfs_get_inode(dir->i_sb, sd);
753 if (!inode) {
754 ret = ERR_PTR(-ENOMEM);
755 goto out_unlock;
758 /* instantiate and hash dentry */
759 ret = d_find_alias(inode);
760 if (!ret) {
761 d_set_d_op(dentry, &sysfs_dentry_ops);
762 dentry->d_fsdata = sysfs_get(sd);
763 d_add(dentry, inode);
764 } else {
765 d_move(ret, dentry);
766 iput(inode);
769 out_unlock:
770 mutex_unlock(&sysfs_mutex);
771 return ret;
774 const struct inode_operations sysfs_dir_inode_operations = {
775 .lookup = sysfs_lookup,
776 .permission = sysfs_permission,
777 .setattr = sysfs_setattr,
778 .getattr = sysfs_getattr,
779 .setxattr = sysfs_setxattr,
782 static void remove_dir(struct sysfs_dirent *sd)
784 struct sysfs_addrm_cxt acxt;
786 sysfs_addrm_start(&acxt, sd->s_parent);
787 sysfs_remove_one(&acxt, sd);
788 sysfs_addrm_finish(&acxt);
791 void sysfs_remove_subdir(struct sysfs_dirent *sd)
793 remove_dir(sd);
797 static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
799 struct sysfs_addrm_cxt acxt;
800 struct rb_node *pos;
802 if (!dir_sd)
803 return;
805 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
806 sysfs_addrm_start(&acxt, dir_sd);
807 pos = rb_first(&dir_sd->s_dir.inode_tree);
808 while (pos) {
809 struct sysfs_dirent *sd = rb_entry(pos, struct sysfs_dirent, inode_node);
810 pos = rb_next(pos);
811 if (sysfs_type(sd) != SYSFS_DIR)
812 sysfs_remove_one(&acxt, sd);
814 sysfs_addrm_finish(&acxt);
816 remove_dir(dir_sd);
820 * sysfs_remove_dir - remove an object's directory.
821 * @kobj: object.
823 * The only thing special about this is that we remove any files in
824 * the directory before we remove the directory, and we've inlined
825 * what used to be sysfs_rmdir() below, instead of calling separately.
828 void sysfs_remove_dir(struct kobject * kobj)
830 struct sysfs_dirent *sd = kobj->sd;
832 spin_lock(&sysfs_assoc_lock);
833 kobj->sd = NULL;
834 spin_unlock(&sysfs_assoc_lock);
836 __sysfs_remove_dir(sd);
839 int sysfs_rename(struct sysfs_dirent *sd,
840 struct sysfs_dirent *new_parent_sd, const void *new_ns,
841 const char *new_name)
843 const char *dup_name = NULL;
844 int error;
846 mutex_lock(&sysfs_mutex);
848 error = 0;
849 if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
850 (strcmp(sd->s_name, new_name) == 0))
851 goto out; /* nothing to rename */
853 error = -EEXIST;
854 if (sysfs_find_dirent(new_parent_sd, new_ns, new_name))
855 goto out;
857 /* rename sysfs_dirent */
858 if (strcmp(sd->s_name, new_name) != 0) {
859 error = -ENOMEM;
860 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
861 if (!new_name)
862 goto out;
864 dup_name = sd->s_name;
865 sd->s_name = new_name;
868 /* Move to the appropriate place in the appropriate directories rbtree. */
869 sysfs_unlink_sibling(sd);
870 sysfs_get(new_parent_sd);
871 sysfs_put(sd->s_parent);
872 sd->s_ns = new_ns;
873 sd->s_parent = new_parent_sd;
874 sysfs_link_sibling(sd);
876 error = 0;
877 out:
878 mutex_unlock(&sysfs_mutex);
879 kfree(dup_name);
880 return error;
883 int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
885 struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
886 const void *new_ns = NULL;
888 if (sysfs_ns_type(parent_sd))
889 new_ns = kobj->ktype->namespace(kobj);
891 return sysfs_rename(kobj->sd, parent_sd, new_ns, new_name);
894 int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
896 struct sysfs_dirent *sd = kobj->sd;
897 struct sysfs_dirent *new_parent_sd;
898 const void *new_ns = NULL;
900 BUG_ON(!sd->s_parent);
901 if (sysfs_ns_type(sd->s_parent))
902 new_ns = kobj->ktype->namespace(kobj);
903 new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
904 new_parent_kobj->sd : &sysfs_root;
906 return sysfs_rename(sd, new_parent_sd, new_ns, sd->s_name);
909 /* Relationship between s_mode and the DT_xxx types */
910 static inline unsigned char dt_type(struct sysfs_dirent *sd)
912 return (sd->s_mode >> 12) & 15;
915 static int sysfs_dir_release(struct inode *inode, struct file *filp)
917 sysfs_put(filp->private_data);
918 return 0;
921 static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
922 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
924 if (pos) {
925 int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
926 pos->s_parent == parent_sd &&
927 ino == pos->s_ino;
928 sysfs_put(pos);
929 if (!valid)
930 pos = NULL;
932 if (!pos && (ino > 1) && (ino < INT_MAX)) {
933 struct rb_node *p = parent_sd->s_dir.inode_tree.rb_node;
934 while (p) {
935 #define node rb_entry(p, struct sysfs_dirent, inode_node)
936 if (ino < node->s_ino) {
937 pos = node;
938 p = node->inode_node.rb_left;
939 } else if (ino > node->s_ino) {
940 p = node->inode_node.rb_right;
941 } else {
942 pos = node;
943 break;
945 #undef node
948 while (pos && pos->s_ns != ns) {
949 struct rb_node *p = rb_next(&pos->inode_node);
950 if (!p)
951 pos = NULL;
952 else
953 pos = rb_entry(p, struct sysfs_dirent, inode_node);
955 return pos;
958 static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
959 struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
961 pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
962 if (pos) do {
963 struct rb_node *p = rb_next(&pos->inode_node);
964 if (!p)
965 pos = NULL;
966 else
967 pos = rb_entry(p, struct sysfs_dirent, inode_node);
968 } while (pos && pos->s_ns != ns);
969 return pos;
972 static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
974 struct dentry *dentry = filp->f_path.dentry;
975 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
976 struct sysfs_dirent *pos = filp->private_data;
977 enum kobj_ns_type type;
978 const void *ns;
979 ino_t ino;
981 type = sysfs_ns_type(parent_sd);
982 ns = sysfs_info(dentry->d_sb)->ns[type];
984 if (filp->f_pos == 0) {
985 ino = parent_sd->s_ino;
986 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
987 filp->f_pos++;
989 if (filp->f_pos == 1) {
990 if (parent_sd->s_parent)
991 ino = parent_sd->s_parent->s_ino;
992 else
993 ino = parent_sd->s_ino;
994 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
995 filp->f_pos++;
997 mutex_lock(&sysfs_mutex);
998 for (pos = sysfs_dir_pos(ns, parent_sd, filp->f_pos, pos);
999 pos;
1000 pos = sysfs_dir_next_pos(ns, parent_sd, filp->f_pos, pos)) {
1001 const char * name;
1002 unsigned int type;
1003 int len, ret;
1005 name = pos->s_name;
1006 len = strlen(name);
1007 ino = pos->s_ino;
1008 type = dt_type(pos);
1009 filp->f_pos = ino;
1010 filp->private_data = sysfs_get(pos);
1012 mutex_unlock(&sysfs_mutex);
1013 ret = filldir(dirent, name, len, filp->f_pos, ino, type);
1014 mutex_lock(&sysfs_mutex);
1015 if (ret < 0)
1016 break;
1018 mutex_unlock(&sysfs_mutex);
1019 if ((filp->f_pos > 1) && !pos) { /* EOF */
1020 filp->f_pos = INT_MAX;
1021 filp->private_data = NULL;
1023 return 0;
1027 const struct file_operations sysfs_dir_operations = {
1028 .read = generic_read_dir,
1029 .readdir = sysfs_readdir,
1030 .release = sysfs_dir_release,
1031 .llseek = generic_file_llseek,