2 * fs/kernfs/dir.c - kernfs directory implementation
4 * Copyright (c) 2001-3 Patrick Mochel
5 * Copyright (c) 2007 SUSE Linux Products GmbH
6 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
8 * This file is released under the GPLv2.
11 #include <linux/sched.h>
13 #include <linux/namei.h>
14 #include <linux/idr.h>
15 #include <linux/slab.h>
16 #include <linux/security.h>
17 #include <linux/hash.h>
19 #include "kernfs-internal.h"
21 DEFINE_MUTEX(kernfs_mutex
);
23 #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
25 static bool kernfs_lockdep(struct kernfs_node
*kn
)
27 #ifdef CONFIG_DEBUG_LOCK_ALLOC
28 return kn
->flags
& KERNFS_LOCKDEP
;
36 * @name: Null terminated string to hash
37 * @ns: Namespace tag to hash
39 * Returns 31 bit hash of ns + name (so it fits in an off_t )
41 static unsigned int kernfs_name_hash(const char *name
, const void *ns
)
43 unsigned long hash
= init_name_hash();
44 unsigned int len
= strlen(name
);
46 hash
= partial_name_hash(*name
++, hash
);
47 hash
= (end_name_hash(hash
) ^ hash_ptr((void *)ns
, 31));
49 /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
57 static int kernfs_name_compare(unsigned int hash
, const char *name
,
58 const void *ns
, const struct kernfs_node
*kn
)
61 return hash
- kn
->hash
;
64 return strcmp(name
, kn
->name
);
67 static int kernfs_sd_compare(const struct kernfs_node
*left
,
68 const struct kernfs_node
*right
)
70 return kernfs_name_compare(left
->hash
, left
->name
, left
->ns
, right
);
74 * kernfs_link_sibling - link kernfs_node into sibling rbtree
75 * @kn: kernfs_node of interest
77 * Link @kn into its sibling rbtree which starts from
78 * @kn->parent->dir.children.
81 * mutex_lock(kernfs_mutex)
84 * 0 on susccess -EEXIST on failure.
86 static int kernfs_link_sibling(struct kernfs_node
*kn
)
88 struct rb_node
**node
= &kn
->parent
->dir
.children
.rb_node
;
89 struct rb_node
*parent
= NULL
;
91 if (kernfs_type(kn
) == KERNFS_DIR
)
92 kn
->parent
->dir
.subdirs
++;
95 struct kernfs_node
*pos
;
98 pos
= rb_to_kn(*node
);
100 result
= kernfs_sd_compare(kn
, pos
);
102 node
= &pos
->rb
.rb_left
;
104 node
= &pos
->rb
.rb_right
;
108 /* add new node and rebalance the tree */
109 rb_link_node(&kn
->rb
, parent
, node
);
110 rb_insert_color(&kn
->rb
, &kn
->parent
->dir
.children
);
115 * kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree
116 * @kn: kernfs_node of interest
118 * Unlink @kn from its sibling rbtree which starts from
119 * kn->parent->dir.children.
122 * mutex_lock(kernfs_mutex)
124 static bool kernfs_unlink_sibling(struct kernfs_node
*kn
)
126 if (RB_EMPTY_NODE(&kn
->rb
))
129 if (kernfs_type(kn
) == KERNFS_DIR
)
130 kn
->parent
->dir
.subdirs
--;
132 rb_erase(&kn
->rb
, &kn
->parent
->dir
.children
);
133 RB_CLEAR_NODE(&kn
->rb
);
138 * kernfs_get_active - get an active reference to kernfs_node
139 * @kn: kernfs_node to get an active reference to
141 * Get an active reference of @kn. This function is noop if @kn
145 * Pointer to @kn on success, NULL on failure.
147 struct kernfs_node
*kernfs_get_active(struct kernfs_node
*kn
)
152 if (!atomic_inc_unless_negative(&kn
->active
))
155 if (kernfs_lockdep(kn
))
156 rwsem_acquire_read(&kn
->dep_map
, 0, 1, _RET_IP_
);
161 * kernfs_put_active - put an active reference to kernfs_node
162 * @kn: kernfs_node to put an active reference to
164 * Put an active reference to @kn. This function is noop if @kn
167 void kernfs_put_active(struct kernfs_node
*kn
)
169 struct kernfs_root
*root
= kernfs_root(kn
);
175 if (kernfs_lockdep(kn
))
176 rwsem_release(&kn
->dep_map
, 1, _RET_IP_
);
177 v
= atomic_dec_return(&kn
->active
);
178 if (likely(v
!= KN_DEACTIVATED_BIAS
))
181 wake_up_all(&root
->deactivate_waitq
);
185 * kernfs_drain - drain kernfs_node
186 * @kn: kernfs_node to drain
188 * Drain existing usages of @kn. Mutiple removers may invoke this function
189 * concurrently on @kn and all will return after draining is complete.
190 * Returns %true if drain is performed and kernfs_mutex was temporarily
191 * released. %false if @kn was already drained and no operation was
194 * The caller is responsible for ensuring @kn stays pinned while this
195 * function is in progress even if it gets removed by someone else.
197 static bool kernfs_drain(struct kernfs_node
*kn
)
198 __releases(&kernfs_mutex
) __acquires(&kernfs_mutex
)
200 struct kernfs_root
*root
= kernfs_root(kn
);
202 lockdep_assert_held(&kernfs_mutex
);
203 WARN_ON_ONCE(atomic_read(&kn
->active
) >= 0);
206 * We want to go through the active ref lockdep annotation at least
207 * once for all node removals, but the lockdep annotation can't be
208 * nested inside kernfs_mutex and deactivation can't make forward
209 * progress if we keep dropping the mutex. Use JUST_ACTIVATED to
210 * force the slow path once for each deactivation if lockdep is
213 if ((!kernfs_lockdep(kn
) || !(kn
->flags
& KERNFS_JUST_DEACTIVATED
)) &&
214 atomic_read(&kn
->active
) == KN_DEACTIVATED_BIAS
)
217 kn
->flags
&= ~KERNFS_JUST_DEACTIVATED
;
218 mutex_unlock(&kernfs_mutex
);
220 if (kernfs_lockdep(kn
)) {
221 rwsem_acquire(&kn
->dep_map
, 0, 0, _RET_IP_
);
222 if (atomic_read(&kn
->active
) != KN_DEACTIVATED_BIAS
)
223 lock_contended(&kn
->dep_map
, _RET_IP_
);
226 wait_event(root
->deactivate_waitq
,
227 atomic_read(&kn
->active
) == KN_DEACTIVATED_BIAS
);
229 if (kernfs_lockdep(kn
)) {
230 lock_acquired(&kn
->dep_map
, _RET_IP_
);
231 rwsem_release(&kn
->dep_map
, 1, _RET_IP_
);
234 mutex_lock(&kernfs_mutex
);
239 * kernfs_get - get a reference count on a kernfs_node
240 * @kn: the target kernfs_node
242 void kernfs_get(struct kernfs_node
*kn
)
245 WARN_ON(!atomic_read(&kn
->count
));
246 atomic_inc(&kn
->count
);
249 EXPORT_SYMBOL_GPL(kernfs_get
);
252 * kernfs_put - put a reference count on a kernfs_node
253 * @kn: the target kernfs_node
255 * Put a reference count of @kn and destroy it if it reached zero.
257 void kernfs_put(struct kernfs_node
*kn
)
259 struct kernfs_node
*parent
;
260 struct kernfs_root
*root
;
262 if (!kn
|| !atomic_dec_and_test(&kn
->count
))
264 root
= kernfs_root(kn
);
267 * Moving/renaming is always done while holding reference.
268 * kn->parent won't change beneath us.
272 WARN_ONCE(atomic_read(&kn
->active
) != KN_DEACTIVATED_BIAS
,
273 "kernfs_put: %s/%s: released with incorrect active_ref %d\n",
274 parent
? parent
->name
: "", kn
->name
, atomic_read(&kn
->active
));
276 if (kernfs_type(kn
) == KERNFS_LINK
)
277 kernfs_put(kn
->symlink
.target_kn
);
278 if (!(kn
->flags
& KERNFS_STATIC_NAME
))
281 if (kn
->iattr
->ia_secdata
)
282 security_release_secctx(kn
->iattr
->ia_secdata
,
283 kn
->iattr
->ia_secdata_len
);
284 simple_xattrs_free(&kn
->iattr
->xattrs
);
287 ida_simple_remove(&root
->ino_ida
, kn
->ino
);
288 kmem_cache_free(kernfs_node_cache
, kn
);
292 if (atomic_dec_and_test(&kn
->count
))
295 /* just released the root kn, free @root too */
296 ida_destroy(&root
->ino_ida
);
300 EXPORT_SYMBOL_GPL(kernfs_put
);
302 static int kernfs_dop_revalidate(struct dentry
*dentry
, unsigned int flags
)
304 struct kernfs_node
*kn
;
306 if (flags
& LOOKUP_RCU
)
309 /* Always perform fresh lookup for negatives */
310 if (!dentry
->d_inode
)
311 goto out_bad_unlocked
;
313 kn
= dentry
->d_fsdata
;
314 mutex_lock(&kernfs_mutex
);
316 /* Force fresh lookup if removed */
317 if (kn
->parent
&& RB_EMPTY_NODE(&kn
->rb
))
320 /* The kernfs node has been moved? */
321 if (dentry
->d_parent
->d_fsdata
!= kn
->parent
)
324 /* The kernfs node has been renamed */
325 if (strcmp(dentry
->d_name
.name
, kn
->name
) != 0)
328 /* The kernfs node has been moved to a different namespace */
329 if (kn
->parent
&& kernfs_ns_enabled(kn
->parent
) &&
330 kernfs_info(dentry
->d_sb
)->ns
!= kn
->ns
)
333 mutex_unlock(&kernfs_mutex
);
337 mutex_unlock(&kernfs_mutex
);
340 * @dentry doesn't match the underlying kernfs node, drop the
341 * dentry and force lookup. If we have submounts we must allow the
342 * vfs caches to lie about the state of the filesystem to prevent
343 * leaks and other nasty things, so use check_submounts_and_drop()
344 * instead of d_drop().
346 if (check_submounts_and_drop(dentry
) != 0)
352 static void kernfs_dop_release(struct dentry
*dentry
)
354 kernfs_put(dentry
->d_fsdata
);
357 const struct dentry_operations kernfs_dops
= {
358 .d_revalidate
= kernfs_dop_revalidate
,
359 .d_release
= kernfs_dop_release
,
362 struct kernfs_node
*kernfs_new_node(struct kernfs_root
*root
, const char *name
,
363 umode_t mode
, unsigned flags
)
365 char *dup_name
= NULL
;
366 struct kernfs_node
*kn
;
369 if (!(flags
& KERNFS_STATIC_NAME
)) {
370 name
= dup_name
= kstrdup(name
, GFP_KERNEL
);
375 kn
= kmem_cache_zalloc(kernfs_node_cache
, GFP_KERNEL
);
379 ret
= ida_simple_get(&root
->ino_ida
, 1, 0, GFP_KERNEL
);
384 atomic_set(&kn
->count
, 1);
385 atomic_set(&kn
->active
, KN_DEACTIVATED_BIAS
);
386 RB_CLEAR_NODE(&kn
->rb
);
395 kmem_cache_free(kernfs_node_cache
, kn
);
402 * kernfs_addrm_start - prepare for kernfs_node add/remove
403 * @acxt: pointer to kernfs_addrm_cxt to be used
405 * This function is called when the caller is about to add or remove
406 * kernfs_node. This function acquires kernfs_mutex. @acxt is used
407 * to keep and pass context to other addrm functions.
410 * Kernel thread context (may sleep). kernfs_mutex is locked on
413 void kernfs_addrm_start(struct kernfs_addrm_cxt
*acxt
)
414 __acquires(kernfs_mutex
)
416 memset(acxt
, 0, sizeof(*acxt
));
418 mutex_lock(&kernfs_mutex
);
422 * kernfs_add_one - add kernfs_node to parent without warning
423 * @acxt: addrm context to use
424 * @kn: kernfs_node to be added
425 * @parent: the parent kernfs_node to add @kn to
427 * Get @parent and set @kn->parent to it and increment nlink of the
428 * parent inode if @kn is a directory and link into the children list
431 * This function should be called between calls to
432 * kernfs_addrm_start() and kernfs_addrm_finish() and should be passed
433 * the same @acxt as passed to kernfs_addrm_start().
436 * Determined by kernfs_addrm_start().
439 * 0 on success, -EEXIST if entry with the given name already
442 int kernfs_add_one(struct kernfs_addrm_cxt
*acxt
, struct kernfs_node
*kn
,
443 struct kernfs_node
*parent
)
445 bool has_ns
= kernfs_ns_enabled(parent
);
446 struct kernfs_iattrs
*ps_iattr
;
449 WARN_ON_ONCE(atomic_read(&parent
->active
) < 0);
451 if (has_ns
!= (bool)kn
->ns
) {
452 WARN(1, KERN_WARNING
"kernfs: ns %s in '%s' for '%s'\n",
453 has_ns
? "required" : "invalid", parent
->name
, kn
->name
);
457 if (kernfs_type(parent
) != KERNFS_DIR
)
460 kn
->hash
= kernfs_name_hash(kn
->name
, kn
->ns
);
464 ret
= kernfs_link_sibling(kn
);
468 /* Update timestamps on the parent */
469 ps_iattr
= parent
->iattr
;
471 struct iattr
*ps_iattrs
= &ps_iattr
->ia_iattr
;
472 ps_iattrs
->ia_ctime
= ps_iattrs
->ia_mtime
= CURRENT_TIME
;
475 /* Mark the entry added into directory tree */
476 atomic_sub(KN_DEACTIVATED_BIAS
, &kn
->active
);
481 * kernfs_addrm_finish - finish up kernfs_node add/remove
482 * @acxt: addrm context to finish up
484 * Finish up kernfs_node add/remove. Resources acquired by
485 * kernfs_addrm_start() are released and removed kernfs_nodes are
489 * kernfs_mutex is released.
491 void kernfs_addrm_finish(struct kernfs_addrm_cxt
*acxt
)
492 __releases(kernfs_mutex
)
494 /* release resources acquired by kernfs_addrm_start() */
495 mutex_unlock(&kernfs_mutex
);
497 /* kill removed kernfs_nodes */
498 while (acxt
->removed
) {
499 struct kernfs_node
*kn
= acxt
->removed
;
501 acxt
->removed
= kn
->u
.removed_list
;
508 * kernfs_find_ns - find kernfs_node with the given name
509 * @parent: kernfs_node to search under
510 * @name: name to look for
511 * @ns: the namespace tag to use
513 * Look for kernfs_node with name @name under @parent. Returns pointer to
514 * the found kernfs_node on success, %NULL on failure.
516 static struct kernfs_node
*kernfs_find_ns(struct kernfs_node
*parent
,
517 const unsigned char *name
,
520 struct rb_node
*node
= parent
->dir
.children
.rb_node
;
521 bool has_ns
= kernfs_ns_enabled(parent
);
524 lockdep_assert_held(&kernfs_mutex
);
526 if (has_ns
!= (bool)ns
) {
527 WARN(1, KERN_WARNING
"kernfs: ns %s in '%s' for '%s'\n",
528 has_ns
? "required" : "invalid", parent
->name
, name
);
532 hash
= kernfs_name_hash(name
, ns
);
534 struct kernfs_node
*kn
;
538 result
= kernfs_name_compare(hash
, name
, ns
, kn
);
540 node
= node
->rb_left
;
542 node
= node
->rb_right
;
550 * kernfs_find_and_get_ns - find and get kernfs_node with the given name
551 * @parent: kernfs_node to search under
552 * @name: name to look for
553 * @ns: the namespace tag to use
555 * Look for kernfs_node with name @name under @parent and get a reference
556 * if found. This function may sleep and returns pointer to the found
557 * kernfs_node on success, %NULL on failure.
559 struct kernfs_node
*kernfs_find_and_get_ns(struct kernfs_node
*parent
,
560 const char *name
, const void *ns
)
562 struct kernfs_node
*kn
;
564 mutex_lock(&kernfs_mutex
);
565 kn
= kernfs_find_ns(parent
, name
, ns
);
567 mutex_unlock(&kernfs_mutex
);
571 EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns
);
574 * kernfs_create_root - create a new kernfs hierarchy
575 * @kdops: optional directory syscall operations for the hierarchy
576 * @priv: opaque data associated with the new directory
578 * Returns the root of the new hierarchy on success, ERR_PTR() value on
581 struct kernfs_root
*kernfs_create_root(struct kernfs_dir_ops
*kdops
, void *priv
)
583 struct kernfs_root
*root
;
584 struct kernfs_node
*kn
;
586 root
= kzalloc(sizeof(*root
), GFP_KERNEL
);
588 return ERR_PTR(-ENOMEM
);
590 ida_init(&root
->ino_ida
);
592 kn
= kernfs_new_node(root
, "", S_IFDIR
| S_IRUGO
| S_IXUGO
, KERNFS_DIR
);
594 ida_destroy(&root
->ino_ida
);
596 return ERR_PTR(-ENOMEM
);
599 atomic_sub(KN_DEACTIVATED_BIAS
, &kn
->active
);
603 root
->dir_ops
= kdops
;
605 init_waitqueue_head(&root
->deactivate_waitq
);
611 * kernfs_destroy_root - destroy a kernfs hierarchy
612 * @root: root of the hierarchy to destroy
614 * Destroy the hierarchy anchored at @root by removing all existing
615 * directories and destroying @root.
617 void kernfs_destroy_root(struct kernfs_root
*root
)
619 kernfs_remove(root
->kn
); /* will also free @root */
623 * kernfs_create_dir_ns - create a directory
624 * @parent: parent in which to create a new directory
625 * @name: name of the new directory
626 * @mode: mode of the new directory
627 * @priv: opaque data associated with the new directory
628 * @ns: optional namespace tag of the directory
630 * Returns the created node on success, ERR_PTR() value on failure.
632 struct kernfs_node
*kernfs_create_dir_ns(struct kernfs_node
*parent
,
633 const char *name
, umode_t mode
,
634 void *priv
, const void *ns
)
636 struct kernfs_addrm_cxt acxt
;
637 struct kernfs_node
*kn
;
641 kn
= kernfs_new_node(kernfs_root(parent
), name
, mode
| S_IFDIR
,
644 return ERR_PTR(-ENOMEM
);
646 kn
->dir
.root
= parent
->dir
.root
;
652 if (kernfs_get_active(parent
)) {
653 kernfs_addrm_start(&acxt
);
654 rc
= kernfs_add_one(&acxt
, kn
, parent
);
655 kernfs_addrm_finish(&acxt
);
656 kernfs_put_active(parent
);
666 static struct dentry
*kernfs_iop_lookup(struct inode
*dir
,
667 struct dentry
*dentry
,
671 struct kernfs_node
*parent
= dentry
->d_parent
->d_fsdata
;
672 struct kernfs_node
*kn
;
674 const void *ns
= NULL
;
676 mutex_lock(&kernfs_mutex
);
678 if (kernfs_ns_enabled(parent
))
679 ns
= kernfs_info(dir
->i_sb
)->ns
;
681 kn
= kernfs_find_ns(parent
, dentry
->d_name
.name
, ns
);
689 dentry
->d_fsdata
= kn
;
691 /* attach dentry and inode */
692 inode
= kernfs_get_inode(dir
->i_sb
, kn
);
694 ret
= ERR_PTR(-ENOMEM
);
698 /* instantiate and hash dentry */
699 ret
= d_materialise_unique(dentry
, inode
);
701 mutex_unlock(&kernfs_mutex
);
705 static int kernfs_iop_mkdir(struct inode
*dir
, struct dentry
*dentry
,
708 struct kernfs_node
*parent
= dir
->i_private
;
709 struct kernfs_dir_ops
*kdops
= kernfs_root(parent
)->dir_ops
;
711 if (!kdops
|| !kdops
->mkdir
)
714 return kdops
->mkdir(parent
, dentry
->d_name
.name
, mode
);
717 static int kernfs_iop_rmdir(struct inode
*dir
, struct dentry
*dentry
)
719 struct kernfs_node
*kn
= dentry
->d_fsdata
;
720 struct kernfs_dir_ops
*kdops
= kernfs_root(kn
)->dir_ops
;
722 if (!kdops
|| !kdops
->rmdir
)
725 return kdops
->rmdir(kn
);
728 static int kernfs_iop_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
729 struct inode
*new_dir
, struct dentry
*new_dentry
)
731 struct kernfs_node
*kn
= old_dentry
->d_fsdata
;
732 struct kernfs_node
*new_parent
= new_dir
->i_private
;
733 struct kernfs_dir_ops
*kdops
= kernfs_root(kn
)->dir_ops
;
735 if (!kdops
|| !kdops
->rename
)
738 return kdops
->rename(kn
, new_parent
, new_dentry
->d_name
.name
);
741 const struct inode_operations kernfs_dir_iops
= {
742 .lookup
= kernfs_iop_lookup
,
743 .permission
= kernfs_iop_permission
,
744 .setattr
= kernfs_iop_setattr
,
745 .getattr
= kernfs_iop_getattr
,
746 .setxattr
= kernfs_iop_setxattr
,
747 .removexattr
= kernfs_iop_removexattr
,
748 .getxattr
= kernfs_iop_getxattr
,
749 .listxattr
= kernfs_iop_listxattr
,
751 .mkdir
= kernfs_iop_mkdir
,
752 .rmdir
= kernfs_iop_rmdir
,
753 .rename
= kernfs_iop_rename
,
756 static struct kernfs_node
*kernfs_leftmost_descendant(struct kernfs_node
*pos
)
758 struct kernfs_node
*last
;
765 if (kernfs_type(pos
) != KERNFS_DIR
)
768 rbn
= rb_first(&pos
->dir
.children
);
779 * kernfs_next_descendant_post - find the next descendant for post-order walk
780 * @pos: the current position (%NULL to initiate traversal)
781 * @root: kernfs_node whose descendants to walk
783 * Find the next descendant to visit for post-order traversal of @root's
784 * descendants. @root is included in the iteration and the last node to be
787 static struct kernfs_node
*kernfs_next_descendant_post(struct kernfs_node
*pos
,
788 struct kernfs_node
*root
)
792 lockdep_assert_held(&kernfs_mutex
);
794 /* if first iteration, visit leftmost descendant which may be root */
796 return kernfs_leftmost_descendant(root
);
798 /* if we visited @root, we're done */
802 /* if there's an unvisited sibling, visit its leftmost descendant */
803 rbn
= rb_next(&pos
->rb
);
805 return kernfs_leftmost_descendant(rb_to_kn(rbn
));
807 /* no sibling left, visit parent */
811 static void __kernfs_deactivate(struct kernfs_node
*kn
)
813 struct kernfs_node
*pos
;
815 lockdep_assert_held(&kernfs_mutex
);
817 /* prevent any new usage under @kn by deactivating all nodes */
819 while ((pos
= kernfs_next_descendant_post(pos
, kn
))) {
820 if (atomic_read(&pos
->active
) >= 0) {
821 atomic_add(KN_DEACTIVATED_BIAS
, &pos
->active
);
822 pos
->flags
|= KERNFS_JUST_DEACTIVATED
;
827 * Drain the subtree. If kernfs_drain() blocked to drain, which is
828 * indicated by %true return, it temporarily released kernfs_mutex
829 * and the rbtree might have been modified inbetween breaking our
830 * future walk. Restart the walk after each %true return.
833 while ((pos
= kernfs_next_descendant_post(pos
, kn
))) {
837 drained
= kernfs_drain(pos
);
844 static void __kernfs_remove(struct kernfs_addrm_cxt
*acxt
,
845 struct kernfs_node
*kn
)
847 struct kernfs_node
*pos
;
849 lockdep_assert_held(&kernfs_mutex
);
854 pr_debug("kernfs %s: removing\n", kn
->name
);
856 __kernfs_deactivate(kn
);
858 /* unlink the subtree node-by-node */
860 pos
= kernfs_leftmost_descendant(kn
);
863 * We're gonna release kernfs_mutex to unmap bin files,
864 * Make sure @pos doesn't go away inbetween.
869 * This must be come before unlinking; otherwise, when
870 * there are multiple removers, some may finish before
871 * unmapping is complete.
873 if (pos
->flags
& KERNFS_HAS_MMAP
) {
874 mutex_unlock(&kernfs_mutex
);
875 kernfs_unmap_file(pos
);
876 mutex_lock(&kernfs_mutex
);
880 * kernfs_unlink_sibling() succeeds once per node. Use it
881 * to decide who's responsible for cleanups.
883 if (!pos
->parent
|| kernfs_unlink_sibling(pos
)) {
884 struct kernfs_iattrs
*ps_iattr
=
885 pos
->parent
? pos
->parent
->iattr
: NULL
;
887 /* update timestamps on the parent */
889 ps_iattr
->ia_iattr
.ia_ctime
= CURRENT_TIME
;
890 ps_iattr
->ia_iattr
.ia_mtime
= CURRENT_TIME
;
893 pos
->u
.removed_list
= acxt
->removed
;
902 * kernfs_remove - remove a kernfs_node recursively
903 * @kn: the kernfs_node to remove
905 * Remove @kn along with all its subdirectories and files.
907 void kernfs_remove(struct kernfs_node
*kn
)
909 struct kernfs_addrm_cxt acxt
;
911 kernfs_addrm_start(&acxt
);
912 __kernfs_remove(&acxt
, kn
);
913 kernfs_addrm_finish(&acxt
);
917 * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it
918 * @parent: parent of the target
919 * @name: name of the kernfs_node to remove
920 * @ns: namespace tag of the kernfs_node to remove
922 * Look for the kernfs_node with @name and @ns under @parent and remove it.
923 * Returns 0 on success, -ENOENT if such entry doesn't exist.
925 int kernfs_remove_by_name_ns(struct kernfs_node
*parent
, const char *name
,
928 struct kernfs_addrm_cxt acxt
;
929 struct kernfs_node
*kn
;
932 WARN(1, KERN_WARNING
"kernfs: can not remove '%s', no directory\n",
937 kernfs_addrm_start(&acxt
);
939 kn
= kernfs_find_ns(parent
, name
, ns
);
941 __kernfs_remove(&acxt
, kn
);
943 kernfs_addrm_finish(&acxt
);
952 * kernfs_rename_ns - move and rename a kernfs_node
954 * @new_parent: new parent to put @sd under
955 * @new_name: new name
956 * @new_ns: new namespace tag
958 int kernfs_rename_ns(struct kernfs_node
*kn
, struct kernfs_node
*new_parent
,
959 const char *new_name
, const void *new_ns
)
964 if (!kernfs_get_active(new_parent
))
966 if (!kernfs_get_active(kn
))
967 goto out_put_new_parent
;
969 mutex_lock(&kernfs_mutex
);
972 if ((kn
->parent
== new_parent
) && (kn
->ns
== new_ns
) &&
973 (strcmp(kn
->name
, new_name
) == 0))
974 goto out_unlock
; /* nothing to rename */
977 if (kernfs_find_ns(new_parent
, new_name
, new_ns
))
980 /* rename kernfs_node */
981 if (strcmp(kn
->name
, new_name
) != 0) {
983 new_name
= kstrdup(new_name
, GFP_KERNEL
);
987 if (kn
->flags
& KERNFS_STATIC_NAME
)
988 kn
->flags
&= ~KERNFS_STATIC_NAME
;
996 * Move to the appropriate place in the appropriate directories rbtree.
998 kernfs_unlink_sibling(kn
);
999 kernfs_get(new_parent
);
1000 kernfs_put(kn
->parent
);
1002 kn
->hash
= kernfs_name_hash(kn
->name
, kn
->ns
);
1003 kn
->parent
= new_parent
;
1004 kernfs_link_sibling(kn
);
1008 mutex_unlock(&kernfs_mutex
);
1009 kernfs_put_active(kn
);
1011 kernfs_put_active(new_parent
);
1016 /* Relationship between s_mode and the DT_xxx types */
1017 static inline unsigned char dt_type(struct kernfs_node
*kn
)
1019 return (kn
->mode
>> 12) & 15;
1022 static int kernfs_dir_fop_release(struct inode
*inode
, struct file
*filp
)
1024 kernfs_put(filp
->private_data
);
1028 static struct kernfs_node
*kernfs_dir_pos(const void *ns
,
1029 struct kernfs_node
*parent
, loff_t hash
, struct kernfs_node
*pos
)
1032 int valid
= pos
->parent
== parent
&& hash
== pos
->hash
;
1037 if (!pos
&& (hash
> 1) && (hash
< INT_MAX
)) {
1038 struct rb_node
*node
= parent
->dir
.children
.rb_node
;
1040 pos
= rb_to_kn(node
);
1042 if (hash
< pos
->hash
)
1043 node
= node
->rb_left
;
1044 else if (hash
> pos
->hash
)
1045 node
= node
->rb_right
;
1050 /* Skip over entries in the wrong namespace */
1051 while (pos
&& pos
->ns
!= ns
) {
1052 struct rb_node
*node
= rb_next(&pos
->rb
);
1056 pos
= rb_to_kn(node
);
1061 static struct kernfs_node
*kernfs_dir_next_pos(const void *ns
,
1062 struct kernfs_node
*parent
, ino_t ino
, struct kernfs_node
*pos
)
1064 pos
= kernfs_dir_pos(ns
, parent
, ino
, pos
);
1067 struct rb_node
*node
= rb_next(&pos
->rb
);
1071 pos
= rb_to_kn(node
);
1072 } while (pos
&& pos
->ns
!= ns
);
1076 static int kernfs_fop_readdir(struct file
*file
, struct dir_context
*ctx
)
1078 struct dentry
*dentry
= file
->f_path
.dentry
;
1079 struct kernfs_node
*parent
= dentry
->d_fsdata
;
1080 struct kernfs_node
*pos
= file
->private_data
;
1081 const void *ns
= NULL
;
1083 if (!dir_emit_dots(file
, ctx
))
1085 mutex_lock(&kernfs_mutex
);
1087 if (kernfs_ns_enabled(parent
))
1088 ns
= kernfs_info(dentry
->d_sb
)->ns
;
1090 for (pos
= kernfs_dir_pos(ns
, parent
, ctx
->pos
, pos
);
1092 pos
= kernfs_dir_next_pos(ns
, parent
, ctx
->pos
, pos
)) {
1093 const char *name
= pos
->name
;
1094 unsigned int type
= dt_type(pos
);
1095 int len
= strlen(name
);
1096 ino_t ino
= pos
->ino
;
1098 ctx
->pos
= pos
->hash
;
1099 file
->private_data
= pos
;
1102 mutex_unlock(&kernfs_mutex
);
1103 if (!dir_emit(ctx
, name
, len
, ino
, type
))
1105 mutex_lock(&kernfs_mutex
);
1107 mutex_unlock(&kernfs_mutex
);
1108 file
->private_data
= NULL
;
1113 static loff_t
kernfs_dir_fop_llseek(struct file
*file
, loff_t offset
,
1116 struct inode
*inode
= file_inode(file
);
1119 mutex_lock(&inode
->i_mutex
);
1120 ret
= generic_file_llseek(file
, offset
, whence
);
1121 mutex_unlock(&inode
->i_mutex
);
1126 const struct file_operations kernfs_dir_fops
= {
1127 .read
= generic_read_dir
,
1128 .iterate
= kernfs_fop_readdir
,
1129 .release
= kernfs_dir_fop_release
,
1130 .llseek
= kernfs_dir_fop_llseek
,