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.
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>
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
);
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.
41 * mutex_lock(sysfs_mutex)
43 static void sysfs_link_sibling(struct sysfs_dirent
*sd
)
45 struct sysfs_dirent
*parent_sd
= sd
->s_parent
;
46 struct sysfs_dirent
**pos
;
49 struct rb_node
*parent
;
51 BUG_ON(sd
->s_sibling
);
53 if (sysfs_type(sd
) == SYSFS_DIR
)
54 parent_sd
->s_dir
.subdirs
++;
56 /* Store directory entries in order by ino. This allows
57 * readdir to properly restart without having to add a
58 * cursor into the s_dir.children list.
60 for (pos
= &parent_sd
->s_dir
.children
; *pos
; pos
= &(*pos
)->s_sibling
) {
61 if (sd
->s_ino
< (*pos
)->s_ino
)
67 p
= &parent_sd
->s_dir
.name_tree
.rb_node
;
72 #define node rb_entry(parent, struct sysfs_dirent, name_node)
73 c
= strcmp(sd
->s_name
, node
->s_name
);
75 p
= &node
->name_node
.rb_left
;
77 p
= &node
->name_node
.rb_right
;
81 rb_link_node(&sd
->name_node
, parent
, p
);
82 rb_insert_color(&sd
->name_node
, &parent_sd
->s_dir
.name_tree
);
86 * sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
87 * @sd: sysfs_dirent of interest
89 * Unlink @sd from its sibling list which starts from
90 * sd->s_parent->s_dir.children.
93 * mutex_lock(sysfs_mutex)
95 static void sysfs_unlink_sibling(struct sysfs_dirent
*sd
)
97 struct sysfs_dirent
**pos
;
99 if (sysfs_type(sd
) == SYSFS_DIR
)
100 sd
->s_parent
->s_dir
.subdirs
--;
102 for (pos
= &sd
->s_parent
->s_dir
.children
; *pos
;
103 pos
= &(*pos
)->s_sibling
) {
105 *pos
= sd
->s_sibling
;
106 sd
->s_sibling
= NULL
;
111 rb_erase(&sd
->name_node
, &sd
->s_parent
->s_dir
.name_tree
);
115 * sysfs_get_active - get an active reference to sysfs_dirent
116 * @sd: sysfs_dirent to get an active reference to
118 * Get an active reference of @sd. This function is noop if @sd
122 * Pointer to @sd on success, NULL on failure.
124 struct sysfs_dirent
*sysfs_get_active(struct sysfs_dirent
*sd
)
132 v
= atomic_read(&sd
->s_active
);
136 t
= atomic_cmpxchg(&sd
->s_active
, v
, v
+ 1);
137 if (likely(t
== v
)) {
138 rwsem_acquire_read(&sd
->dep_map
, 0, 1, _RET_IP_
);
149 * sysfs_put_active - put an active reference to sysfs_dirent
150 * @sd: sysfs_dirent to put an active reference to
152 * Put an active reference to @sd. This function is noop if @sd
155 void sysfs_put_active(struct sysfs_dirent
*sd
)
162 rwsem_release(&sd
->dep_map
, 1, _RET_IP_
);
163 v
= atomic_dec_return(&sd
->s_active
);
164 if (likely(v
!= SD_DEACTIVATED_BIAS
))
167 /* atomic_dec_return() is a mb(), we'll always see the updated
170 complete(sd
->u
.completion
);
174 * sysfs_deactivate - deactivate sysfs_dirent
175 * @sd: sysfs_dirent to deactivate
177 * Deny new active references and drain existing ones.
179 static void sysfs_deactivate(struct sysfs_dirent
*sd
)
181 DECLARE_COMPLETION_ONSTACK(wait
);
184 BUG_ON(!(sd
->s_flags
& SYSFS_FLAG_REMOVED
));
186 if (!(sysfs_type(sd
) & SYSFS_ACTIVE_REF
))
189 sd
->u
.completion
= (void *)&wait
;
191 rwsem_acquire(&sd
->dep_map
, 0, 0, _RET_IP_
);
192 /* atomic_add_return() is a mb(), put_active() will always see
193 * the updated sd->u.completion.
195 v
= atomic_add_return(SD_DEACTIVATED_BIAS
, &sd
->s_active
);
197 if (v
!= SD_DEACTIVATED_BIAS
) {
198 lock_contended(&sd
->dep_map
, _RET_IP_
);
199 wait_for_completion(&wait
);
202 lock_acquired(&sd
->dep_map
, _RET_IP_
);
203 rwsem_release(&sd
->dep_map
, 1, _RET_IP_
);
206 static int sysfs_alloc_ino(ino_t
*pino
)
211 spin_lock(&sysfs_ino_lock
);
212 rc
= ida_get_new_above(&sysfs_ino_ida
, 2, &ino
);
213 spin_unlock(&sysfs_ino_lock
);
216 if (ida_pre_get(&sysfs_ino_ida
, GFP_KERNEL
))
225 static void sysfs_free_ino(ino_t ino
)
227 spin_lock(&sysfs_ino_lock
);
228 ida_remove(&sysfs_ino_ida
, ino
);
229 spin_unlock(&sysfs_ino_lock
);
232 void release_sysfs_dirent(struct sysfs_dirent
* sd
)
234 struct sysfs_dirent
*parent_sd
;
237 /* Moving/renaming is always done while holding reference.
238 * sd->s_parent won't change beneath us.
240 parent_sd
= sd
->s_parent
;
242 if (sysfs_type(sd
) == SYSFS_KOBJ_LINK
)
243 sysfs_put(sd
->s_symlink
.target_sd
);
244 if (sysfs_type(sd
) & SYSFS_COPY_NAME
)
246 if (sd
->s_iattr
&& sd
->s_iattr
->ia_secdata
)
247 security_release_secctx(sd
->s_iattr
->ia_secdata
,
248 sd
->s_iattr
->ia_secdata_len
);
250 sysfs_free_ino(sd
->s_ino
);
251 kmem_cache_free(sysfs_dir_cachep
, sd
);
254 if (sd
&& atomic_dec_and_test(&sd
->s_count
))
258 static int sysfs_dentry_delete(const struct dentry
*dentry
)
260 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
261 return !!(sd
->s_flags
& SYSFS_FLAG_REMOVED
);
264 static int sysfs_dentry_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
266 struct sysfs_dirent
*sd
;
269 if (nd
->flags
& LOOKUP_RCU
)
272 sd
= dentry
->d_fsdata
;
273 mutex_lock(&sysfs_mutex
);
275 /* The sysfs dirent has been deleted */
276 if (sd
->s_flags
& SYSFS_FLAG_REMOVED
)
279 /* The sysfs dirent has been moved? */
280 if (dentry
->d_parent
->d_fsdata
!= sd
->s_parent
)
283 /* The sysfs dirent has been renamed */
284 if (strcmp(dentry
->d_name
.name
, sd
->s_name
) != 0)
287 mutex_unlock(&sysfs_mutex
);
291 /* Remove the dentry from the dcache hashes.
292 * If this is a deleted dentry we use d_drop instead of d_delete
293 * so sysfs doesn't need to cope with negative dentries.
295 * If this is a dentry that has simply been renamed we
296 * use d_drop to remove it from the dcache lookup on its
297 * old parent. If this dentry persists later when a lookup
298 * is performed at its new name the dentry will be readded
299 * to the dcache hashes.
301 is_dir
= (sysfs_type(sd
) == SYSFS_DIR
);
302 mutex_unlock(&sysfs_mutex
);
304 /* If we have submounts we must allow the vfs caches
305 * to lie about the state of the filesystem to prevent
306 * leaks and other nasty things.
308 if (have_submounts(dentry
))
310 shrink_dcache_parent(dentry
);
316 static void sysfs_dentry_iput(struct dentry
*dentry
, struct inode
*inode
)
318 struct sysfs_dirent
* sd
= dentry
->d_fsdata
;
324 static const struct dentry_operations sysfs_dentry_ops
= {
325 .d_revalidate
= sysfs_dentry_revalidate
,
326 .d_delete
= sysfs_dentry_delete
,
327 .d_iput
= sysfs_dentry_iput
,
330 struct sysfs_dirent
*sysfs_new_dirent(const char *name
, umode_t mode
, int type
)
332 char *dup_name
= NULL
;
333 struct sysfs_dirent
*sd
;
335 if (type
& SYSFS_COPY_NAME
) {
336 name
= dup_name
= kstrdup(name
, GFP_KERNEL
);
341 sd
= kmem_cache_zalloc(sysfs_dir_cachep
, GFP_KERNEL
);
345 if (sysfs_alloc_ino(&sd
->s_ino
))
348 atomic_set(&sd
->s_count
, 1);
349 atomic_set(&sd
->s_active
, 0);
358 kmem_cache_free(sysfs_dir_cachep
, sd
);
365 * sysfs_addrm_start - prepare for sysfs_dirent add/remove
366 * @acxt: pointer to sysfs_addrm_cxt to be used
367 * @parent_sd: parent sysfs_dirent
369 * This function is called when the caller is about to add or
370 * remove sysfs_dirent under @parent_sd. This function acquires
371 * sysfs_mutex. @acxt is used to keep and pass context to
372 * other addrm functions.
375 * Kernel thread context (may sleep). sysfs_mutex is locked on
378 void sysfs_addrm_start(struct sysfs_addrm_cxt
*acxt
,
379 struct sysfs_dirent
*parent_sd
)
381 memset(acxt
, 0, sizeof(*acxt
));
382 acxt
->parent_sd
= parent_sd
;
384 mutex_lock(&sysfs_mutex
);
388 * __sysfs_add_one - add sysfs_dirent to parent without warning
389 * @acxt: addrm context to use
390 * @sd: sysfs_dirent to be added
392 * Get @acxt->parent_sd and set sd->s_parent to it and increment
393 * nlink of parent inode if @sd is a directory and link into the
394 * children list of the parent.
396 * This function should be called between calls to
397 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
398 * passed the same @acxt as passed to sysfs_addrm_start().
401 * Determined by sysfs_addrm_start().
404 * 0 on success, -EEXIST if entry with the given name already
407 int __sysfs_add_one(struct sysfs_addrm_cxt
*acxt
, struct sysfs_dirent
*sd
)
409 struct sysfs_inode_attrs
*ps_iattr
;
411 if (sysfs_find_dirent(acxt
->parent_sd
, sd
->s_ns
, sd
->s_name
))
414 sd
->s_parent
= sysfs_get(acxt
->parent_sd
);
416 sysfs_link_sibling(sd
);
418 /* Update timestamps on the parent */
419 ps_iattr
= acxt
->parent_sd
->s_iattr
;
421 struct iattr
*ps_iattrs
= &ps_iattr
->ia_iattr
;
422 ps_iattrs
->ia_ctime
= ps_iattrs
->ia_mtime
= CURRENT_TIME
;
429 * sysfs_pathname - return full path to sysfs dirent
430 * @sd: sysfs_dirent whose path we want
431 * @path: caller allocated buffer
433 * Gives the name "/" to the sysfs_root entry; any path returned
434 * is relative to wherever sysfs is mounted.
436 * XXX: does no error checking on @path size
438 static char *sysfs_pathname(struct sysfs_dirent
*sd
, char *path
)
441 sysfs_pathname(sd
->s_parent
, path
);
444 strcat(path
, sd
->s_name
);
449 * sysfs_add_one - add sysfs_dirent to parent
450 * @acxt: addrm context to use
451 * @sd: sysfs_dirent to be added
453 * Get @acxt->parent_sd and set sd->s_parent to it and increment
454 * nlink of parent inode if @sd is a directory and link into the
455 * children list of the parent.
457 * This function should be called between calls to
458 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
459 * passed the same @acxt as passed to sysfs_addrm_start().
462 * Determined by sysfs_addrm_start().
465 * 0 on success, -EEXIST if entry with the given name already
468 int sysfs_add_one(struct sysfs_addrm_cxt
*acxt
, struct sysfs_dirent
*sd
)
472 ret
= __sysfs_add_one(acxt
, sd
);
473 if (ret
== -EEXIST
) {
474 char *path
= kzalloc(PATH_MAX
, GFP_KERNEL
);
476 "sysfs: cannot create duplicate filename '%s'\n",
477 (path
== NULL
) ? sd
->s_name
:
478 strcat(strcat(sysfs_pathname(acxt
->parent_sd
, path
), "/"),
487 * sysfs_remove_one - remove sysfs_dirent from parent
488 * @acxt: addrm context to use
489 * @sd: sysfs_dirent to be removed
491 * Mark @sd removed and drop nlink of parent inode if @sd is a
492 * directory. @sd is unlinked from the children list.
494 * This function should be called between calls to
495 * sysfs_addrm_start() and sysfs_addrm_finish() and should be
496 * passed the same @acxt as passed to sysfs_addrm_start().
499 * Determined by sysfs_addrm_start().
501 void sysfs_remove_one(struct sysfs_addrm_cxt
*acxt
, struct sysfs_dirent
*sd
)
503 struct sysfs_inode_attrs
*ps_iattr
;
505 BUG_ON(sd
->s_flags
& SYSFS_FLAG_REMOVED
);
507 sysfs_unlink_sibling(sd
);
509 /* Update timestamps on the parent */
510 ps_iattr
= acxt
->parent_sd
->s_iattr
;
512 struct iattr
*ps_iattrs
= &ps_iattr
->ia_iattr
;
513 ps_iattrs
->ia_ctime
= ps_iattrs
->ia_mtime
= CURRENT_TIME
;
516 sd
->s_flags
|= SYSFS_FLAG_REMOVED
;
517 sd
->u
.removed_list
= acxt
->removed
;
522 * sysfs_addrm_finish - finish up sysfs_dirent add/remove
523 * @acxt: addrm context to finish up
525 * Finish up sysfs_dirent add/remove. Resources acquired by
526 * sysfs_addrm_start() are released and removed sysfs_dirents are
530 * sysfs_mutex is released.
532 void sysfs_addrm_finish(struct sysfs_addrm_cxt
*acxt
)
534 /* release resources acquired by sysfs_addrm_start() */
535 mutex_unlock(&sysfs_mutex
);
537 /* kill removed sysfs_dirents */
538 while (acxt
->removed
) {
539 struct sysfs_dirent
*sd
= acxt
->removed
;
541 acxt
->removed
= sd
->u
.removed_list
;
543 sysfs_deactivate(sd
);
550 * sysfs_find_dirent - find sysfs_dirent with the given name
551 * @parent_sd: sysfs_dirent to search under
552 * @name: name to look for
554 * Look for sysfs_dirent with name @name under @parent_sd.
557 * mutex_lock(sysfs_mutex)
560 * Pointer to sysfs_dirent if found, NULL if not.
562 struct sysfs_dirent
*sysfs_find_dirent(struct sysfs_dirent
*parent_sd
,
564 const unsigned char *name
)
566 struct rb_node
*p
= parent_sd
->s_dir
.name_tree
.rb_node
;
567 struct sysfs_dirent
*found
= NULL
;
571 #define node rb_entry(p, struct sysfs_dirent, name_node)
572 c
= strcmp(name
, node
->s_name
);
574 p
= node
->name_node
.rb_left
;
576 p
= node
->name_node
.rb_right
;
579 p
= node
->name_node
.rb_left
;
585 while (found
->s_ns
&& found
->s_ns
!= ns
) {
586 p
= rb_next(&found
->name_node
);
589 found
= rb_entry(p
, struct sysfs_dirent
, name_node
);
590 if (strcmp(name
, found
->s_name
))
599 * sysfs_get_dirent - find and get sysfs_dirent with the given name
600 * @parent_sd: sysfs_dirent to search under
601 * @name: name to look for
603 * Look for sysfs_dirent with name @name under @parent_sd and get
607 * Kernel thread context (may sleep). Grabs sysfs_mutex.
610 * Pointer to sysfs_dirent if found, NULL if not.
612 struct sysfs_dirent
*sysfs_get_dirent(struct sysfs_dirent
*parent_sd
,
614 const unsigned char *name
)
616 struct sysfs_dirent
*sd
;
618 mutex_lock(&sysfs_mutex
);
619 sd
= sysfs_find_dirent(parent_sd
, ns
, name
);
621 mutex_unlock(&sysfs_mutex
);
625 EXPORT_SYMBOL_GPL(sysfs_get_dirent
);
627 static int create_dir(struct kobject
*kobj
, struct sysfs_dirent
*parent_sd
,
628 enum kobj_ns_type type
, const void *ns
, const char *name
,
629 struct sysfs_dirent
**p_sd
)
631 umode_t mode
= S_IFDIR
| S_IRWXU
| S_IRUGO
| S_IXUGO
;
632 struct sysfs_addrm_cxt acxt
;
633 struct sysfs_dirent
*sd
;
637 sd
= sysfs_new_dirent(name
, mode
, SYSFS_DIR
);
641 sd
->s_flags
|= (type
<< SYSFS_NS_TYPE_SHIFT
);
643 sd
->s_dir
.kobj
= kobj
;
646 sysfs_addrm_start(&acxt
, parent_sd
);
647 rc
= sysfs_add_one(&acxt
, sd
);
648 sysfs_addrm_finish(&acxt
);
658 int sysfs_create_subdir(struct kobject
*kobj
, const char *name
,
659 struct sysfs_dirent
**p_sd
)
661 return create_dir(kobj
, kobj
->sd
,
662 KOBJ_NS_TYPE_NONE
, NULL
, name
, p_sd
);
666 * sysfs_read_ns_type: return associated ns_type
667 * @kobj: the kobject being queried
669 * Each kobject can be tagged with exactly one namespace type
670 * (i.e. network or user). Return the ns_type associated with
673 static enum kobj_ns_type
sysfs_read_ns_type(struct kobject
*kobj
)
675 const struct kobj_ns_type_operations
*ops
;
676 enum kobj_ns_type type
;
678 ops
= kobj_child_ns_ops(kobj
);
680 return KOBJ_NS_TYPE_NONE
;
683 BUG_ON(type
<= KOBJ_NS_TYPE_NONE
);
684 BUG_ON(type
>= KOBJ_NS_TYPES
);
685 BUG_ON(!kobj_ns_type_registered(type
));
691 * sysfs_create_dir - create a directory for an object.
692 * @kobj: object we're creating directory for.
694 int sysfs_create_dir(struct kobject
* kobj
)
696 enum kobj_ns_type type
;
697 struct sysfs_dirent
*parent_sd
, *sd
;
698 const void *ns
= NULL
;
704 parent_sd
= kobj
->parent
->sd
;
706 parent_sd
= &sysfs_root
;
708 if (sysfs_ns_type(parent_sd
))
709 ns
= kobj
->ktype
->namespace(kobj
);
710 type
= sysfs_read_ns_type(kobj
);
712 error
= create_dir(kobj
, parent_sd
, type
, ns
, kobject_name(kobj
), &sd
);
718 static struct dentry
* sysfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
719 struct nameidata
*nd
)
721 struct dentry
*ret
= NULL
;
722 struct dentry
*parent
= dentry
->d_parent
;
723 struct sysfs_dirent
*parent_sd
= parent
->d_fsdata
;
724 struct sysfs_dirent
*sd
;
726 enum kobj_ns_type type
;
729 mutex_lock(&sysfs_mutex
);
731 type
= sysfs_ns_type(parent_sd
);
732 ns
= sysfs_info(dir
->i_sb
)->ns
[type
];
734 sd
= sysfs_find_dirent(parent_sd
, ns
, dentry
->d_name
.name
);
738 ret
= ERR_PTR(-ENOENT
);
742 /* attach dentry and inode */
743 inode
= sysfs_get_inode(dir
->i_sb
, sd
);
745 ret
= ERR_PTR(-ENOMEM
);
749 /* instantiate and hash dentry */
750 ret
= d_find_alias(inode
);
752 d_set_d_op(dentry
, &sysfs_dentry_ops
);
753 dentry
->d_fsdata
= sysfs_get(sd
);
754 d_add(dentry
, inode
);
761 mutex_unlock(&sysfs_mutex
);
765 const struct inode_operations sysfs_dir_inode_operations
= {
766 .lookup
= sysfs_lookup
,
767 .permission
= sysfs_permission
,
768 .setattr
= sysfs_setattr
,
769 .getattr
= sysfs_getattr
,
770 .setxattr
= sysfs_setxattr
,
773 static void remove_dir(struct sysfs_dirent
*sd
)
775 struct sysfs_addrm_cxt acxt
;
777 sysfs_addrm_start(&acxt
, sd
->s_parent
);
778 sysfs_remove_one(&acxt
, sd
);
779 sysfs_addrm_finish(&acxt
);
782 void sysfs_remove_subdir(struct sysfs_dirent
*sd
)
788 static void __sysfs_remove_dir(struct sysfs_dirent
*dir_sd
)
790 struct sysfs_addrm_cxt acxt
;
791 struct sysfs_dirent
**pos
;
796 pr_debug("sysfs %s: removing dir\n", dir_sd
->s_name
);
797 sysfs_addrm_start(&acxt
, dir_sd
);
798 pos
= &dir_sd
->s_dir
.children
;
800 struct sysfs_dirent
*sd
= *pos
;
802 if (sysfs_type(sd
) != SYSFS_DIR
)
803 sysfs_remove_one(&acxt
, sd
);
805 pos
= &(*pos
)->s_sibling
;
807 sysfs_addrm_finish(&acxt
);
813 * sysfs_remove_dir - remove an object's directory.
816 * The only thing special about this is that we remove any files in
817 * the directory before we remove the directory, and we've inlined
818 * what used to be sysfs_rmdir() below, instead of calling separately.
821 void sysfs_remove_dir(struct kobject
* kobj
)
823 struct sysfs_dirent
*sd
= kobj
->sd
;
825 spin_lock(&sysfs_assoc_lock
);
827 spin_unlock(&sysfs_assoc_lock
);
829 __sysfs_remove_dir(sd
);
832 int sysfs_rename(struct sysfs_dirent
*sd
,
833 struct sysfs_dirent
*new_parent_sd
, const void *new_ns
,
834 const char *new_name
)
836 const char *dup_name
= NULL
;
839 mutex_lock(&sysfs_mutex
);
842 if ((sd
->s_parent
== new_parent_sd
) && (sd
->s_ns
== new_ns
) &&
843 (strcmp(sd
->s_name
, new_name
) == 0))
844 goto out
; /* nothing to rename */
847 if (sysfs_find_dirent(new_parent_sd
, new_ns
, new_name
))
850 /* rename sysfs_dirent */
851 if (strcmp(sd
->s_name
, new_name
) != 0) {
853 new_name
= dup_name
= kstrdup(new_name
, GFP_KERNEL
);
857 dup_name
= sd
->s_name
;
858 sd
->s_name
= new_name
;
861 /* Remove from old parent's list and insert into new parent's list. */
862 if (sd
->s_parent
!= new_parent_sd
) {
863 sysfs_unlink_sibling(sd
);
864 sysfs_get(new_parent_sd
);
865 sysfs_put(sd
->s_parent
);
866 sd
->s_parent
= new_parent_sd
;
867 sysfs_link_sibling(sd
);
873 mutex_unlock(&sysfs_mutex
);
878 int sysfs_rename_dir(struct kobject
*kobj
, const char *new_name
)
880 struct sysfs_dirent
*parent_sd
= kobj
->sd
->s_parent
;
881 const void *new_ns
= NULL
;
883 if (sysfs_ns_type(parent_sd
))
884 new_ns
= kobj
->ktype
->namespace(kobj
);
886 return sysfs_rename(kobj
->sd
, parent_sd
, new_ns
, new_name
);
889 int sysfs_move_dir(struct kobject
*kobj
, struct kobject
*new_parent_kobj
)
891 struct sysfs_dirent
*sd
= kobj
->sd
;
892 struct sysfs_dirent
*new_parent_sd
;
893 const void *new_ns
= NULL
;
895 BUG_ON(!sd
->s_parent
);
896 if (sysfs_ns_type(sd
->s_parent
))
897 new_ns
= kobj
->ktype
->namespace(kobj
);
898 new_parent_sd
= new_parent_kobj
&& new_parent_kobj
->sd
?
899 new_parent_kobj
->sd
: &sysfs_root
;
901 return sysfs_rename(sd
, new_parent_sd
, new_ns
, sd
->s_name
);
904 /* Relationship between s_mode and the DT_xxx types */
905 static inline unsigned char dt_type(struct sysfs_dirent
*sd
)
907 return (sd
->s_mode
>> 12) & 15;
910 static int sysfs_dir_release(struct inode
*inode
, struct file
*filp
)
912 sysfs_put(filp
->private_data
);
916 static struct sysfs_dirent
*sysfs_dir_pos(const void *ns
,
917 struct sysfs_dirent
*parent_sd
, ino_t ino
, struct sysfs_dirent
*pos
)
920 int valid
= !(pos
->s_flags
& SYSFS_FLAG_REMOVED
) &&
921 pos
->s_parent
== parent_sd
&&
927 if (!pos
&& (ino
> 1) && (ino
< INT_MAX
)) {
928 pos
= parent_sd
->s_dir
.children
;
929 while (pos
&& (ino
> pos
->s_ino
))
930 pos
= pos
->s_sibling
;
932 while (pos
&& pos
->s_ns
&& pos
->s_ns
!= ns
)
933 pos
= pos
->s_sibling
;
937 static struct sysfs_dirent
*sysfs_dir_next_pos(const void *ns
,
938 struct sysfs_dirent
*parent_sd
, ino_t ino
, struct sysfs_dirent
*pos
)
940 pos
= sysfs_dir_pos(ns
, parent_sd
, ino
, pos
);
942 pos
= pos
->s_sibling
;
943 while (pos
&& pos
->s_ns
&& pos
->s_ns
!= ns
)
944 pos
= pos
->s_sibling
;
948 static int sysfs_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
)
950 struct dentry
*dentry
= filp
->f_path
.dentry
;
951 struct sysfs_dirent
* parent_sd
= dentry
->d_fsdata
;
952 struct sysfs_dirent
*pos
= filp
->private_data
;
953 enum kobj_ns_type type
;
957 type
= sysfs_ns_type(parent_sd
);
958 ns
= sysfs_info(dentry
->d_sb
)->ns
[type
];
960 if (filp
->f_pos
== 0) {
961 ino
= parent_sd
->s_ino
;
962 if (filldir(dirent
, ".", 1, filp
->f_pos
, ino
, DT_DIR
) == 0)
965 if (filp
->f_pos
== 1) {
966 if (parent_sd
->s_parent
)
967 ino
= parent_sd
->s_parent
->s_ino
;
969 ino
= parent_sd
->s_ino
;
970 if (filldir(dirent
, "..", 2, filp
->f_pos
, ino
, DT_DIR
) == 0)
973 mutex_lock(&sysfs_mutex
);
974 for (pos
= sysfs_dir_pos(ns
, parent_sd
, filp
->f_pos
, pos
);
976 pos
= sysfs_dir_next_pos(ns
, parent_sd
, filp
->f_pos
, pos
)) {
986 filp
->private_data
= sysfs_get(pos
);
988 mutex_unlock(&sysfs_mutex
);
989 ret
= filldir(dirent
, name
, len
, filp
->f_pos
, ino
, type
);
990 mutex_lock(&sysfs_mutex
);
994 mutex_unlock(&sysfs_mutex
);
995 if ((filp
->f_pos
> 1) && !pos
) { /* EOF */
996 filp
->f_pos
= INT_MAX
;
997 filp
->private_data
= NULL
;
1003 const struct file_operations sysfs_dir_operations
= {
1004 .read
= generic_read_dir
,
1005 .readdir
= sysfs_readdir
,
1006 .release
= sysfs_dir_release
,
1007 .llseek
= generic_file_llseek
,