Lines Matching refs:kn
20 static DEFINE_RWLOCK(kernfs_rename_lock); /* kn->parent and ->name */
34 static bool __kernfs_active(struct kernfs_node *kn)
36 return atomic_read(&kn->active) >= 0;
39 static bool kernfs_active(struct kernfs_node *kn)
41 lockdep_assert_held(&kernfs_root(kn)->kernfs_rwsem);
42 return __kernfs_active(kn);
45 static bool kernfs_lockdep(struct kernfs_node *kn)
48 return kn->flags & KERNFS_LOCKDEP;
54 static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen)
56 if (!kn)
59 return strlcpy(buf, kn->parent ? kn->name : "/", buflen);
83 da = kernfs_depth(ra->kn, a);
84 db = kernfs_depth(rb->kn, b);
138 struct kernfs_node *kn, *common;
147 kn_from = kernfs_root(kn_to)->kn;
167 for (kn = kn_to, j = 0; j < i; j++)
168 kn = kn->parent;
171 len += strlcpy(buf + len, kn->name,
180 * @kn: kernfs_node of interest
181 * @buf: buffer to copy @kn's name into
184 * Copies the name of @kn into @buf of @buflen bytes. The behavior is
187 * Fills buffer with "(null)" if @kn is %NULL.
189 * Return: the length of @kn's name and if @buf isn't long enough,
194 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
200 ret = kernfs_name_locked(kn, buf, buflen);
236 * @kn: kernfs_node of interest
240 void pr_cont_kernfs_name(struct kernfs_node *kn)
246 kernfs_name(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf));
254 * @kn: kernfs_node of interest
258 void pr_cont_kernfs_path(struct kernfs_node *kn)
265 sz = kernfs_path_from_node(kn, NULL, kernfs_pr_cont_buf,
285 * @kn: kernfs_node of interest
287 * Determines @kn's parent, pins and returns it. This function can be
290 * Return: parent node of @kn
292 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
298 parent = kn->parent;
329 const void *ns, const struct kernfs_node *kn)
331 if (hash < kn->hash)
333 if (hash > kn->hash)
335 if (ns < kn->ns)
337 if (ns > kn->ns)
339 return strcmp(name, kn->name);
350 * @kn: kernfs_node of interest
352 * Link @kn into its sibling rbtree which starts from
353 * @kn->parent->dir.children.
361 static int kernfs_link_sibling(struct kernfs_node *kn)
363 struct rb_node **node = &kn->parent->dir.children.rb_node;
372 result = kernfs_sd_compare(kn, pos);
382 rb_link_node(&kn->rb, parent, node);
383 rb_insert_color(&kn->rb, &kn->parent->dir.children);
386 down_write(&kernfs_root(kn)->kernfs_iattr_rwsem);
387 if (kernfs_type(kn) == KERNFS_DIR)
388 kn->parent->dir.subdirs++;
389 kernfs_inc_rev(kn->parent);
390 up_write(&kernfs_root(kn)->kernfs_iattr_rwsem);
397 * @kn: kernfs_node of interest
399 * Try to unlink @kn from its sibling rbtree which starts from
400 * kn->parent->dir.children.
402 * Return: %true if @kn was actually removed,
403 * %false if @kn wasn't on the rbtree.
408 static bool kernfs_unlink_sibling(struct kernfs_node *kn)
410 if (RB_EMPTY_NODE(&kn->rb))
413 down_write(&kernfs_root(kn)->kernfs_iattr_rwsem);
414 if (kernfs_type(kn) == KERNFS_DIR)
415 kn->parent->dir.subdirs--;
416 kernfs_inc_rev(kn->parent);
417 up_write(&kernfs_root(kn)->kernfs_iattr_rwsem);
419 rb_erase(&kn->rb, &kn->parent->dir.children);
420 RB_CLEAR_NODE(&kn->rb);
426 * @kn: kernfs_node to get an active reference to
428 * Get an active reference of @kn. This function is noop if @kn
432 * Pointer to @kn on success, %NULL on failure.
434 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
436 if (unlikely(!kn))
439 if (!atomic_inc_unless_negative(&kn->active))
442 if (kernfs_lockdep(kn))
443 rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
444 return kn;
449 * @kn: kernfs_node to put an active reference to
451 * Put an active reference to @kn. This function is noop if @kn
454 void kernfs_put_active(struct kernfs_node *kn)
458 if (unlikely(!kn))
461 if (kernfs_lockdep(kn))
462 rwsem_release(&kn->dep_map, _RET_IP_);
463 v = atomic_dec_return(&kn->active);
467 wake_up_all(&kernfs_root(kn)->deactivate_waitq);
472 * @kn: kernfs_node to drain
474 * Drain existing usages and nuke all existing mmaps of @kn. Multiple
475 * removers may invoke this function concurrently on @kn and all will
478 static void kernfs_drain(struct kernfs_node *kn)
479 __releases(&kernfs_root(kn)->kernfs_rwsem)
480 __acquires(&kernfs_root(kn)->kernfs_rwsem)
482 struct kernfs_root *root = kernfs_root(kn);
485 WARN_ON_ONCE(kernfs_active(kn));
493 if (atomic_read(&kn->active) == KN_DEACTIVATED_BIAS &&
494 !kernfs_should_drain_open_files(kn))
499 if (kernfs_lockdep(kn)) {
500 rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
501 if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
502 lock_contended(&kn->dep_map, _RET_IP_);
506 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
508 if (kernfs_lockdep(kn)) {
509 lock_acquired(&kn->dep_map, _RET_IP_);
510 rwsem_release(&kn->dep_map, _RET_IP_);
513 if (kernfs_should_drain_open_files(kn))
514 kernfs_drain_open_files(kn);
521 * @kn: the target kernfs_node
523 void kernfs_get(struct kernfs_node *kn)
525 if (kn) {
526 WARN_ON(!atomic_read(&kn->count));
527 atomic_inc(&kn->count);
534 * @kn: the target kernfs_node
536 * Put a reference count of @kn and destroy it if it reached zero.
538 void kernfs_put(struct kernfs_node *kn)
543 if (!kn || !atomic_dec_and_test(&kn->count))
545 root = kernfs_root(kn);
549 * kn->parent won't change beneath us.
551 parent = kn->parent;
553 WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
555 parent ? parent->name : "", kn->name, atomic_read(&kn->active));
557 if (kernfs_type(kn) == KERNFS_LINK)
558 kernfs_put(kn->symlink.target_kn);
560 kfree_const(kn->name);
562 if (kn->iattr) {
563 simple_xattrs_free(&kn->iattr->xattrs, NULL);
564 kmem_cache_free(kernfs_iattrs_cache, kn->iattr);
567 idr_remove(&root->ino_idr, (u32)kernfs_ino(kn));
569 kmem_cache_free(kernfs_node_cache, kn);
571 kn = parent;
572 if (kn) {
573 if (atomic_dec_and_test(&kn->count))
576 /* just released the root kn, free @root too */
607 struct kernfs_node *kn;
615 kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
616 if (!kn)
621 ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC);
631 kn->id = (u64)id_highbits << 32 | ret;
633 atomic_set(&kn->count, 1);
634 atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
635 RB_CLEAR_NODE(&kn->rb);
637 kn->name = name;
638 kn->mode = mode;
639 kn->flags = flags;
648 ret = __kernfs_setattr(kn, &iattr);
654 ret = security_kernfs_init_security(parent, kn);
659 return kn;
663 idr_remove(&root->ino_idr, (u32)kernfs_ino(kn));
666 kmem_cache_free(kernfs_node_cache, kn);
677 struct kernfs_node *kn;
691 kn = __kernfs_new_node(kernfs_root(parent), parent,
693 if (kn) {
695 kn->parent = parent;
697 return kn;
714 struct kernfs_node *kn;
720 kn = idr_find(&root->ino_idr, (u32)ino);
721 if (!kn)
726 if (kernfs_ino(kn) != ino)
730 if (unlikely(gen && kernfs_gen(kn) != gen))
735 * We should fail if @kn has never been activated and guarantee success
736 * if the caller knows that @kn is active. Both can be achieved by
737 * __kernfs_active() which tests @kn->active without kernfs_rwsem.
739 if (unlikely(!__kernfs_active(kn) || !atomic_inc_not_zero(&kn->count)))
743 return kn;
751 * @kn: kernfs_node to be added
753 * The caller must already have initialized @kn->parent. This
754 * function increments nlink of the parent's inode if @kn is a
761 int kernfs_add_one(struct kernfs_node *kn)
763 struct kernfs_node *parent = kn->parent;
773 if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
774 has_ns ? "required" : "invalid", parent->name, kn->name))
784 kn->hash = kernfs_name_hash(kn->name, kn->ns);
786 ret = kernfs_link_sibling(kn);
809 if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
810 kernfs_activate(kn);
846 struct kernfs_node *kn;
849 kn = rb_to_kn(node);
850 result = kernfs_name_compare(hash, name, ns, kn);
856 return kn;
906 struct kernfs_node *kn;
910 kn = kernfs_find_ns(parent, name, ns);
911 kernfs_get(kn);
914 return kn;
932 struct kernfs_node *kn;
936 kn = kernfs_walk_ns(parent, path, ns);
937 kernfs_get(kn);
940 return kn;
956 struct kernfs_node *kn;
979 kn = __kernfs_new_node(root, NULL, "", S_IFDIR | S_IRUGO | S_IXUGO,
982 if (!kn) {
988 kn->priv = priv;
989 kn->dir.root = root;
993 root->kn = kn;
997 kernfs_activate(kn);
1015 kernfs_get(root->kn);
1016 kernfs_remove(root->kn);
1017 kernfs_put(root->kn); /* will also free @root */
1028 return root->kn;
1048 struct kernfs_node *kn;
1052 kn = kernfs_new_node(parent, name, mode | S_IFDIR,
1054 if (!kn)
1057 kn->dir.root = parent->dir.root;
1058 kn->ns = ns;
1059 kn->priv = priv;
1062 rc = kernfs_add_one(kn);
1064 return kn;
1066 kernfs_put(kn);
1080 struct kernfs_node *kn;
1084 kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR,
1086 if (!kn)
1089 kn->flags |= KERNFS_EMPTY_DIR;
1090 kn->dir.root = parent->dir.root;
1091 kn->ns = NULL;
1092 kn->priv = NULL;
1095 rc = kernfs_add_one(kn);
1097 return kn;
1099 kernfs_put(kn);
1105 struct kernfs_node *kn;
1148 kn = kernfs_dentry_node(dentry);
1149 root = kernfs_root(kn);
1153 if (!kernfs_active(kn))
1157 if (kernfs_dentry_node(dentry->d_parent) != kn->parent)
1161 if (strcmp(dentry->d_name.name, kn->name) != 0)
1165 if (kn->parent && kernfs_ns_enabled(kn->parent) &&
1166 kernfs_info(dentry->d_sb)->ns != kn->ns)
1185 struct kernfs_node *kn;
1195 kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
1197 if (kn) {
1201 if (!kernfs_active(kn)) {
1205 inode = kernfs_get_inode(dir->i_sb, kn);
1245 struct kernfs_node *kn = kernfs_dentry_node(dentry);
1246 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1252 if (!kernfs_get_active(kn))
1255 ret = scops->rmdir(kn);
1257 kernfs_put_active(kn);
1266 struct kernfs_node *kn = kernfs_dentry_node(old_dentry);
1268 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1277 if (!kernfs_get_active(kn))
1281 kernfs_put_active(kn);
1285 ret = scops->rename(kn, new_parent, new_dentry->d_name.name);
1288 kernfs_put_active(kn);
1361 static void kernfs_activate_one(struct kernfs_node *kn)
1363 lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem);
1365 kn->flags |= KERNFS_ACTIVATED;
1367 if (kernfs_active(kn) || (kn->flags & (KERNFS_HIDDEN | KERNFS_REMOVING)))
1370 WARN_ON_ONCE(kn->parent && RB_EMPTY_NODE(&kn->rb));
1371 WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS);
1373 atomic_sub(KN_DEACTIVATED_BIAS, &kn->active);
1378 * @kn: kernfs_node whose subtree is to be activated
1387 * after kernfs_remove*() is invoked on @kn.
1389 void kernfs_activate(struct kernfs_node *kn)
1392 struct kernfs_root *root = kernfs_root(kn);
1397 while ((pos = kernfs_next_descendant_post(pos, kn)))
1405 * @kn: kernfs_node to show or hide
1408 * If @show is %false, @kn is marked hidden and deactivated. A hidden node is
1415 void kernfs_show(struct kernfs_node *kn, bool show)
1417 struct kernfs_root *root = kernfs_root(kn);
1419 if (WARN_ON_ONCE(kernfs_type(kn) == KERNFS_DIR))
1425 kn->flags &= ~KERNFS_HIDDEN;
1426 if (kn->flags & KERNFS_ACTIVATED)
1427 kernfs_activate_one(kn);
1429 kn->flags |= KERNFS_HIDDEN;
1430 if (kernfs_active(kn))
1431 atomic_add(KN_DEACTIVATED_BIAS, &kn->active);
1432 kernfs_drain(kn);
1438 static void __kernfs_remove(struct kernfs_node *kn)
1442 /* Short-circuit if non-root @kn has already finished removal. */
1443 if (!kn)
1446 lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem);
1452 if (kn->parent && RB_EMPTY_NODE(&kn->rb))
1455 pr_debug("kernfs %s: removing\n", kn->name);
1459 while ((pos = kernfs_next_descendant_post(pos, kn))) {
1467 pos = kernfs_leftmost_descendant(kn);
1488 down_write(&kernfs_root(kn)->kernfs_iattr_rwsem);
1495 up_write(&kernfs_root(kn)->kernfs_iattr_rwsem);
1500 } while (pos != kn);
1505 * @kn: the kernfs_node to remove
1507 * Remove @kn along with all its subdirectories and files.
1509 void kernfs_remove(struct kernfs_node *kn)
1513 if (!kn)
1516 root = kernfs_root(kn);
1519 __kernfs_remove(kn);
1525 * @kn: the self kernfs_node
1532 * This function releases the active reference of @kn the caller is
1533 * holding. Once this function is called, @kn may be removed at any point
1537 void kernfs_break_active_protection(struct kernfs_node *kn)
1543 kernfs_put_active(kn);
1548 * @kn: the self kernfs_node
1553 * restore the active protection - @kn may already or be in the process of
1561 void kernfs_unbreak_active_protection(struct kernfs_node *kn)
1564 * @kn->active could be in any state; however, the increment we do
1566 * finishes and this temporary bump can't break anything. If @kn
1567 * is alive, nothing changes. If @kn is being deactivated, the
1569 * deactivated state. If @kn is already removed, the temporary
1570 * bump is guaranteed to be gone before @kn is released.
1572 atomic_inc(&kn->active);
1573 if (kernfs_lockdep(kn))
1574 rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_);
1579 * @kn: the self kernfs_node to remove
1603 * Return: %true if @kn is removed by this call, otherwise %false.
1605 bool kernfs_remove_self(struct kernfs_node *kn)
1608 struct kernfs_root *root = kernfs_root(kn);
1611 kernfs_break_active_protection(kn);
1622 if (!(kn->flags & KERNFS_SUICIDAL)) {
1623 kn->flags |= KERNFS_SUICIDAL;
1624 __kernfs_remove(kn);
1625 kn->flags |= KERNFS_SUICIDED;
1628 wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq;
1634 if ((kn->flags & KERNFS_SUICIDED) &&
1635 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS)
1643 WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb));
1651 kernfs_unbreak_active_protection(kn);
1670 struct kernfs_node *kn;
1682 kn = kernfs_find_ns(parent, name, ns);
1683 if (kn) {
1684 kernfs_get(kn);
1685 __kernfs_remove(kn);
1686 kernfs_put(kn);
1691 if (kn)
1699 * @kn: target node
1706 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
1715 if (!kn->parent)
1718 root = kernfs_root(kn);
1722 if (!kernfs_active(kn) || !kernfs_active(new_parent) ||
1727 if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
1728 (strcmp(kn->name, new_name) == 0))
1736 if (strcmp(kn->name, new_name) != 0) {
1748 kernfs_unlink_sibling(kn);
1754 old_parent = kn->parent;
1755 kn->parent = new_parent;
1757 kn->ns = new_ns;
1759 old_name = kn->name;
1760 kn->name = new_name;
1765 kn->hash = kernfs_name_hash(kn->name, kn->ns);
1766 kernfs_link_sibling(kn);