Lines Matching refs:kn
21 static DEFINE_SPINLOCK(kernfs_rename_lock); /* kn->parent and ->name */
35 static bool kernfs_active(struct kernfs_node *kn)
38 return atomic_read(&kn->active) >= 0;
41 static bool kernfs_lockdep(struct kernfs_node *kn)
44 return kn->flags & KERNFS_LOCKDEP;
50 static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen)
52 if (!kn)
55 return strlcpy(buf, kn->parent ? kn->name : "/", buflen);
79 da = kernfs_depth(ra->kn, a);
80 db = kernfs_depth(rb->kn, b);
134 struct kernfs_node *kn, *common;
143 kn_from = kernfs_root(kn_to)->kn;
166 for (kn = kn_to, j = 0; j < i; j++)
167 kn = kn->parent;
170 len += strlcpy(buf + len, kn->name,
179 * @kn: kernfs_node of interest
180 * @buf: buffer to copy @kn's name into
183 * Copies the name of @kn into @buf of @buflen bytes. The behavior is
184 * similar to strlcpy(). It returns the length of @kn's name and if @buf
187 * Fills buffer with "(null)" if @kn is NULL.
191 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
197 ret = kernfs_name_locked(kn, buf, buflen);
233 * @kn: kernfs_node of interest
237 void pr_cont_kernfs_name(struct kernfs_node *kn)
243 kernfs_name(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf));
251 * @kn: kernfs_node of interest
255 void pr_cont_kernfs_path(struct kernfs_node *kn)
262 sz = kernfs_path_from_node(kn, NULL, kernfs_pr_cont_buf,
282 * @kn: kernfs_node of interest
284 * Determines @kn's parent, pins and returns it. This function can be
287 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
293 parent = kn->parent;
324 const void *ns, const struct kernfs_node *kn)
326 if (hash < kn->hash)
328 if (hash > kn->hash)
330 if (ns < kn->ns)
332 if (ns > kn->ns)
334 return strcmp(name, kn->name);
345 * @kn: kernfs_node of interest
347 * Link @kn into its sibling rbtree which starts from
348 * @kn->parent->dir.children.
356 static int kernfs_link_sibling(struct kernfs_node *kn)
358 struct rb_node **node = &kn->parent->dir.children.rb_node;
367 result = kernfs_sd_compare(kn, pos);
377 rb_link_node(&kn->rb, parent, node);
378 rb_insert_color(&kn->rb, &kn->parent->dir.children);
381 if (kernfs_type(kn) == KERNFS_DIR)
382 kn->parent->dir.subdirs++;
389 * @kn: kernfs_node of interest
391 * Try to unlink @kn from its sibling rbtree which starts from
392 * kn->parent->dir.children. Returns %true if @kn was actually
393 * removed, %false if @kn wasn't on the rbtree.
398 static bool kernfs_unlink_sibling(struct kernfs_node *kn)
400 if (RB_EMPTY_NODE(&kn->rb))
403 if (kernfs_type(kn) == KERNFS_DIR)
404 kn->parent->dir.subdirs--;
406 rb_erase(&kn->rb, &kn->parent->dir.children);
407 RB_CLEAR_NODE(&kn->rb);
413 * @kn: kernfs_node to get an active reference to
415 * Get an active reference of @kn. This function is noop if @kn
419 * Pointer to @kn on success, NULL on failure.
421 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
423 if (unlikely(!kn))
426 if (!atomic_inc_unless_negative(&kn->active))
429 if (kernfs_lockdep(kn))
430 rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
431 return kn;
436 * @kn: kernfs_node to put an active reference to
438 * Put an active reference to @kn. This function is noop if @kn
441 void kernfs_put_active(struct kernfs_node *kn)
445 if (unlikely(!kn))
448 if (kernfs_lockdep(kn))
449 rwsem_release(&kn->dep_map, _RET_IP_);
450 v = atomic_dec_return(&kn->active);
454 wake_up_all(&kernfs_root(kn)->deactivate_waitq);
459 * @kn: kernfs_node to drain
461 * Drain existing usages and nuke all existing mmaps of @kn. Mutiple
462 * removers may invoke this function concurrently on @kn and all will
465 static void kernfs_drain(struct kernfs_node *kn)
468 struct kernfs_root *root = kernfs_root(kn);
471 WARN_ON_ONCE(kernfs_active(kn));
475 if (kernfs_lockdep(kn)) {
476 rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
477 if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
478 lock_contended(&kn->dep_map, _RET_IP_);
483 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
485 if (kernfs_lockdep(kn)) {
486 lock_acquired(&kn->dep_map, _RET_IP_);
487 rwsem_release(&kn->dep_map, _RET_IP_);
490 kernfs_drain_open_files(kn);
497 * @kn: the target kernfs_node
499 void kernfs_get(struct kernfs_node *kn)
501 if (kn) {
502 WARN_ON(!atomic_read(&kn->count));
503 atomic_inc(&kn->count);
510 * @kn: the target kernfs_node
512 * Put a reference count of @kn and destroy it if it reached zero.
514 void kernfs_put(struct kernfs_node *kn)
519 if (!kn || !atomic_dec_and_test(&kn->count))
521 root = kernfs_root(kn);
525 * kn->parent won't change beneath us.
527 parent = kn->parent;
529 WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
531 parent ? parent->name : "", kn->name, atomic_read(&kn->active));
533 if (kernfs_type(kn) == KERNFS_LINK)
534 kernfs_put(kn->symlink.target_kn);
536 kfree_const(kn->name);
538 if (kn->iattr) {
539 simple_xattrs_free(&kn->iattr->xattrs);
540 kmem_cache_free(kernfs_iattrs_cache, kn->iattr);
543 idr_remove(&root->ino_idr, (u32)kernfs_ino(kn));
545 kmem_cache_free(kernfs_node_cache, kn);
547 kn = parent;
548 if (kn) {
549 if (atomic_dec_and_test(&kn->count))
552 /* just released the root kn, free @root too */
561 struct kernfs_node *kn;
570 kn = kernfs_dentry_node(dentry);
574 if (!kernfs_active(kn))
578 if (kernfs_dentry_node(dentry->d_parent) != kn->parent)
582 if (strcmp(dentry->d_name.name, kn->name) != 0)
586 if (kn->parent && kernfs_ns_enabled(kn->parent) &&
587 kernfs_info(dentry->d_sb)->ns != kn->ns)
627 struct kernfs_node *kn;
635 kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
636 if (!kn)
641 ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC);
651 kn->id = (u64)id_highbits << 32 | ret;
653 atomic_set(&kn->count, 1);
654 atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
655 RB_CLEAR_NODE(&kn->rb);
657 kn->name = name;
658 kn->mode = mode;
659 kn->flags = flags;
668 ret = __kernfs_setattr(kn, &iattr);
674 ret = security_kernfs_init_security(parent, kn);
679 return kn;
683 idr_remove(&root->ino_idr, (u32)kernfs_ino(kn));
686 kmem_cache_free(kernfs_node_cache, kn);
697 struct kernfs_node *kn;
711 kn = __kernfs_new_node(kernfs_root(parent), parent,
713 if (kn) {
715 kn->parent = parent;
717 return kn;
734 struct kernfs_node *kn;
740 kn = idr_find(&root->ino_idr, (u32)ino);
741 if (!kn)
746 if (kernfs_ino(kn) != ino)
750 if (unlikely(gen && kernfs_gen(kn) != gen))
756 * @kn was added to idr and we just wanna see it set. No need to
759 if (unlikely(!(kn->flags & KERNFS_ACTIVATED) ||
760 !atomic_inc_not_zero(&kn->count)))
764 return kn;
772 * @kn: kernfs_node to be added
774 * The caller must already have initialized @kn->parent. This
775 * function increments nlink of the parent's inode if @kn is a
782 int kernfs_add_one(struct kernfs_node *kn)
784 struct kernfs_node *parent = kn->parent;
793 if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
794 has_ns ? "required" : "invalid", parent->name, kn->name))
807 kn->hash = kernfs_name_hash(kn->name, kn->ns);
809 ret = kernfs_link_sibling(kn);
829 if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
830 kernfs_activate(kn);
865 struct kernfs_node *kn;
868 kn = rb_to_kn(node);
869 result = kernfs_name_compare(hash, name, ns, kn);
875 return kn;
924 struct kernfs_node *kn;
927 kn = kernfs_find_ns(parent, name, ns);
928 kernfs_get(kn);
931 return kn;
948 struct kernfs_node *kn;
951 kn = kernfs_walk_ns(parent, path, ns);
952 kernfs_get(kn);
955 return kn;
971 struct kernfs_node *kn;
991 kn = __kernfs_new_node(root, NULL, "", S_IFDIR | S_IRUGO | S_IXUGO,
994 if (!kn) {
1000 kn->priv = priv;
1001 kn->dir.root = root;
1005 root->kn = kn;
1009 kernfs_activate(kn);
1023 kernfs_remove(root->kn); /* will also free @root */
1043 struct kernfs_node *kn;
1047 kn = kernfs_new_node(parent, name, mode | S_IFDIR,
1049 if (!kn)
1052 kn->dir.root = parent->dir.root;
1053 kn->ns = ns;
1054 kn->priv = priv;
1057 rc = kernfs_add_one(kn);
1059 return kn;
1061 kernfs_put(kn);
1075 struct kernfs_node *kn;
1079 kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR,
1081 if (!kn)
1084 kn->flags |= KERNFS_EMPTY_DIR;
1085 kn->dir.root = parent->dir.root;
1086 kn->ns = NULL;
1087 kn->priv = NULL;
1090 rc = kernfs_add_one(kn);
1092 return kn;
1094 kernfs_put(kn);
1104 struct kernfs_node *kn;
1113 kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
1116 if (!kn || !kernfs_active(kn)) {
1122 inode = kernfs_get_inode(dir->i_sb, kn);
1156 struct kernfs_node *kn = kernfs_dentry_node(dentry);
1157 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1163 if (!kernfs_get_active(kn))
1166 ret = scops->rmdir(kn);
1168 kernfs_put_active(kn);
1176 struct kernfs_node *kn = kernfs_dentry_node(old_dentry);
1178 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1187 if (!kernfs_get_active(kn))
1191 kernfs_put_active(kn);
1195 ret = scops->rename(kn, new_parent, new_dentry->d_name.name);
1198 kernfs_put_active(kn);
1271 * @kn: kernfs_node whose subtree is to be activated
1280 * after kernfs_remove*() is invoked on @kn.
1282 void kernfs_activate(struct kernfs_node *kn)
1289 while ((pos = kernfs_next_descendant_post(pos, kn))) {
1303 static void __kernfs_remove(struct kernfs_node *kn)
1310 * Short-circuit if non-root @kn has already finished removal.
1314 if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb)))
1317 pr_debug("kernfs %s: removing\n", kn->name);
1319 /* prevent any new usage under @kn by deactivating all nodes */
1321 while ((pos = kernfs_next_descendant_post(pos, kn)))
1327 pos = kernfs_leftmost_descendant(kn);
1338 * Drain iff @kn was activated. This avoids draining and
1343 if (kn->flags & KERNFS_ACTIVATED)
1346 WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS);
1366 } while (pos != kn);
1371 * @kn: the kernfs_node to remove
1373 * Remove @kn along with all its subdirectories and files.
1375 void kernfs_remove(struct kernfs_node *kn)
1378 __kernfs_remove(kn);
1384 * @kn: the self kernfs_node
1391 * This function releases the active reference of @kn the caller is
1392 * holding. Once this function is called, @kn may be removed at any point
1396 void kernfs_break_active_protection(struct kernfs_node *kn)
1402 kernfs_put_active(kn);
1407 * @kn: the self kernfs_node
1412 * restore the active protection - @kn may already or be in the process of
1420 void kernfs_unbreak_active_protection(struct kernfs_node *kn)
1423 * @kn->active could be in any state; however, the increment we do
1425 * finishes and this temporary bump can't break anything. If @kn
1426 * is alive, nothing changes. If @kn is being deactivated, the
1428 * deactivated state. If @kn is already removed, the temporary
1429 * bump is guaranteed to be gone before @kn is released.
1431 atomic_inc(&kn->active);
1432 if (kernfs_lockdep(kn))
1433 rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_);
1438 * @kn: the self kernfs_node to remove
1462 bool kernfs_remove_self(struct kernfs_node *kn)
1467 kernfs_break_active_protection(kn);
1478 if (!(kn->flags & KERNFS_SUICIDAL)) {
1479 kn->flags |= KERNFS_SUICIDAL;
1480 __kernfs_remove(kn);
1481 kn->flags |= KERNFS_SUICIDED;
1484 wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq;
1490 if ((kn->flags & KERNFS_SUICIDED) &&
1491 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS)
1499 WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb));
1507 kernfs_unbreak_active_protection(kn);
1525 struct kernfs_node *kn;
1535 kn = kernfs_find_ns(parent, name, ns);
1536 if (kn) {
1537 kernfs_get(kn);
1538 __kernfs_remove(kn);
1539 kernfs_put(kn);
1544 if (kn)
1552 * @kn: target node
1557 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
1565 if (!kn->parent)
1571 if (!kernfs_active(kn) || !kernfs_active(new_parent) ||
1576 if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
1577 (strcmp(kn->name, new_name) == 0))
1585 if (strcmp(kn->name, new_name) != 0) {
1597 kernfs_unlink_sibling(kn);
1603 old_parent = kn->parent;
1604 kn->parent = new_parent;
1606 kn->ns = new_ns;
1608 old_name = kn->name;
1609 kn->name = new_name;
1614 kn->hash = kernfs_name_hash(kn->name, kn->ns);
1615 kernfs_link_sibling(kn);
1627 static inline unsigned char dt_type(struct kernfs_node *kn)
1629 return (kn->mode >> 12) & 15;