155716d26SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2b8441ed2STejun Heo /* 3b8441ed2STejun Heo * fs/kernfs/dir.c - kernfs directory implementation 4b8441ed2STejun Heo * 5b8441ed2STejun Heo * Copyright (c) 2001-3 Patrick Mochel 6b8441ed2STejun Heo * Copyright (c) 2007 SUSE Linux Products GmbH 7b8441ed2STejun Heo * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 8b8441ed2STejun Heo */ 9fd7b9f7bSTejun Heo 10abd54f02STejun Heo #include <linux/sched.h> 11fd7b9f7bSTejun Heo #include <linux/fs.h> 12fd7b9f7bSTejun Heo #include <linux/namei.h> 13fd7b9f7bSTejun Heo #include <linux/idr.h> 14fd7b9f7bSTejun Heo #include <linux/slab.h> 15fd7b9f7bSTejun Heo #include <linux/security.h> 16fd7b9f7bSTejun Heo #include <linux/hash.h> 17fd7b9f7bSTejun Heo 18fd7b9f7bSTejun Heo #include "kernfs-internal.h" 19fd7b9f7bSTejun Heo 203eef34adSTejun Heo static DEFINE_SPINLOCK(kernfs_rename_lock); /* kn->parent and ->name */ 211a702dc8SHao Luo /* 221a702dc8SHao Luo * Don't use rename_lock to piggy back on pr_cont_buf. We don't want to 231a702dc8SHao Luo * call pr_cont() while holding rename_lock. Because sometimes pr_cont() 241a702dc8SHao Luo * will perform wakeups when releasing console_sem. Holding rename_lock 251a702dc8SHao Luo * will introduce deadlock if the scheduler reads the kernfs_name in the 261a702dc8SHao Luo * wakeup path. 271a702dc8SHao Luo */ 281a702dc8SHao Luo static DEFINE_SPINLOCK(kernfs_pr_cont_lock); 291a702dc8SHao Luo static char kernfs_pr_cont_buf[PATH_MAX]; /* protected by pr_cont_lock */ 307d35079fSShaohua Li static DEFINE_SPINLOCK(kernfs_idr_lock); /* root->ino_idr */ 31fd7b9f7bSTejun Heo 32adc5e8b5STejun Heo #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb) 33fd7b9f7bSTejun Heo 341edfe4eaSTejun Heo static bool __kernfs_active(struct kernfs_node *kn) 351edfe4eaSTejun Heo { 361edfe4eaSTejun Heo return atomic_read(&kn->active) >= 0; 371edfe4eaSTejun Heo } 381edfe4eaSTejun Heo 3981c173cbSTejun Heo static bool kernfs_active(struct kernfs_node *kn) 4081c173cbSTejun Heo { 41393c3714SMinchan Kim lockdep_assert_held(&kernfs_root(kn)->kernfs_rwsem); 421edfe4eaSTejun Heo return __kernfs_active(kn); 4381c173cbSTejun Heo } 4481c173cbSTejun Heo 45182fd64bSTejun Heo static bool kernfs_lockdep(struct kernfs_node *kn) 46182fd64bSTejun Heo { 47182fd64bSTejun Heo #ifdef CONFIG_DEBUG_LOCK_ALLOC 48182fd64bSTejun Heo return kn->flags & KERNFS_LOCKDEP; 49182fd64bSTejun Heo #else 50182fd64bSTejun Heo return false; 51182fd64bSTejun Heo #endif 52182fd64bSTejun Heo } 53182fd64bSTejun Heo 543eef34adSTejun Heo static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen) 553eef34adSTejun Heo { 5617627157SKonstantin Khlebnikov if (!kn) 5717627157SKonstantin Khlebnikov return strlcpy(buf, "(null)", buflen); 5817627157SKonstantin Khlebnikov 593eef34adSTejun Heo return strlcpy(buf, kn->parent ? kn->name : "/", buflen); 603eef34adSTejun Heo } 613eef34adSTejun Heo 629f6df573SAditya Kali /* kernfs_node_depth - compute depth from @from to @to */ 639f6df573SAditya Kali static size_t kernfs_depth(struct kernfs_node *from, struct kernfs_node *to) 643eef34adSTejun Heo { 659f6df573SAditya Kali size_t depth = 0; 663eef34adSTejun Heo 679f6df573SAditya Kali while (to->parent && to != from) { 689f6df573SAditya Kali depth++; 699f6df573SAditya Kali to = to->parent; 703eef34adSTejun Heo } 719f6df573SAditya Kali return depth; 729f6df573SAditya Kali } 733eef34adSTejun Heo 749f6df573SAditya Kali static struct kernfs_node *kernfs_common_ancestor(struct kernfs_node *a, 759f6df573SAditya Kali struct kernfs_node *b) 769f6df573SAditya Kali { 779f6df573SAditya Kali size_t da, db; 789f6df573SAditya Kali struct kernfs_root *ra = kernfs_root(a), *rb = kernfs_root(b); 799f6df573SAditya Kali 809f6df573SAditya Kali if (ra != rb) 819f6df573SAditya Kali return NULL; 829f6df573SAditya Kali 839f6df573SAditya Kali da = kernfs_depth(ra->kn, a); 849f6df573SAditya Kali db = kernfs_depth(rb->kn, b); 859f6df573SAditya Kali 869f6df573SAditya Kali while (da > db) { 879f6df573SAditya Kali a = a->parent; 889f6df573SAditya Kali da--; 899f6df573SAditya Kali } 909f6df573SAditya Kali while (db > da) { 919f6df573SAditya Kali b = b->parent; 929f6df573SAditya Kali db--; 939f6df573SAditya Kali } 949f6df573SAditya Kali 959f6df573SAditya Kali /* worst case b and a will be the same at root */ 969f6df573SAditya Kali while (b != a) { 979f6df573SAditya Kali b = b->parent; 989f6df573SAditya Kali a = a->parent; 999f6df573SAditya Kali } 1009f6df573SAditya Kali 1019f6df573SAditya Kali return a; 1029f6df573SAditya Kali } 1039f6df573SAditya Kali 1049f6df573SAditya Kali /** 1059f6df573SAditya Kali * kernfs_path_from_node_locked - find a pseudo-absolute path to @kn_to, 1069f6df573SAditya Kali * where kn_from is treated as root of the path. 1079f6df573SAditya Kali * @kn_from: kernfs node which should be treated as root for the path 1089f6df573SAditya Kali * @kn_to: kernfs node to which path is needed 1099f6df573SAditya Kali * @buf: buffer to copy the path into 1109f6df573SAditya Kali * @buflen: size of @buf 1119f6df573SAditya Kali * 1129f6df573SAditya Kali * We need to handle couple of scenarios here: 1139f6df573SAditya Kali * [1] when @kn_from is an ancestor of @kn_to at some level 1149f6df573SAditya Kali * kn_from: /n1/n2/n3 1159f6df573SAditya Kali * kn_to: /n1/n2/n3/n4/n5 1169f6df573SAditya Kali * result: /n4/n5 1179f6df573SAditya Kali * 1189f6df573SAditya Kali * [2] when @kn_from is on a different hierarchy and we need to find common 1199f6df573SAditya Kali * ancestor between @kn_from and @kn_to. 1209f6df573SAditya Kali * kn_from: /n1/n2/n3/n4 1219f6df573SAditya Kali * kn_to: /n1/n2/n5 1229f6df573SAditya Kali * result: /../../n5 1239f6df573SAditya Kali * OR 1249f6df573SAditya Kali * kn_from: /n1/n2/n3/n4/n5 [depth=5] 1259f6df573SAditya Kali * kn_to: /n1/n2/n3 [depth=3] 1269f6df573SAditya Kali * result: /../.. 1279f6df573SAditya Kali * 128*24b3e3ddSRandy Dunlap * [3] when @kn_to is %NULL result will be "(null)" 12917627157SKonstantin Khlebnikov * 130*24b3e3ddSRandy Dunlap * Return: the length of the full path. If the full length is equal to or 1313abb1d90STejun Heo * greater than @buflen, @buf contains the truncated path with the trailing 1323abb1d90STejun Heo * '\0'. On error, -errno is returned. 1339f6df573SAditya Kali */ 1349f6df573SAditya Kali static int kernfs_path_from_node_locked(struct kernfs_node *kn_to, 1359f6df573SAditya Kali struct kernfs_node *kn_from, 1369f6df573SAditya Kali char *buf, size_t buflen) 1379f6df573SAditya Kali { 1389f6df573SAditya Kali struct kernfs_node *kn, *common; 1399f6df573SAditya Kali const char parent_str[] = "/.."; 1403abb1d90STejun Heo size_t depth_from, depth_to, len = 0; 1413abb1d90STejun Heo int i, j; 1429f6df573SAditya Kali 14317627157SKonstantin Khlebnikov if (!kn_to) 14417627157SKonstantin Khlebnikov return strlcpy(buf, "(null)", buflen); 14517627157SKonstantin Khlebnikov 1469f6df573SAditya Kali if (!kn_from) 1479f6df573SAditya Kali kn_from = kernfs_root(kn_to)->kn; 1489f6df573SAditya Kali 1499f6df573SAditya Kali if (kn_from == kn_to) 1509f6df573SAditya Kali return strlcpy(buf, "/", buflen); 1519f6df573SAditya Kali 152bbe70e4eSJia-Ju Bai if (!buf) 153bbe70e4eSJia-Ju Bai return -EINVAL; 154bbe70e4eSJia-Ju Bai 1559f6df573SAditya Kali common = kernfs_common_ancestor(kn_from, kn_to); 1569f6df573SAditya Kali if (WARN_ON(!common)) 1573abb1d90STejun Heo return -EINVAL; 1589f6df573SAditya Kali 1599f6df573SAditya Kali depth_to = kernfs_depth(common, kn_to); 1609f6df573SAditya Kali depth_from = kernfs_depth(common, kn_from); 1619f6df573SAditya Kali 1629f6df573SAditya Kali buf[0] = '\0'; 1639f6df573SAditya Kali 1649f6df573SAditya Kali for (i = 0; i < depth_from; i++) 1659f6df573SAditya Kali len += strlcpy(buf + len, parent_str, 1669f6df573SAditya Kali len < buflen ? buflen - len : 0); 1679f6df573SAditya Kali 1689f6df573SAditya Kali /* Calculate how many bytes we need for the rest */ 1693abb1d90STejun Heo for (i = depth_to - 1; i >= 0; i--) { 1703abb1d90STejun Heo for (kn = kn_to, j = 0; j < i; j++) 1713abb1d90STejun Heo kn = kn->parent; 1723abb1d90STejun Heo len += strlcpy(buf + len, "/", 1733abb1d90STejun Heo len < buflen ? buflen - len : 0); 1743abb1d90STejun Heo len += strlcpy(buf + len, kn->name, 1753abb1d90STejun Heo len < buflen ? buflen - len : 0); 1769f6df573SAditya Kali } 1779f6df573SAditya Kali 1783abb1d90STejun Heo return len; 1793eef34adSTejun Heo } 1803eef34adSTejun Heo 1813eef34adSTejun Heo /** 1823eef34adSTejun Heo * kernfs_name - obtain the name of a given node 1833eef34adSTejun Heo * @kn: kernfs_node of interest 1843eef34adSTejun Heo * @buf: buffer to copy @kn's name into 1853eef34adSTejun Heo * @buflen: size of @buf 1863eef34adSTejun Heo * 1873eef34adSTejun Heo * Copies the name of @kn into @buf of @buflen bytes. The behavior is 188*24b3e3ddSRandy Dunlap * similar to strlcpy(). 1893eef34adSTejun Heo * 190*24b3e3ddSRandy Dunlap * Fills buffer with "(null)" if @kn is %NULL. 191*24b3e3ddSRandy Dunlap * 192*24b3e3ddSRandy Dunlap * Return: the length of @kn's name and if @buf isn't long enough, 193*24b3e3ddSRandy Dunlap * it's filled up to @buflen-1 and nul terminated. 19417627157SKonstantin Khlebnikov * 1953eef34adSTejun Heo * This function can be called from any context. 1963eef34adSTejun Heo */ 1973eef34adSTejun Heo int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 1983eef34adSTejun Heo { 1993eef34adSTejun Heo unsigned long flags; 2003eef34adSTejun Heo int ret; 2013eef34adSTejun Heo 2023eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 2033eef34adSTejun Heo ret = kernfs_name_locked(kn, buf, buflen); 2043eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 2053eef34adSTejun Heo return ret; 2063eef34adSTejun Heo } 2073eef34adSTejun Heo 2083eef34adSTejun Heo /** 2099f6df573SAditya Kali * kernfs_path_from_node - build path of node @to relative to @from. 2109f6df573SAditya Kali * @from: parent kernfs_node relative to which we need to build the path 2119f6df573SAditya Kali * @to: kernfs_node of interest 2129f6df573SAditya Kali * @buf: buffer to copy @to's path into 2139f6df573SAditya Kali * @buflen: size of @buf 2149f6df573SAditya Kali * 2159f6df573SAditya Kali * Builds @to's path relative to @from in @buf. @from and @to must 2169f6df573SAditya Kali * be on the same kernfs-root. If @from is not parent of @to, then a relative 2179f6df573SAditya Kali * path (which includes '..'s) as needed to reach from @from to @to is 2189f6df573SAditya Kali * returned. 2199f6df573SAditya Kali * 220*24b3e3ddSRandy Dunlap * Return: the length of the full path. If the full length is equal to or 2213abb1d90STejun Heo * greater than @buflen, @buf contains the truncated path with the trailing 2223abb1d90STejun Heo * '\0'. On error, -errno is returned. 2239f6df573SAditya Kali */ 2249f6df573SAditya Kali int kernfs_path_from_node(struct kernfs_node *to, struct kernfs_node *from, 2259f6df573SAditya Kali char *buf, size_t buflen) 2269f6df573SAditya Kali { 2279f6df573SAditya Kali unsigned long flags; 2289f6df573SAditya Kali int ret; 2299f6df573SAditya Kali 2309f6df573SAditya Kali spin_lock_irqsave(&kernfs_rename_lock, flags); 2319f6df573SAditya Kali ret = kernfs_path_from_node_locked(to, from, buf, buflen); 2329f6df573SAditya Kali spin_unlock_irqrestore(&kernfs_rename_lock, flags); 2339f6df573SAditya Kali return ret; 2349f6df573SAditya Kali } 2359f6df573SAditya Kali EXPORT_SYMBOL_GPL(kernfs_path_from_node); 2369f6df573SAditya Kali 2379f6df573SAditya Kali /** 2383eef34adSTejun Heo * pr_cont_kernfs_name - pr_cont name of a kernfs_node 2393eef34adSTejun Heo * @kn: kernfs_node of interest 2403eef34adSTejun Heo * 2413eef34adSTejun Heo * This function can be called from any context. 2423eef34adSTejun Heo */ 2433eef34adSTejun Heo void pr_cont_kernfs_name(struct kernfs_node *kn) 2443eef34adSTejun Heo { 2453eef34adSTejun Heo unsigned long flags; 2463eef34adSTejun Heo 2471a702dc8SHao Luo spin_lock_irqsave(&kernfs_pr_cont_lock, flags); 2483eef34adSTejun Heo 2491a702dc8SHao Luo kernfs_name(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf)); 2503eef34adSTejun Heo pr_cont("%s", kernfs_pr_cont_buf); 2513eef34adSTejun Heo 2521a702dc8SHao Luo spin_unlock_irqrestore(&kernfs_pr_cont_lock, flags); 2533eef34adSTejun Heo } 2543eef34adSTejun Heo 2553eef34adSTejun Heo /** 2563eef34adSTejun Heo * pr_cont_kernfs_path - pr_cont path of a kernfs_node 2573eef34adSTejun Heo * @kn: kernfs_node of interest 2583eef34adSTejun Heo * 2593eef34adSTejun Heo * This function can be called from any context. 2603eef34adSTejun Heo */ 2613eef34adSTejun Heo void pr_cont_kernfs_path(struct kernfs_node *kn) 2623eef34adSTejun Heo { 2633eef34adSTejun Heo unsigned long flags; 2649f6df573SAditya Kali int sz; 2653eef34adSTejun Heo 2661a702dc8SHao Luo spin_lock_irqsave(&kernfs_pr_cont_lock, flags); 2673eef34adSTejun Heo 2681a702dc8SHao Luo sz = kernfs_path_from_node(kn, NULL, kernfs_pr_cont_buf, 2693eef34adSTejun Heo sizeof(kernfs_pr_cont_buf)); 2709f6df573SAditya Kali if (sz < 0) { 2719f6df573SAditya Kali pr_cont("(error)"); 2729f6df573SAditya Kali goto out; 2739f6df573SAditya Kali } 2743eef34adSTejun Heo 2759f6df573SAditya Kali if (sz >= sizeof(kernfs_pr_cont_buf)) { 2769f6df573SAditya Kali pr_cont("(name too long)"); 2779f6df573SAditya Kali goto out; 2789f6df573SAditya Kali } 2799f6df573SAditya Kali 2809f6df573SAditya Kali pr_cont("%s", kernfs_pr_cont_buf); 2819f6df573SAditya Kali 2829f6df573SAditya Kali out: 2831a702dc8SHao Luo spin_unlock_irqrestore(&kernfs_pr_cont_lock, flags); 2843eef34adSTejun Heo } 2853eef34adSTejun Heo 2863eef34adSTejun Heo /** 2873eef34adSTejun Heo * kernfs_get_parent - determine the parent node and pin it 2883eef34adSTejun Heo * @kn: kernfs_node of interest 2893eef34adSTejun Heo * 2903eef34adSTejun Heo * Determines @kn's parent, pins and returns it. This function can be 2913eef34adSTejun Heo * called from any context. 292*24b3e3ddSRandy Dunlap * 293*24b3e3ddSRandy Dunlap * Return: parent node of @kn 2943eef34adSTejun Heo */ 2953eef34adSTejun Heo struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 2963eef34adSTejun Heo { 2973eef34adSTejun Heo struct kernfs_node *parent; 2983eef34adSTejun Heo unsigned long flags; 2993eef34adSTejun Heo 3003eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 3013eef34adSTejun Heo parent = kn->parent; 3023eef34adSTejun Heo kernfs_get(parent); 3033eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 3043eef34adSTejun Heo 3053eef34adSTejun Heo return parent; 3063eef34adSTejun Heo } 3073eef34adSTejun Heo 308fd7b9f7bSTejun Heo /** 309*24b3e3ddSRandy Dunlap * kernfs_name_hash - calculate hash of @ns + @name 310fd7b9f7bSTejun Heo * @name: Null terminated string to hash 311fd7b9f7bSTejun Heo * @ns: Namespace tag to hash 312fd7b9f7bSTejun Heo * 313*24b3e3ddSRandy Dunlap * Return: 31-bit hash of ns + name (so it fits in an off_t) 314fd7b9f7bSTejun Heo */ 315c637b8acSTejun Heo static unsigned int kernfs_name_hash(const char *name, const void *ns) 316fd7b9f7bSTejun Heo { 3178387ff25SLinus Torvalds unsigned long hash = init_name_hash(ns); 318fd7b9f7bSTejun Heo unsigned int len = strlen(name); 319fd7b9f7bSTejun Heo while (len--) 320fd7b9f7bSTejun Heo hash = partial_name_hash(*name++, hash); 3218387ff25SLinus Torvalds hash = end_name_hash(hash); 322fd7b9f7bSTejun Heo hash &= 0x7fffffffU; 323fd7b9f7bSTejun Heo /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */ 32488391d49SRichard Cochran if (hash < 2) 325fd7b9f7bSTejun Heo hash += 2; 326fd7b9f7bSTejun Heo if (hash >= INT_MAX) 327fd7b9f7bSTejun Heo hash = INT_MAX - 1; 328fd7b9f7bSTejun Heo return hash; 329fd7b9f7bSTejun Heo } 330fd7b9f7bSTejun Heo 331c637b8acSTejun Heo static int kernfs_name_compare(unsigned int hash, const char *name, 332324a56e1STejun Heo const void *ns, const struct kernfs_node *kn) 333fd7b9f7bSTejun Heo { 33472392ed0SRasmus Villemoes if (hash < kn->hash) 33572392ed0SRasmus Villemoes return -1; 33672392ed0SRasmus Villemoes if (hash > kn->hash) 33772392ed0SRasmus Villemoes return 1; 33872392ed0SRasmus Villemoes if (ns < kn->ns) 33972392ed0SRasmus Villemoes return -1; 34072392ed0SRasmus Villemoes if (ns > kn->ns) 34172392ed0SRasmus Villemoes return 1; 342adc5e8b5STejun Heo return strcmp(name, kn->name); 343fd7b9f7bSTejun Heo } 344fd7b9f7bSTejun Heo 345c637b8acSTejun Heo static int kernfs_sd_compare(const struct kernfs_node *left, 346324a56e1STejun Heo const struct kernfs_node *right) 347fd7b9f7bSTejun Heo { 348c637b8acSTejun Heo return kernfs_name_compare(left->hash, left->name, left->ns, right); 349fd7b9f7bSTejun Heo } 350fd7b9f7bSTejun Heo 351fd7b9f7bSTejun Heo /** 352c637b8acSTejun Heo * kernfs_link_sibling - link kernfs_node into sibling rbtree 353324a56e1STejun Heo * @kn: kernfs_node of interest 354fd7b9f7bSTejun Heo * 355324a56e1STejun Heo * Link @kn into its sibling rbtree which starts from 356adc5e8b5STejun Heo * @kn->parent->dir.children. 357fd7b9f7bSTejun Heo * 358fd7b9f7bSTejun Heo * Locking: 3597ba0273bSIan Kent * kernfs_rwsem held exclusive 360fd7b9f7bSTejun Heo * 361*24b3e3ddSRandy Dunlap * Return: 362*24b3e3ddSRandy Dunlap * %0 on success, -EEXIST on failure. 363fd7b9f7bSTejun Heo */ 364c637b8acSTejun Heo static int kernfs_link_sibling(struct kernfs_node *kn) 365fd7b9f7bSTejun Heo { 366adc5e8b5STejun Heo struct rb_node **node = &kn->parent->dir.children.rb_node; 367fd7b9f7bSTejun Heo struct rb_node *parent = NULL; 368fd7b9f7bSTejun Heo 369fd7b9f7bSTejun Heo while (*node) { 370324a56e1STejun Heo struct kernfs_node *pos; 371fd7b9f7bSTejun Heo int result; 372fd7b9f7bSTejun Heo 373324a56e1STejun Heo pos = rb_to_kn(*node); 374fd7b9f7bSTejun Heo parent = *node; 375c637b8acSTejun Heo result = kernfs_sd_compare(kn, pos); 376fd7b9f7bSTejun Heo if (result < 0) 377adc5e8b5STejun Heo node = &pos->rb.rb_left; 378fd7b9f7bSTejun Heo else if (result > 0) 379adc5e8b5STejun Heo node = &pos->rb.rb_right; 380fd7b9f7bSTejun Heo else 381fd7b9f7bSTejun Heo return -EEXIST; 382fd7b9f7bSTejun Heo } 383c1befb88SJianyu Zhan 384fd7b9f7bSTejun Heo /* add new node and rebalance the tree */ 385adc5e8b5STejun Heo rb_link_node(&kn->rb, parent, node); 386adc5e8b5STejun Heo rb_insert_color(&kn->rb, &kn->parent->dir.children); 387c1befb88SJianyu Zhan 388c1befb88SJianyu Zhan /* successfully added, account subdir number */ 389c1befb88SJianyu Zhan if (kernfs_type(kn) == KERNFS_DIR) 390c1befb88SJianyu Zhan kn->parent->dir.subdirs++; 391895adbecSIan Kent kernfs_inc_rev(kn->parent); 392c1befb88SJianyu Zhan 393fd7b9f7bSTejun Heo return 0; 394fd7b9f7bSTejun Heo } 395fd7b9f7bSTejun Heo 396fd7b9f7bSTejun Heo /** 397c637b8acSTejun Heo * kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree 398324a56e1STejun Heo * @kn: kernfs_node of interest 399fd7b9f7bSTejun Heo * 40035beab06STejun Heo * Try to unlink @kn from its sibling rbtree which starts from 401*24b3e3ddSRandy Dunlap * kn->parent->dir.children. 402*24b3e3ddSRandy Dunlap * 403*24b3e3ddSRandy Dunlap * Return: %true if @kn was actually removed, 404*24b3e3ddSRandy Dunlap * %false if @kn wasn't on the rbtree. 405fd7b9f7bSTejun Heo * 406fd7b9f7bSTejun Heo * Locking: 4077ba0273bSIan Kent * kernfs_rwsem held exclusive 408fd7b9f7bSTejun Heo */ 40935beab06STejun Heo static bool kernfs_unlink_sibling(struct kernfs_node *kn) 410fd7b9f7bSTejun Heo { 41135beab06STejun Heo if (RB_EMPTY_NODE(&kn->rb)) 41235beab06STejun Heo return false; 41335beab06STejun Heo 414df23fc39STejun Heo if (kernfs_type(kn) == KERNFS_DIR) 415adc5e8b5STejun Heo kn->parent->dir.subdirs--; 416895adbecSIan Kent kernfs_inc_rev(kn->parent); 417fd7b9f7bSTejun Heo 418adc5e8b5STejun Heo rb_erase(&kn->rb, &kn->parent->dir.children); 41935beab06STejun Heo RB_CLEAR_NODE(&kn->rb); 42035beab06STejun Heo return true; 421fd7b9f7bSTejun Heo } 422fd7b9f7bSTejun Heo 423fd7b9f7bSTejun Heo /** 424c637b8acSTejun Heo * kernfs_get_active - get an active reference to kernfs_node 425324a56e1STejun Heo * @kn: kernfs_node to get an active reference to 426fd7b9f7bSTejun Heo * 427324a56e1STejun Heo * Get an active reference of @kn. This function is noop if @kn 428*24b3e3ddSRandy Dunlap * is %NULL. 429fd7b9f7bSTejun Heo * 430*24b3e3ddSRandy Dunlap * Return: 431*24b3e3ddSRandy Dunlap * Pointer to @kn on success, %NULL on failure. 432fd7b9f7bSTejun Heo */ 433c637b8acSTejun Heo struct kernfs_node *kernfs_get_active(struct kernfs_node *kn) 434fd7b9f7bSTejun Heo { 435324a56e1STejun Heo if (unlikely(!kn)) 436fd7b9f7bSTejun Heo return NULL; 437fd7b9f7bSTejun Heo 438f4b3e631SGreg Kroah-Hartman if (!atomic_inc_unless_negative(&kn->active)) 439f4b3e631SGreg Kroah-Hartman return NULL; 440f4b3e631SGreg Kroah-Hartman 441182fd64bSTejun Heo if (kernfs_lockdep(kn)) 442324a56e1STejun Heo rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_); 443324a56e1STejun Heo return kn; 444fd7b9f7bSTejun Heo } 445fd7b9f7bSTejun Heo 446fd7b9f7bSTejun Heo /** 447c637b8acSTejun Heo * kernfs_put_active - put an active reference to kernfs_node 448324a56e1STejun Heo * @kn: kernfs_node to put an active reference to 449fd7b9f7bSTejun Heo * 450324a56e1STejun Heo * Put an active reference to @kn. This function is noop if @kn 451*24b3e3ddSRandy Dunlap * is %NULL. 452fd7b9f7bSTejun Heo */ 453c637b8acSTejun Heo void kernfs_put_active(struct kernfs_node *kn) 454fd7b9f7bSTejun Heo { 455fd7b9f7bSTejun Heo int v; 456fd7b9f7bSTejun Heo 457324a56e1STejun Heo if (unlikely(!kn)) 458fd7b9f7bSTejun Heo return; 459fd7b9f7bSTejun Heo 460182fd64bSTejun Heo if (kernfs_lockdep(kn)) 4615facae4fSQian Cai rwsem_release(&kn->dep_map, _RET_IP_); 462adc5e8b5STejun Heo v = atomic_dec_return(&kn->active); 463df23fc39STejun Heo if (likely(v != KN_DEACTIVATED_BIAS)) 464fd7b9f7bSTejun Heo return; 465fd7b9f7bSTejun Heo 4662fd60da4SPeng Wang wake_up_all(&kernfs_root(kn)->deactivate_waitq); 467fd7b9f7bSTejun Heo } 468fd7b9f7bSTejun Heo 469fd7b9f7bSTejun Heo /** 47081c173cbSTejun Heo * kernfs_drain - drain kernfs_node 47181c173cbSTejun Heo * @kn: kernfs_node to drain 472fd7b9f7bSTejun Heo * 473*24b3e3ddSRandy Dunlap * Drain existing usages and nuke all existing mmaps of @kn. Multiple 47481c173cbSTejun Heo * removers may invoke this function concurrently on @kn and all will 47581c173cbSTejun Heo * return after draining is complete. 476fd7b9f7bSTejun Heo */ 47781c173cbSTejun Heo static void kernfs_drain(struct kernfs_node *kn) 478393c3714SMinchan Kim __releases(&kernfs_root(kn)->kernfs_rwsem) 479393c3714SMinchan Kim __acquires(&kernfs_root(kn)->kernfs_rwsem) 480fd7b9f7bSTejun Heo { 481abd54f02STejun Heo struct kernfs_root *root = kernfs_root(kn); 482fd7b9f7bSTejun Heo 483393c3714SMinchan Kim lockdep_assert_held_write(&root->kernfs_rwsem); 48481c173cbSTejun Heo WARN_ON_ONCE(kernfs_active(kn)); 485abd54f02STejun Heo 4862d7f9f8cSTejun Heo /* 4872d7f9f8cSTejun Heo * Skip draining if already fully drained. This avoids draining and its 4882d7f9f8cSTejun Heo * lockdep annotations for nodes which have never been activated 4892d7f9f8cSTejun Heo * allowing embedding kernfs_remove() in create error paths without 4902d7f9f8cSTejun Heo * worrying about draining. 4912d7f9f8cSTejun Heo */ 4922d7f9f8cSTejun Heo if (atomic_read(&kn->active) == KN_DEACTIVATED_BIAS && 4932d7f9f8cSTejun Heo !kernfs_should_drain_open_files(kn)) 4942d7f9f8cSTejun Heo return; 4952d7f9f8cSTejun Heo 496393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 497abd54f02STejun Heo 498182fd64bSTejun Heo if (kernfs_lockdep(kn)) { 49935beab06STejun Heo rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_); 50035beab06STejun Heo if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS) 50135beab06STejun Heo lock_contended(&kn->dep_map, _RET_IP_); 50235beab06STejun Heo } 50335beab06STejun Heo 504abd54f02STejun Heo wait_event(root->deactivate_waitq, 505abd54f02STejun Heo atomic_read(&kn->active) == KN_DEACTIVATED_BIAS); 506fd7b9f7bSTejun Heo 507182fd64bSTejun Heo if (kernfs_lockdep(kn)) { 508324a56e1STejun Heo lock_acquired(&kn->dep_map, _RET_IP_); 5095facae4fSQian Cai rwsem_release(&kn->dep_map, _RET_IP_); 510fd7b9f7bSTejun Heo } 51135beab06STejun Heo 512bdb2fd7fSTejun Heo if (kernfs_should_drain_open_files(kn)) 5130e67db2fSTejun Heo kernfs_drain_open_files(kn); 514ccf02aafSTejun Heo 515393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 516a6607930STejun Heo } 517fd7b9f7bSTejun Heo 518fd7b9f7bSTejun Heo /** 519324a56e1STejun Heo * kernfs_get - get a reference count on a kernfs_node 520324a56e1STejun Heo * @kn: the target kernfs_node 521fd7b9f7bSTejun Heo */ 522324a56e1STejun Heo void kernfs_get(struct kernfs_node *kn) 523fd7b9f7bSTejun Heo { 524324a56e1STejun Heo if (kn) { 525adc5e8b5STejun Heo WARN_ON(!atomic_read(&kn->count)); 526adc5e8b5STejun Heo atomic_inc(&kn->count); 527fd7b9f7bSTejun Heo } 528fd7b9f7bSTejun Heo } 529fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_get); 530fd7b9f7bSTejun Heo 531fd7b9f7bSTejun Heo /** 532324a56e1STejun Heo * kernfs_put - put a reference count on a kernfs_node 533324a56e1STejun Heo * @kn: the target kernfs_node 534fd7b9f7bSTejun Heo * 535324a56e1STejun Heo * Put a reference count of @kn and destroy it if it reached zero. 536fd7b9f7bSTejun Heo */ 537324a56e1STejun Heo void kernfs_put(struct kernfs_node *kn) 538fd7b9f7bSTejun Heo { 539324a56e1STejun Heo struct kernfs_node *parent; 540ba7443bcSTejun Heo struct kernfs_root *root; 541fd7b9f7bSTejun Heo 542adc5e8b5STejun Heo if (!kn || !atomic_dec_and_test(&kn->count)) 543fd7b9f7bSTejun Heo return; 544324a56e1STejun Heo root = kernfs_root(kn); 545fd7b9f7bSTejun Heo repeat: 54681c173cbSTejun Heo /* 54781c173cbSTejun Heo * Moving/renaming is always done while holding reference. 548adc5e8b5STejun Heo * kn->parent won't change beneath us. 549fd7b9f7bSTejun Heo */ 550adc5e8b5STejun Heo parent = kn->parent; 551fd7b9f7bSTejun Heo 55281c173cbSTejun Heo WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS, 55381c173cbSTejun Heo "kernfs_put: %s/%s: released with incorrect active_ref %d\n", 55481c173cbSTejun Heo parent ? parent->name : "", kn->name, atomic_read(&kn->active)); 555fd7b9f7bSTejun Heo 556df23fc39STejun Heo if (kernfs_type(kn) == KERNFS_LINK) 557adc5e8b5STejun Heo kernfs_put(kn->symlink.target_kn); 558dfeb0750STejun Heo 55975287a67SAndrzej Hajda kfree_const(kn->name); 560dfeb0750STejun Heo 561adc5e8b5STejun Heo if (kn->iattr) { 562adc5e8b5STejun Heo simple_xattrs_free(&kn->iattr->xattrs); 56326e28d68SAyush Mittal kmem_cache_free(kernfs_iattrs_cache, kn->iattr); 5642322392bSTejun Heo } 5657d35079fSShaohua Li spin_lock(&kernfs_idr_lock); 56640430452STejun Heo idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); 5677d35079fSShaohua Li spin_unlock(&kernfs_idr_lock); 568a797bfc3STejun Heo kmem_cache_free(kernfs_node_cache, kn); 569fd7b9f7bSTejun Heo 570324a56e1STejun Heo kn = parent; 571324a56e1STejun Heo if (kn) { 572adc5e8b5STejun Heo if (atomic_dec_and_test(&kn->count)) 573fd7b9f7bSTejun Heo goto repeat; 574ba7443bcSTejun Heo } else { 575324a56e1STejun Heo /* just released the root kn, free @root too */ 5767d35079fSShaohua Li idr_destroy(&root->ino_idr); 577ba7443bcSTejun Heo kfree(root); 578ba7443bcSTejun Heo } 579fd7b9f7bSTejun Heo } 580fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_put); 581fd7b9f7bSTejun Heo 5820c23b225STejun Heo /** 5830c23b225STejun Heo * kernfs_node_from_dentry - determine kernfs_node associated with a dentry 5840c23b225STejun Heo * @dentry: the dentry in question 5850c23b225STejun Heo * 586*24b3e3ddSRandy Dunlap * Return: the kernfs_node associated with @dentry. If @dentry is not a 5870c23b225STejun Heo * kernfs one, %NULL is returned. 5880c23b225STejun Heo * 5890c23b225STejun Heo * While the returned kernfs_node will stay accessible as long as @dentry 5900c23b225STejun Heo * is accessible, the returned node can be in any state and the caller is 5910c23b225STejun Heo * fully responsible for determining what's accessible. 5920c23b225STejun Heo */ 5930c23b225STejun Heo struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 5940c23b225STejun Heo { 5950288e7faSHui Su if (dentry->d_sb->s_op == &kernfs_sops) 596319ba91dSShaohua Li return kernfs_dentry_node(dentry); 5970c23b225STejun Heo return NULL; 5980c23b225STejun Heo } 5990c23b225STejun Heo 600db4aad20STejun Heo static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root, 601e19dfdc8SOndrej Mosnacek struct kernfs_node *parent, 602db4aad20STejun Heo const char *name, umode_t mode, 603488dee96SDmitry Torokhov kuid_t uid, kgid_t gid, 604db4aad20STejun Heo unsigned flags) 605fd7b9f7bSTejun Heo { 606324a56e1STejun Heo struct kernfs_node *kn; 60740430452STejun Heo u32 id_highbits; 608bc755553STejun Heo int ret; 609fd7b9f7bSTejun Heo 610dfeb0750STejun Heo name = kstrdup_const(name, GFP_KERNEL); 611fd7b9f7bSTejun Heo if (!name) 612fd7b9f7bSTejun Heo return NULL; 613fd7b9f7bSTejun Heo 614a797bfc3STejun Heo kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL); 615324a56e1STejun Heo if (!kn) 616fd7b9f7bSTejun Heo goto err_out1; 617fd7b9f7bSTejun Heo 6187d35079fSShaohua Li idr_preload(GFP_KERNEL); 6197d35079fSShaohua Li spin_lock(&kernfs_idr_lock); 6204a3ef68aSShaohua Li ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC); 62140430452STejun Heo if (ret >= 0 && ret < root->last_id_lowbits) 62240430452STejun Heo root->id_highbits++; 62340430452STejun Heo id_highbits = root->id_highbits; 62440430452STejun Heo root->last_id_lowbits = ret; 6257d35079fSShaohua Li spin_unlock(&kernfs_idr_lock); 6267d35079fSShaohua Li idr_preload_end(); 627bc755553STejun Heo if (ret < 0) 628fd7b9f7bSTejun Heo goto err_out2; 62967c0496eSTejun Heo 63040430452STejun Heo kn->id = (u64)id_highbits << 32 | ret; 631fd7b9f7bSTejun Heo 632b680b081STejun Heo atomic_set(&kn->count, 1); 63381c173cbSTejun Heo atomic_set(&kn->active, KN_DEACTIVATED_BIAS); 63435beab06STejun Heo RB_CLEAR_NODE(&kn->rb); 635fd7b9f7bSTejun Heo 636adc5e8b5STejun Heo kn->name = name; 637adc5e8b5STejun Heo kn->mode = mode; 63881c173cbSTejun Heo kn->flags = flags; 639fd7b9f7bSTejun Heo 640488dee96SDmitry Torokhov if (!uid_eq(uid, GLOBAL_ROOT_UID) || !gid_eq(gid, GLOBAL_ROOT_GID)) { 641488dee96SDmitry Torokhov struct iattr iattr = { 642488dee96SDmitry Torokhov .ia_valid = ATTR_UID | ATTR_GID, 643488dee96SDmitry Torokhov .ia_uid = uid, 644488dee96SDmitry Torokhov .ia_gid = gid, 645488dee96SDmitry Torokhov }; 646488dee96SDmitry Torokhov 647488dee96SDmitry Torokhov ret = __kernfs_setattr(kn, &iattr); 648488dee96SDmitry Torokhov if (ret < 0) 649488dee96SDmitry Torokhov goto err_out3; 650488dee96SDmitry Torokhov } 651488dee96SDmitry Torokhov 652e19dfdc8SOndrej Mosnacek if (parent) { 653e19dfdc8SOndrej Mosnacek ret = security_kernfs_init_security(parent, kn); 654e19dfdc8SOndrej Mosnacek if (ret) 655e19dfdc8SOndrej Mosnacek goto err_out3; 656e19dfdc8SOndrej Mosnacek } 657e19dfdc8SOndrej Mosnacek 658324a56e1STejun Heo return kn; 659fd7b9f7bSTejun Heo 660488dee96SDmitry Torokhov err_out3: 66140430452STejun Heo idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); 662fd7b9f7bSTejun Heo err_out2: 663a797bfc3STejun Heo kmem_cache_free(kernfs_node_cache, kn); 664fd7b9f7bSTejun Heo err_out1: 665dfeb0750STejun Heo kfree_const(name); 666fd7b9f7bSTejun Heo return NULL; 667fd7b9f7bSTejun Heo } 668fd7b9f7bSTejun Heo 669db4aad20STejun Heo struct kernfs_node *kernfs_new_node(struct kernfs_node *parent, 670db4aad20STejun Heo const char *name, umode_t mode, 671488dee96SDmitry Torokhov kuid_t uid, kgid_t gid, 672db4aad20STejun Heo unsigned flags) 673db4aad20STejun Heo { 674db4aad20STejun Heo struct kernfs_node *kn; 675db4aad20STejun Heo 676e19dfdc8SOndrej Mosnacek kn = __kernfs_new_node(kernfs_root(parent), parent, 677488dee96SDmitry Torokhov name, mode, uid, gid, flags); 678db4aad20STejun Heo if (kn) { 679db4aad20STejun Heo kernfs_get(parent); 680db4aad20STejun Heo kn->parent = parent; 681db4aad20STejun Heo } 682db4aad20STejun Heo return kn; 683db4aad20STejun Heo } 684db4aad20STejun Heo 685ba16b284SShaohua Li /* 686fe0f726cSTejun Heo * kernfs_find_and_get_node_by_id - get kernfs_node from node id 687ba16b284SShaohua Li * @root: the kernfs root 688fe0f726cSTejun Heo * @id: the target node id 689fe0f726cSTejun Heo * 690fe0f726cSTejun Heo * @id's lower 32bits encode ino and upper gen. If the gen portion is 691fe0f726cSTejun Heo * zero, all generations are matched. 692ba16b284SShaohua Li * 693*24b3e3ddSRandy Dunlap * Return: %NULL on failure, 694*24b3e3ddSRandy Dunlap * otherwise a kernfs node with reference counter incremented. 695ba16b284SShaohua Li */ 696fe0f726cSTejun Heo struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root, 697fe0f726cSTejun Heo u64 id) 698ba16b284SShaohua Li { 699ba16b284SShaohua Li struct kernfs_node *kn; 700fe0f726cSTejun Heo ino_t ino = kernfs_id_ino(id); 701fe0f726cSTejun Heo u32 gen = kernfs_id_gen(id); 702ba16b284SShaohua Li 703b680b081STejun Heo spin_lock(&kernfs_idr_lock); 704b680b081STejun Heo 70540430452STejun Heo kn = idr_find(&root->ino_idr, (u32)ino); 706ba16b284SShaohua Li if (!kn) 707b680b081STejun Heo goto err_unlock; 708ba16b284SShaohua Li 70940430452STejun Heo if (sizeof(ino_t) >= sizeof(u64)) { 71040430452STejun Heo /* we looked up with the low 32bits, compare the whole */ 71140430452STejun Heo if (kernfs_ino(kn) != ino) 71240430452STejun Heo goto err_unlock; 71340430452STejun Heo } else { 714fe0f726cSTejun Heo /* 0 matches all generations */ 715fe0f726cSTejun Heo if (unlikely(gen && kernfs_gen(kn) != gen)) 716fe0f726cSTejun Heo goto err_unlock; 71740430452STejun Heo } 718fe0f726cSTejun Heo 7191edfe4eaSTejun Heo /* 7201edfe4eaSTejun Heo * We should fail if @kn has never been activated and guarantee success 7211edfe4eaSTejun Heo * if the caller knows that @kn is active. Both can be achieved by 7221edfe4eaSTejun Heo * __kernfs_active() which tests @kn->active without kernfs_rwsem. 7231edfe4eaSTejun Heo */ 7241edfe4eaSTejun Heo if (unlikely(!__kernfs_active(kn) || !atomic_inc_not_zero(&kn->count))) 725b680b081STejun Heo goto err_unlock; 726ba16b284SShaohua Li 727b680b081STejun Heo spin_unlock(&kernfs_idr_lock); 728ba16b284SShaohua Li return kn; 729b680b081STejun Heo err_unlock: 730b680b081STejun Heo spin_unlock(&kernfs_idr_lock); 731ba16b284SShaohua Li return NULL; 732ba16b284SShaohua Li } 733ba16b284SShaohua Li 734fd7b9f7bSTejun Heo /** 735c637b8acSTejun Heo * kernfs_add_one - add kernfs_node to parent without warning 736324a56e1STejun Heo * @kn: kernfs_node to be added 737fd7b9f7bSTejun Heo * 738db4aad20STejun Heo * The caller must already have initialized @kn->parent. This 739db4aad20STejun Heo * function increments nlink of the parent's inode if @kn is a 740db4aad20STejun Heo * directory and link into the children list of the parent. 741fd7b9f7bSTejun Heo * 742*24b3e3ddSRandy Dunlap * Return: 743*24b3e3ddSRandy Dunlap * %0 on success, -EEXIST if entry with the given name already 744fd7b9f7bSTejun Heo * exists. 745fd7b9f7bSTejun Heo */ 746988cd7afSTejun Heo int kernfs_add_one(struct kernfs_node *kn) 747fd7b9f7bSTejun Heo { 748db4aad20STejun Heo struct kernfs_node *parent = kn->parent; 749393c3714SMinchan Kim struct kernfs_root *root = kernfs_root(parent); 750c525aaddSTejun Heo struct kernfs_iattrs *ps_iattr; 751988cd7afSTejun Heo bool has_ns; 752fd7b9f7bSTejun Heo int ret; 753fd7b9f7bSTejun Heo 754393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 755988cd7afSTejun Heo 756988cd7afSTejun Heo ret = -EINVAL; 757988cd7afSTejun Heo has_ns = kernfs_ns_enabled(parent); 758988cd7afSTejun Heo if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 759988cd7afSTejun Heo has_ns ? "required" : "invalid", parent->name, kn->name)) 760988cd7afSTejun Heo goto out_unlock; 761fd7b9f7bSTejun Heo 762df23fc39STejun Heo if (kernfs_type(parent) != KERNFS_DIR) 763988cd7afSTejun Heo goto out_unlock; 764fd7b9f7bSTejun Heo 765988cd7afSTejun Heo ret = -ENOENT; 766c2549174STejun Heo if (parent->flags & (KERNFS_REMOVING | KERNFS_EMPTY_DIR)) 767988cd7afSTejun Heo goto out_unlock; 768798c75a0SGreg Kroah-Hartman 769c637b8acSTejun Heo kn->hash = kernfs_name_hash(kn->name, kn->ns); 770fd7b9f7bSTejun Heo 771c637b8acSTejun Heo ret = kernfs_link_sibling(kn); 772fd7b9f7bSTejun Heo if (ret) 773988cd7afSTejun Heo goto out_unlock; 774fd7b9f7bSTejun Heo 775fd7b9f7bSTejun Heo /* Update timestamps on the parent */ 776adc5e8b5STejun Heo ps_iattr = parent->iattr; 777fd7b9f7bSTejun Heo if (ps_iattr) { 77805895219SOndrej Mosnacek ktime_get_real_ts64(&ps_iattr->ia_ctime); 77905895219SOndrej Mosnacek ps_iattr->ia_mtime = ps_iattr->ia_ctime; 780fd7b9f7bSTejun Heo } 781fd7b9f7bSTejun Heo 782393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 783d35258efSTejun Heo 784d35258efSTejun Heo /* 785d35258efSTejun Heo * Activate the new node unless CREATE_DEACTIVATED is requested. 786d35258efSTejun Heo * If not activated here, the kernfs user is responsible for 787d35258efSTejun Heo * activating the node with kernfs_activate(). A node which hasn't 788d35258efSTejun Heo * been activated is not visible to userland and its removal won't 789d35258efSTejun Heo * trigger deactivation. 790d35258efSTejun Heo */ 791d35258efSTejun Heo if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 792d35258efSTejun Heo kernfs_activate(kn); 793d35258efSTejun Heo return 0; 794d35258efSTejun Heo 795988cd7afSTejun Heo out_unlock: 796393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 797988cd7afSTejun Heo return ret; 798fd7b9f7bSTejun Heo } 799fd7b9f7bSTejun Heo 800fd7b9f7bSTejun Heo /** 801324a56e1STejun Heo * kernfs_find_ns - find kernfs_node with the given name 802324a56e1STejun Heo * @parent: kernfs_node to search under 803fd7b9f7bSTejun Heo * @name: name to look for 804fd7b9f7bSTejun Heo * @ns: the namespace tag to use 805fd7b9f7bSTejun Heo * 806*24b3e3ddSRandy Dunlap * Look for kernfs_node with name @name under @parent. 807*24b3e3ddSRandy Dunlap * 808*24b3e3ddSRandy Dunlap * Return: pointer to the found kernfs_node on success, %NULL on failure. 809fd7b9f7bSTejun Heo */ 810324a56e1STejun Heo static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent, 811fd7b9f7bSTejun Heo const unsigned char *name, 812fd7b9f7bSTejun Heo const void *ns) 813fd7b9f7bSTejun Heo { 814adc5e8b5STejun Heo struct rb_node *node = parent->dir.children.rb_node; 815ac9bba03STejun Heo bool has_ns = kernfs_ns_enabled(parent); 816fd7b9f7bSTejun Heo unsigned int hash; 817fd7b9f7bSTejun Heo 818393c3714SMinchan Kim lockdep_assert_held(&kernfs_root(parent)->kernfs_rwsem); 819fd7b9f7bSTejun Heo 820fd7b9f7bSTejun Heo if (has_ns != (bool)ns) { 821c637b8acSTejun Heo WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 822adc5e8b5STejun Heo has_ns ? "required" : "invalid", parent->name, name); 823fd7b9f7bSTejun Heo return NULL; 824fd7b9f7bSTejun Heo } 825fd7b9f7bSTejun Heo 826c637b8acSTejun Heo hash = kernfs_name_hash(name, ns); 827fd7b9f7bSTejun Heo while (node) { 828324a56e1STejun Heo struct kernfs_node *kn; 829fd7b9f7bSTejun Heo int result; 830fd7b9f7bSTejun Heo 831324a56e1STejun Heo kn = rb_to_kn(node); 832c637b8acSTejun Heo result = kernfs_name_compare(hash, name, ns, kn); 833fd7b9f7bSTejun Heo if (result < 0) 834fd7b9f7bSTejun Heo node = node->rb_left; 835fd7b9f7bSTejun Heo else if (result > 0) 836fd7b9f7bSTejun Heo node = node->rb_right; 837fd7b9f7bSTejun Heo else 838324a56e1STejun Heo return kn; 839fd7b9f7bSTejun Heo } 840fd7b9f7bSTejun Heo return NULL; 841fd7b9f7bSTejun Heo } 842fd7b9f7bSTejun Heo 843bd96f76aSTejun Heo static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent, 844bd96f76aSTejun Heo const unsigned char *path, 845bd96f76aSTejun Heo const void *ns) 846bd96f76aSTejun Heo { 847e56ed358STejun Heo size_t len; 848e56ed358STejun Heo char *p, *name; 849bd96f76aSTejun Heo 850393c3714SMinchan Kim lockdep_assert_held_read(&kernfs_root(parent)->kernfs_rwsem); 851bd96f76aSTejun Heo 8521a702dc8SHao Luo spin_lock_irq(&kernfs_pr_cont_lock); 853e56ed358STejun Heo 854e56ed358STejun Heo len = strlcpy(kernfs_pr_cont_buf, path, sizeof(kernfs_pr_cont_buf)); 855e56ed358STejun Heo 856e56ed358STejun Heo if (len >= sizeof(kernfs_pr_cont_buf)) { 8571a702dc8SHao Luo spin_unlock_irq(&kernfs_pr_cont_lock); 858bd96f76aSTejun Heo return NULL; 859e56ed358STejun Heo } 860e56ed358STejun Heo 861e56ed358STejun Heo p = kernfs_pr_cont_buf; 862bd96f76aSTejun Heo 863bd96f76aSTejun Heo while ((name = strsep(&p, "/")) && parent) { 864bd96f76aSTejun Heo if (*name == '\0') 865bd96f76aSTejun Heo continue; 866bd96f76aSTejun Heo parent = kernfs_find_ns(parent, name, ns); 867bd96f76aSTejun Heo } 868bd96f76aSTejun Heo 8691a702dc8SHao Luo spin_unlock_irq(&kernfs_pr_cont_lock); 870e56ed358STejun Heo 871bd96f76aSTejun Heo return parent; 872bd96f76aSTejun Heo } 873bd96f76aSTejun Heo 874fd7b9f7bSTejun Heo /** 875324a56e1STejun Heo * kernfs_find_and_get_ns - find and get kernfs_node with the given name 876324a56e1STejun Heo * @parent: kernfs_node to search under 877fd7b9f7bSTejun Heo * @name: name to look for 878fd7b9f7bSTejun Heo * @ns: the namespace tag to use 879fd7b9f7bSTejun Heo * 880324a56e1STejun Heo * Look for kernfs_node with name @name under @parent and get a reference 881*24b3e3ddSRandy Dunlap * if found. This function may sleep. 882*24b3e3ddSRandy Dunlap * 883*24b3e3ddSRandy Dunlap * Return: pointer to the found kernfs_node on success, %NULL on failure. 884fd7b9f7bSTejun Heo */ 885324a56e1STejun Heo struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 886fd7b9f7bSTejun Heo const char *name, const void *ns) 887fd7b9f7bSTejun Heo { 888324a56e1STejun Heo struct kernfs_node *kn; 889393c3714SMinchan Kim struct kernfs_root *root = kernfs_root(parent); 890fd7b9f7bSTejun Heo 891393c3714SMinchan Kim down_read(&root->kernfs_rwsem); 892324a56e1STejun Heo kn = kernfs_find_ns(parent, name, ns); 893324a56e1STejun Heo kernfs_get(kn); 894393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 895fd7b9f7bSTejun Heo 896324a56e1STejun Heo return kn; 897fd7b9f7bSTejun Heo } 898fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns); 899fd7b9f7bSTejun Heo 900fd7b9f7bSTejun Heo /** 901bd96f76aSTejun Heo * kernfs_walk_and_get_ns - find and get kernfs_node with the given path 902bd96f76aSTejun Heo * @parent: kernfs_node to search under 903bd96f76aSTejun Heo * @path: path to look for 904bd96f76aSTejun Heo * @ns: the namespace tag to use 905bd96f76aSTejun Heo * 906bd96f76aSTejun Heo * Look for kernfs_node with path @path under @parent and get a reference 907*24b3e3ddSRandy Dunlap * if found. This function may sleep. 908*24b3e3ddSRandy Dunlap * 909*24b3e3ddSRandy Dunlap * Return: pointer to the found kernfs_node on success, %NULL on failure. 910bd96f76aSTejun Heo */ 911bd96f76aSTejun Heo struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent, 912bd96f76aSTejun Heo const char *path, const void *ns) 913bd96f76aSTejun Heo { 914bd96f76aSTejun Heo struct kernfs_node *kn; 915393c3714SMinchan Kim struct kernfs_root *root = kernfs_root(parent); 916bd96f76aSTejun Heo 917393c3714SMinchan Kim down_read(&root->kernfs_rwsem); 918bd96f76aSTejun Heo kn = kernfs_walk_ns(parent, path, ns); 919bd96f76aSTejun Heo kernfs_get(kn); 920393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 921bd96f76aSTejun Heo 922bd96f76aSTejun Heo return kn; 923bd96f76aSTejun Heo } 924bd96f76aSTejun Heo 925bd96f76aSTejun Heo /** 926ba7443bcSTejun Heo * kernfs_create_root - create a new kernfs hierarchy 92790c07c89STejun Heo * @scops: optional syscall operations for the hierarchy 928d35258efSTejun Heo * @flags: KERNFS_ROOT_* flags 929ba7443bcSTejun Heo * @priv: opaque data associated with the new directory 930ba7443bcSTejun Heo * 931*24b3e3ddSRandy Dunlap * Return: the root of the new hierarchy on success, ERR_PTR() value on 932ba7443bcSTejun Heo * failure. 933ba7443bcSTejun Heo */ 93490c07c89STejun Heo struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 935d35258efSTejun Heo unsigned int flags, void *priv) 936ba7443bcSTejun Heo { 937ba7443bcSTejun Heo struct kernfs_root *root; 938324a56e1STejun Heo struct kernfs_node *kn; 939ba7443bcSTejun Heo 940ba7443bcSTejun Heo root = kzalloc(sizeof(*root), GFP_KERNEL); 941ba7443bcSTejun Heo if (!root) 942ba7443bcSTejun Heo return ERR_PTR(-ENOMEM); 943ba7443bcSTejun Heo 9447d35079fSShaohua Li idr_init(&root->ino_idr); 945393c3714SMinchan Kim init_rwsem(&root->kernfs_rwsem); 9467d568a83STejun Heo INIT_LIST_HEAD(&root->supers); 94740430452STejun Heo 94840430452STejun Heo /* 94940430452STejun Heo * On 64bit ino setups, id is ino. On 32bit, low 32bits are ino. 95040430452STejun Heo * High bits generation. The starting value for both ino and 95140430452STejun Heo * genenration is 1. Initialize upper 32bit allocation 95240430452STejun Heo * accordingly. 95340430452STejun Heo */ 95440430452STejun Heo if (sizeof(ino_t) >= sizeof(u64)) 95540430452STejun Heo root->id_highbits = 0; 95640430452STejun Heo else 95740430452STejun Heo root->id_highbits = 1; 958bc755553STejun Heo 959e19dfdc8SOndrej Mosnacek kn = __kernfs_new_node(root, NULL, "", S_IFDIR | S_IRUGO | S_IXUGO, 960488dee96SDmitry Torokhov GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 961db4aad20STejun Heo KERNFS_DIR); 962324a56e1STejun Heo if (!kn) { 9637d35079fSShaohua Li idr_destroy(&root->ino_idr); 964ba7443bcSTejun Heo kfree(root); 965ba7443bcSTejun Heo return ERR_PTR(-ENOMEM); 966ba7443bcSTejun Heo } 967ba7443bcSTejun Heo 968324a56e1STejun Heo kn->priv = priv; 969adc5e8b5STejun Heo kn->dir.root = root; 970ba7443bcSTejun Heo 97190c07c89STejun Heo root->syscall_ops = scops; 972d35258efSTejun Heo root->flags = flags; 973324a56e1STejun Heo root->kn = kn; 974abd54f02STejun Heo init_waitqueue_head(&root->deactivate_waitq); 975ba7443bcSTejun Heo 976d35258efSTejun Heo if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 977d35258efSTejun Heo kernfs_activate(kn); 978d35258efSTejun Heo 979ba7443bcSTejun Heo return root; 980ba7443bcSTejun Heo } 981ba7443bcSTejun Heo 982ba7443bcSTejun Heo /** 983ba7443bcSTejun Heo * kernfs_destroy_root - destroy a kernfs hierarchy 984ba7443bcSTejun Heo * @root: root of the hierarchy to destroy 985ba7443bcSTejun Heo * 986ba7443bcSTejun Heo * Destroy the hierarchy anchored at @root by removing all existing 987ba7443bcSTejun Heo * directories and destroying @root. 988ba7443bcSTejun Heo */ 989ba7443bcSTejun Heo void kernfs_destroy_root(struct kernfs_root *root) 990ba7443bcSTejun Heo { 991555a0ce4SMinchan Kim /* 992555a0ce4SMinchan Kim * kernfs_remove holds kernfs_rwsem from the root so the root 993555a0ce4SMinchan Kim * shouldn't be freed during the operation. 994555a0ce4SMinchan Kim */ 995555a0ce4SMinchan Kim kernfs_get(root->kn); 996555a0ce4SMinchan Kim kernfs_remove(root->kn); 997555a0ce4SMinchan Kim kernfs_put(root->kn); /* will also free @root */ 998ba7443bcSTejun Heo } 999ba7443bcSTejun Heo 1000ba7443bcSTejun Heo /** 1001f2eb478fSGreg Kroah-Hartman * kernfs_root_to_node - return the kernfs_node associated with a kernfs_root 1002f2eb478fSGreg Kroah-Hartman * @root: root to use to lookup 1003*24b3e3ddSRandy Dunlap * 1004*24b3e3ddSRandy Dunlap * Return: @root's kernfs_node 1005f2eb478fSGreg Kroah-Hartman */ 1006f2eb478fSGreg Kroah-Hartman struct kernfs_node *kernfs_root_to_node(struct kernfs_root *root) 1007f2eb478fSGreg Kroah-Hartman { 1008f2eb478fSGreg Kroah-Hartman return root->kn; 1009f2eb478fSGreg Kroah-Hartman } 1010f2eb478fSGreg Kroah-Hartman 1011f2eb478fSGreg Kroah-Hartman /** 1012fd7b9f7bSTejun Heo * kernfs_create_dir_ns - create a directory 1013fd7b9f7bSTejun Heo * @parent: parent in which to create a new directory 1014fd7b9f7bSTejun Heo * @name: name of the new directory 1015bb8b9d09STejun Heo * @mode: mode of the new directory 1016488dee96SDmitry Torokhov * @uid: uid of the new directory 1017488dee96SDmitry Torokhov * @gid: gid of the new directory 1018fd7b9f7bSTejun Heo * @priv: opaque data associated with the new directory 1019fd7b9f7bSTejun Heo * @ns: optional namespace tag of the directory 1020fd7b9f7bSTejun Heo * 1021*24b3e3ddSRandy Dunlap * Return: the created node on success, ERR_PTR() value on failure. 1022fd7b9f7bSTejun Heo */ 1023324a56e1STejun Heo struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 1024bb8b9d09STejun Heo const char *name, umode_t mode, 1025488dee96SDmitry Torokhov kuid_t uid, kgid_t gid, 1026bb8b9d09STejun Heo void *priv, const void *ns) 1027fd7b9f7bSTejun Heo { 1028324a56e1STejun Heo struct kernfs_node *kn; 1029fd7b9f7bSTejun Heo int rc; 1030fd7b9f7bSTejun Heo 1031fd7b9f7bSTejun Heo /* allocate */ 1032488dee96SDmitry Torokhov kn = kernfs_new_node(parent, name, mode | S_IFDIR, 1033488dee96SDmitry Torokhov uid, gid, KERNFS_DIR); 1034324a56e1STejun Heo if (!kn) 1035fd7b9f7bSTejun Heo return ERR_PTR(-ENOMEM); 1036fd7b9f7bSTejun Heo 1037adc5e8b5STejun Heo kn->dir.root = parent->dir.root; 1038adc5e8b5STejun Heo kn->ns = ns; 1039324a56e1STejun Heo kn->priv = priv; 1040fd7b9f7bSTejun Heo 1041fd7b9f7bSTejun Heo /* link in */ 1042988cd7afSTejun Heo rc = kernfs_add_one(kn); 1043fd7b9f7bSTejun Heo if (!rc) 1044324a56e1STejun Heo return kn; 1045fd7b9f7bSTejun Heo 1046324a56e1STejun Heo kernfs_put(kn); 1047fd7b9f7bSTejun Heo return ERR_PTR(rc); 1048fd7b9f7bSTejun Heo } 1049fd7b9f7bSTejun Heo 1050ea015218SEric W. Biederman /** 1051ea015218SEric W. Biederman * kernfs_create_empty_dir - create an always empty directory 1052ea015218SEric W. Biederman * @parent: parent in which to create a new directory 1053ea015218SEric W. Biederman * @name: name of the new directory 1054ea015218SEric W. Biederman * 1055*24b3e3ddSRandy Dunlap * Return: the created node on success, ERR_PTR() value on failure. 1056ea015218SEric W. Biederman */ 1057ea015218SEric W. Biederman struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent, 1058ea015218SEric W. Biederman const char *name) 1059ea015218SEric W. Biederman { 1060ea015218SEric W. Biederman struct kernfs_node *kn; 1061ea015218SEric W. Biederman int rc; 1062ea015218SEric W. Biederman 1063ea015218SEric W. Biederman /* allocate */ 1064488dee96SDmitry Torokhov kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR, 1065488dee96SDmitry Torokhov GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, KERNFS_DIR); 1066ea015218SEric W. Biederman if (!kn) 1067ea015218SEric W. Biederman return ERR_PTR(-ENOMEM); 1068ea015218SEric W. Biederman 1069ea015218SEric W. Biederman kn->flags |= KERNFS_EMPTY_DIR; 1070ea015218SEric W. Biederman kn->dir.root = parent->dir.root; 1071ea015218SEric W. Biederman kn->ns = NULL; 1072ea015218SEric W. Biederman kn->priv = NULL; 1073ea015218SEric W. Biederman 1074ea015218SEric W. Biederman /* link in */ 1075ea015218SEric W. Biederman rc = kernfs_add_one(kn); 1076ea015218SEric W. Biederman if (!rc) 1077ea015218SEric W. Biederman return kn; 1078ea015218SEric W. Biederman 1079ea015218SEric W. Biederman kernfs_put(kn); 1080ea015218SEric W. Biederman return ERR_PTR(rc); 1081ea015218SEric W. Biederman } 1082ea015218SEric W. Biederman 1083d826e036SIan Kent static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags) 1084d826e036SIan Kent { 1085d826e036SIan Kent struct kernfs_node *kn; 1086393c3714SMinchan Kim struct kernfs_root *root; 1087d826e036SIan Kent 1088d826e036SIan Kent if (flags & LOOKUP_RCU) 1089d826e036SIan Kent return -ECHILD; 1090d826e036SIan Kent 1091c7e7c042SIan Kent /* Negative hashed dentry? */ 1092c7e7c042SIan Kent if (d_really_is_negative(dentry)) { 1093c7e7c042SIan Kent struct kernfs_node *parent; 1094c7e7c042SIan Kent 1095c7e7c042SIan Kent /* If the kernfs parent node has changed discard and 1096c7e7c042SIan Kent * proceed to ->lookup. 109792b57842SIan Kent * 109892b57842SIan Kent * There's nothing special needed here when getting the 109992b57842SIan Kent * dentry parent, even if a concurrent rename is in 110092b57842SIan Kent * progress. That's because the dentry is negative so 110192b57842SIan Kent * it can only be the target of the rename and it will 110292b57842SIan Kent * be doing a d_move() not a replace. Consequently the 110392b57842SIan Kent * dentry d_parent won't change over the d_move(). 110492b57842SIan Kent * 110592b57842SIan Kent * Also kernfs negative dentries transitioning from 110692b57842SIan Kent * negative to positive during revalidate won't happen 110792b57842SIan Kent * because they are invalidated on containing directory 110892b57842SIan Kent * changes and the lookup re-done so that a new positive 110992b57842SIan Kent * dentry can be properly created. 1110c7e7c042SIan Kent */ 111192b57842SIan Kent root = kernfs_root_from_sb(dentry->d_sb); 111292b57842SIan Kent down_read(&root->kernfs_rwsem); 1113c7e7c042SIan Kent parent = kernfs_dentry_node(dentry->d_parent); 1114c7e7c042SIan Kent if (parent) { 1115393c3714SMinchan Kim if (kernfs_dir_changed(parent, dentry)) { 1116393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1117c7e7c042SIan Kent return 0; 1118c7e7c042SIan Kent } 111992b57842SIan Kent } 1120393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1121c7e7c042SIan Kent 1122c7e7c042SIan Kent /* The kernfs parent node hasn't changed, leave the 1123c7e7c042SIan Kent * dentry negative and return success. 1124c7e7c042SIan Kent */ 1125c7e7c042SIan Kent return 1; 1126c7e7c042SIan Kent } 1127d826e036SIan Kent 1128d826e036SIan Kent kn = kernfs_dentry_node(dentry); 1129393c3714SMinchan Kim root = kernfs_root(kn); 1130393c3714SMinchan Kim down_read(&root->kernfs_rwsem); 1131d826e036SIan Kent 1132d826e036SIan Kent /* The kernfs node has been deactivated */ 1133d826e036SIan Kent if (!kernfs_active(kn)) 1134d826e036SIan Kent goto out_bad; 1135d826e036SIan Kent 1136d826e036SIan Kent /* The kernfs node has been moved? */ 1137d826e036SIan Kent if (kernfs_dentry_node(dentry->d_parent) != kn->parent) 1138d826e036SIan Kent goto out_bad; 1139d826e036SIan Kent 1140d826e036SIan Kent /* The kernfs node has been renamed */ 1141d826e036SIan Kent if (strcmp(dentry->d_name.name, kn->name) != 0) 1142d826e036SIan Kent goto out_bad; 1143d826e036SIan Kent 1144d826e036SIan Kent /* The kernfs node has been moved to a different namespace */ 1145d826e036SIan Kent if (kn->parent && kernfs_ns_enabled(kn->parent) && 1146d826e036SIan Kent kernfs_info(dentry->d_sb)->ns != kn->ns) 1147d826e036SIan Kent goto out_bad; 1148d826e036SIan Kent 1149393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1150d826e036SIan Kent return 1; 1151d826e036SIan Kent out_bad: 1152393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1153d826e036SIan Kent return 0; 1154d826e036SIan Kent } 1155d826e036SIan Kent 1156d826e036SIan Kent const struct dentry_operations kernfs_dops = { 1157d826e036SIan Kent .d_revalidate = kernfs_dop_revalidate, 1158d826e036SIan Kent }; 1159d826e036SIan Kent 1160c637b8acSTejun Heo static struct dentry *kernfs_iop_lookup(struct inode *dir, 1161c637b8acSTejun Heo struct dentry *dentry, 1162fd7b9f7bSTejun Heo unsigned int flags) 1163fd7b9f7bSTejun Heo { 1164319ba91dSShaohua Li struct kernfs_node *parent = dir->i_private; 1165324a56e1STejun Heo struct kernfs_node *kn; 1166393c3714SMinchan Kim struct kernfs_root *root; 1167c7e7c042SIan Kent struct inode *inode = NULL; 1168fd7b9f7bSTejun Heo const void *ns = NULL; 1169fd7b9f7bSTejun Heo 1170393c3714SMinchan Kim root = kernfs_root(parent); 1171393c3714SMinchan Kim down_read(&root->kernfs_rwsem); 1172324a56e1STejun Heo if (kernfs_ns_enabled(parent)) 1173c525aaddSTejun Heo ns = kernfs_info(dir->i_sb)->ns; 1174fd7b9f7bSTejun Heo 1175324a56e1STejun Heo kn = kernfs_find_ns(parent, dentry->d_name.name, ns); 1176fd7b9f7bSTejun Heo /* attach dentry and inode */ 1177410d591aSIan Kent if (kn) { 1178410d591aSIan Kent /* Inactive nodes are invisible to the VFS so don't 1179410d591aSIan Kent * create a negative. 1180410d591aSIan Kent */ 1181410d591aSIan Kent if (!kernfs_active(kn)) { 1182393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1183410d591aSIan Kent return NULL; 1184410d591aSIan Kent } 1185c637b8acSTejun Heo inode = kernfs_get_inode(dir->i_sb, kn); 1186c7e7c042SIan Kent if (!inode) 1187c7e7c042SIan Kent inode = ERR_PTR(-ENOMEM); 1188fd7b9f7bSTejun Heo } 1189df38d852SHou Tao /* 1190df38d852SHou Tao * Needed for negative dentry validation. 1191df38d852SHou Tao * The negative dentry can be created in kernfs_iop_lookup() 1192df38d852SHou Tao * or transforms from positive dentry in dentry_unlink_inode() 1193df38d852SHou Tao * called from vfs_rmdir(). 1194df38d852SHou Tao */ 1195df38d852SHou Tao if (!IS_ERR(inode)) 1196c7e7c042SIan Kent kernfs_set_rev(parent, dentry); 1197393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1198c7e7c042SIan Kent 1199df6192f4SIan Kent /* instantiate and hash (possibly negative) dentry */ 1200df6192f4SIan Kent return d_splice_alias(inode, dentry); 1201fd7b9f7bSTejun Heo } 1202fd7b9f7bSTejun Heo 1203549c7297SChristian Brauner static int kernfs_iop_mkdir(struct user_namespace *mnt_userns, 1204549c7297SChristian Brauner struct inode *dir, struct dentry *dentry, 120580b9bbefSTejun Heo umode_t mode) 120680b9bbefSTejun Heo { 120780b9bbefSTejun Heo struct kernfs_node *parent = dir->i_private; 120890c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops; 120907c7530dSTejun Heo int ret; 121080b9bbefSTejun Heo 121190c07c89STejun Heo if (!scops || !scops->mkdir) 121280b9bbefSTejun Heo return -EPERM; 121380b9bbefSTejun Heo 121407c7530dSTejun Heo if (!kernfs_get_active(parent)) 121507c7530dSTejun Heo return -ENODEV; 121607c7530dSTejun Heo 121790c07c89STejun Heo ret = scops->mkdir(parent, dentry->d_name.name, mode); 121807c7530dSTejun Heo 121907c7530dSTejun Heo kernfs_put_active(parent); 122007c7530dSTejun Heo return ret; 122180b9bbefSTejun Heo } 122280b9bbefSTejun Heo 122380b9bbefSTejun Heo static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry) 122480b9bbefSTejun Heo { 1225319ba91dSShaohua Li struct kernfs_node *kn = kernfs_dentry_node(dentry); 122690c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 122707c7530dSTejun Heo int ret; 122880b9bbefSTejun Heo 122990c07c89STejun Heo if (!scops || !scops->rmdir) 123080b9bbefSTejun Heo return -EPERM; 123180b9bbefSTejun Heo 123207c7530dSTejun Heo if (!kernfs_get_active(kn)) 123307c7530dSTejun Heo return -ENODEV; 123407c7530dSTejun Heo 123590c07c89STejun Heo ret = scops->rmdir(kn); 123607c7530dSTejun Heo 123707c7530dSTejun Heo kernfs_put_active(kn); 123807c7530dSTejun Heo return ret; 123980b9bbefSTejun Heo } 124080b9bbefSTejun Heo 1241549c7297SChristian Brauner static int kernfs_iop_rename(struct user_namespace *mnt_userns, 1242549c7297SChristian Brauner struct inode *old_dir, struct dentry *old_dentry, 12431cd66c93SMiklos Szeredi struct inode *new_dir, struct dentry *new_dentry, 12441cd66c93SMiklos Szeredi unsigned int flags) 124580b9bbefSTejun Heo { 1246319ba91dSShaohua Li struct kernfs_node *kn = kernfs_dentry_node(old_dentry); 124780b9bbefSTejun Heo struct kernfs_node *new_parent = new_dir->i_private; 124890c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 124907c7530dSTejun Heo int ret; 125080b9bbefSTejun Heo 12511cd66c93SMiklos Szeredi if (flags) 12521cd66c93SMiklos Szeredi return -EINVAL; 12531cd66c93SMiklos Szeredi 125490c07c89STejun Heo if (!scops || !scops->rename) 125580b9bbefSTejun Heo return -EPERM; 125680b9bbefSTejun Heo 125707c7530dSTejun Heo if (!kernfs_get_active(kn)) 125807c7530dSTejun Heo return -ENODEV; 125907c7530dSTejun Heo 126007c7530dSTejun Heo if (!kernfs_get_active(new_parent)) { 126107c7530dSTejun Heo kernfs_put_active(kn); 126207c7530dSTejun Heo return -ENODEV; 126307c7530dSTejun Heo } 126407c7530dSTejun Heo 126590c07c89STejun Heo ret = scops->rename(kn, new_parent, new_dentry->d_name.name); 126607c7530dSTejun Heo 126707c7530dSTejun Heo kernfs_put_active(new_parent); 126807c7530dSTejun Heo kernfs_put_active(kn); 126907c7530dSTejun Heo return ret; 127080b9bbefSTejun Heo } 127180b9bbefSTejun Heo 1272a797bfc3STejun Heo const struct inode_operations kernfs_dir_iops = { 1273c637b8acSTejun Heo .lookup = kernfs_iop_lookup, 1274c637b8acSTejun Heo .permission = kernfs_iop_permission, 1275c637b8acSTejun Heo .setattr = kernfs_iop_setattr, 1276c637b8acSTejun Heo .getattr = kernfs_iop_getattr, 1277c637b8acSTejun Heo .listxattr = kernfs_iop_listxattr, 127880b9bbefSTejun Heo 127980b9bbefSTejun Heo .mkdir = kernfs_iop_mkdir, 128080b9bbefSTejun Heo .rmdir = kernfs_iop_rmdir, 128180b9bbefSTejun Heo .rename = kernfs_iop_rename, 1282fd7b9f7bSTejun Heo }; 1283fd7b9f7bSTejun Heo 1284c637b8acSTejun Heo static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos) 1285fd7b9f7bSTejun Heo { 1286324a56e1STejun Heo struct kernfs_node *last; 1287fd7b9f7bSTejun Heo 1288fd7b9f7bSTejun Heo while (true) { 1289fd7b9f7bSTejun Heo struct rb_node *rbn; 1290fd7b9f7bSTejun Heo 1291fd7b9f7bSTejun Heo last = pos; 1292fd7b9f7bSTejun Heo 1293df23fc39STejun Heo if (kernfs_type(pos) != KERNFS_DIR) 1294fd7b9f7bSTejun Heo break; 1295fd7b9f7bSTejun Heo 1296adc5e8b5STejun Heo rbn = rb_first(&pos->dir.children); 1297fd7b9f7bSTejun Heo if (!rbn) 1298fd7b9f7bSTejun Heo break; 1299fd7b9f7bSTejun Heo 1300324a56e1STejun Heo pos = rb_to_kn(rbn); 1301fd7b9f7bSTejun Heo } 1302fd7b9f7bSTejun Heo 1303fd7b9f7bSTejun Heo return last; 1304fd7b9f7bSTejun Heo } 1305fd7b9f7bSTejun Heo 1306fd7b9f7bSTejun Heo /** 1307c637b8acSTejun Heo * kernfs_next_descendant_post - find the next descendant for post-order walk 1308fd7b9f7bSTejun Heo * @pos: the current position (%NULL to initiate traversal) 1309324a56e1STejun Heo * @root: kernfs_node whose descendants to walk 1310fd7b9f7bSTejun Heo * 1311fd7b9f7bSTejun Heo * Find the next descendant to visit for post-order traversal of @root's 1312fd7b9f7bSTejun Heo * descendants. @root is included in the iteration and the last node to be 1313fd7b9f7bSTejun Heo * visited. 1314*24b3e3ddSRandy Dunlap * 1315*24b3e3ddSRandy Dunlap * Return: the next descendant to visit or %NULL when done. 1316fd7b9f7bSTejun Heo */ 1317c637b8acSTejun Heo static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos, 1318324a56e1STejun Heo struct kernfs_node *root) 1319fd7b9f7bSTejun Heo { 1320fd7b9f7bSTejun Heo struct rb_node *rbn; 1321fd7b9f7bSTejun Heo 1322393c3714SMinchan Kim lockdep_assert_held_write(&kernfs_root(root)->kernfs_rwsem); 1323fd7b9f7bSTejun Heo 1324fd7b9f7bSTejun Heo /* if first iteration, visit leftmost descendant which may be root */ 1325fd7b9f7bSTejun Heo if (!pos) 1326c637b8acSTejun Heo return kernfs_leftmost_descendant(root); 1327fd7b9f7bSTejun Heo 1328fd7b9f7bSTejun Heo /* if we visited @root, we're done */ 1329fd7b9f7bSTejun Heo if (pos == root) 1330fd7b9f7bSTejun Heo return NULL; 1331fd7b9f7bSTejun Heo 1332fd7b9f7bSTejun Heo /* if there's an unvisited sibling, visit its leftmost descendant */ 1333adc5e8b5STejun Heo rbn = rb_next(&pos->rb); 1334fd7b9f7bSTejun Heo if (rbn) 1335c637b8acSTejun Heo return kernfs_leftmost_descendant(rb_to_kn(rbn)); 1336fd7b9f7bSTejun Heo 1337fd7b9f7bSTejun Heo /* no sibling left, visit parent */ 1338adc5e8b5STejun Heo return pos->parent; 1339fd7b9f7bSTejun Heo } 1340fd7b9f7bSTejun Heo 1341f8eb145eSTejun Heo static void kernfs_activate_one(struct kernfs_node *kn) 1342f8eb145eSTejun Heo { 1343f8eb145eSTejun Heo lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem); 1344f8eb145eSTejun Heo 1345f8eb145eSTejun Heo kn->flags |= KERNFS_ACTIVATED; 1346f8eb145eSTejun Heo 1347783bd07dSTejun Heo if (kernfs_active(kn) || (kn->flags & (KERNFS_HIDDEN | KERNFS_REMOVING))) 1348f8eb145eSTejun Heo return; 1349f8eb145eSTejun Heo 1350f8eb145eSTejun Heo WARN_ON_ONCE(kn->parent && RB_EMPTY_NODE(&kn->rb)); 1351f8eb145eSTejun Heo WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS); 1352f8eb145eSTejun Heo 1353f8eb145eSTejun Heo atomic_sub(KN_DEACTIVATED_BIAS, &kn->active); 1354f8eb145eSTejun Heo } 1355f8eb145eSTejun Heo 1356d35258efSTejun Heo /** 1357d35258efSTejun Heo * kernfs_activate - activate a node which started deactivated 1358d35258efSTejun Heo * @kn: kernfs_node whose subtree is to be activated 1359d35258efSTejun Heo * 1360d35258efSTejun Heo * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node 1361d35258efSTejun Heo * needs to be explicitly activated. A node which hasn't been activated 1362d35258efSTejun Heo * isn't visible to userland and deactivation is skipped during its 1363d35258efSTejun Heo * removal. This is useful to construct atomic init sequences where 1364d35258efSTejun Heo * creation of multiple nodes should either succeed or fail atomically. 1365d35258efSTejun Heo * 1366d35258efSTejun Heo * The caller is responsible for ensuring that this function is not called 1367d35258efSTejun Heo * after kernfs_remove*() is invoked on @kn. 1368d35258efSTejun Heo */ 1369d35258efSTejun Heo void kernfs_activate(struct kernfs_node *kn) 1370d35258efSTejun Heo { 1371d35258efSTejun Heo struct kernfs_node *pos; 1372393c3714SMinchan Kim struct kernfs_root *root = kernfs_root(kn); 1373d35258efSTejun Heo 1374393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 1375d35258efSTejun Heo 1376d35258efSTejun Heo pos = NULL; 1377f8eb145eSTejun Heo while ((pos = kernfs_next_descendant_post(pos, kn))) 1378f8eb145eSTejun Heo kernfs_activate_one(pos); 1379d35258efSTejun Heo 1380393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 1381d35258efSTejun Heo } 1382d35258efSTejun Heo 1383783bd07dSTejun Heo /** 1384783bd07dSTejun Heo * kernfs_show - show or hide a node 1385783bd07dSTejun Heo * @kn: kernfs_node to show or hide 1386783bd07dSTejun Heo * @show: whether to show or hide 1387783bd07dSTejun Heo * 1388783bd07dSTejun Heo * If @show is %false, @kn is marked hidden and deactivated. A hidden node is 1389783bd07dSTejun Heo * ignored in future activaitons. If %true, the mark is removed and activation 1390783bd07dSTejun Heo * state is restored. This function won't implicitly activate a new node in a 1391783bd07dSTejun Heo * %KERNFS_ROOT_CREATE_DEACTIVATED root which hasn't been activated yet. 1392783bd07dSTejun Heo * 1393783bd07dSTejun Heo * To avoid recursion complexities, directories aren't supported for now. 1394783bd07dSTejun Heo */ 1395783bd07dSTejun Heo void kernfs_show(struct kernfs_node *kn, bool show) 1396783bd07dSTejun Heo { 1397783bd07dSTejun Heo struct kernfs_root *root = kernfs_root(kn); 1398783bd07dSTejun Heo 1399783bd07dSTejun Heo if (WARN_ON_ONCE(kernfs_type(kn) == KERNFS_DIR)) 1400783bd07dSTejun Heo return; 1401783bd07dSTejun Heo 1402783bd07dSTejun Heo down_write(&root->kernfs_rwsem); 1403783bd07dSTejun Heo 1404783bd07dSTejun Heo if (show) { 1405783bd07dSTejun Heo kn->flags &= ~KERNFS_HIDDEN; 1406783bd07dSTejun Heo if (kn->flags & KERNFS_ACTIVATED) 1407783bd07dSTejun Heo kernfs_activate_one(kn); 1408783bd07dSTejun Heo } else { 1409783bd07dSTejun Heo kn->flags |= KERNFS_HIDDEN; 1410783bd07dSTejun Heo if (kernfs_active(kn)) 1411783bd07dSTejun Heo atomic_add(KN_DEACTIVATED_BIAS, &kn->active); 1412783bd07dSTejun Heo kernfs_drain(kn); 1413783bd07dSTejun Heo } 1414783bd07dSTejun Heo 1415783bd07dSTejun Heo up_write(&root->kernfs_rwsem); 1416783bd07dSTejun Heo } 1417783bd07dSTejun Heo 1418988cd7afSTejun Heo static void __kernfs_remove(struct kernfs_node *kn) 1419fd7b9f7bSTejun Heo { 142035beab06STejun Heo struct kernfs_node *pos; 142135beab06STejun Heo 142272b5d5aeSYushan Zhou /* Short-circuit if non-root @kn has already finished removal. */ 142372b5d5aeSYushan Zhou if (!kn) 142472b5d5aeSYushan Zhou return; 142572b5d5aeSYushan Zhou 1426393c3714SMinchan Kim lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem); 1427fd7b9f7bSTejun Heo 14286b0afc2aSTejun Heo /* 14296b0afc2aSTejun Heo * This is for kernfs_remove_self() which plays with active ref 14306b0afc2aSTejun Heo * after removal. 14316b0afc2aSTejun Heo */ 143272b5d5aeSYushan Zhou if (kn->parent && RB_EMPTY_NODE(&kn->rb)) 1433ce9b499cSGreg Kroah-Hartman return; 1434ce9b499cSGreg Kroah-Hartman 1435c637b8acSTejun Heo pr_debug("kernfs %s: removing\n", kn->name); 1436fd7b9f7bSTejun Heo 1437c2549174STejun Heo /* prevent new usage by marking all nodes removing and deactivating */ 143835beab06STejun Heo pos = NULL; 1439c2549174STejun Heo while ((pos = kernfs_next_descendant_post(pos, kn))) { 1440c2549174STejun Heo pos->flags |= KERNFS_REMOVING; 144181c173cbSTejun Heo if (kernfs_active(pos)) 144281c173cbSTejun Heo atomic_add(KN_DEACTIVATED_BIAS, &pos->active); 1443c2549174STejun Heo } 144435beab06STejun Heo 144535beab06STejun Heo /* deactivate and unlink the subtree node-by-node */ 1446fd7b9f7bSTejun Heo do { 144735beab06STejun Heo pos = kernfs_leftmost_descendant(kn); 144835beab06STejun Heo 144935beab06STejun Heo /* 14502d7f9f8cSTejun Heo * kernfs_drain() may drop kernfs_rwsem temporarily and @pos's 145181c173cbSTejun Heo * base ref could have been put by someone else by the time 145281c173cbSTejun Heo * the function returns. Make sure it doesn't go away 145381c173cbSTejun Heo * underneath us. 145435beab06STejun Heo */ 145535beab06STejun Heo kernfs_get(pos); 145635beab06STejun Heo 145781c173cbSTejun Heo kernfs_drain(pos); 145835beab06STejun Heo 145935beab06STejun Heo /* 146035beab06STejun Heo * kernfs_unlink_sibling() succeeds once per node. Use it 146135beab06STejun Heo * to decide who's responsible for cleanups. 146235beab06STejun Heo */ 146335beab06STejun Heo if (!pos->parent || kernfs_unlink_sibling(pos)) { 146435beab06STejun Heo struct kernfs_iattrs *ps_iattr = 146535beab06STejun Heo pos->parent ? pos->parent->iattr : NULL; 146635beab06STejun Heo 146735beab06STejun Heo /* update timestamps on the parent */ 146835beab06STejun Heo if (ps_iattr) { 146905895219SOndrej Mosnacek ktime_get_real_ts64(&ps_iattr->ia_ctime); 147005895219SOndrej Mosnacek ps_iattr->ia_mtime = ps_iattr->ia_ctime; 147135beab06STejun Heo } 147235beab06STejun Heo 1473988cd7afSTejun Heo kernfs_put(pos); 147435beab06STejun Heo } 147535beab06STejun Heo 147635beab06STejun Heo kernfs_put(pos); 147735beab06STejun Heo } while (pos != kn); 1478fd7b9f7bSTejun Heo } 1479fd7b9f7bSTejun Heo 1480fd7b9f7bSTejun Heo /** 1481324a56e1STejun Heo * kernfs_remove - remove a kernfs_node recursively 1482324a56e1STejun Heo * @kn: the kernfs_node to remove 1483fd7b9f7bSTejun Heo * 1484324a56e1STejun Heo * Remove @kn along with all its subdirectories and files. 1485fd7b9f7bSTejun Heo */ 1486324a56e1STejun Heo void kernfs_remove(struct kernfs_node *kn) 1487fd7b9f7bSTejun Heo { 1488ad8d8693SMinchan Kim struct kernfs_root *root; 1489ad8d8693SMinchan Kim 1490ad8d8693SMinchan Kim if (!kn) 1491ad8d8693SMinchan Kim return; 1492ad8d8693SMinchan Kim 1493ad8d8693SMinchan Kim root = kernfs_root(kn); 1494393c3714SMinchan Kim 1495393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 1496988cd7afSTejun Heo __kernfs_remove(kn); 1497393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 1498fd7b9f7bSTejun Heo } 1499fd7b9f7bSTejun Heo 1500fd7b9f7bSTejun Heo /** 15016b0afc2aSTejun Heo * kernfs_break_active_protection - break out of active protection 15026b0afc2aSTejun Heo * @kn: the self kernfs_node 15036b0afc2aSTejun Heo * 15046b0afc2aSTejun Heo * The caller must be running off of a kernfs operation which is invoked 15056b0afc2aSTejun Heo * with an active reference - e.g. one of kernfs_ops. Each invocation of 15066b0afc2aSTejun Heo * this function must also be matched with an invocation of 15076b0afc2aSTejun Heo * kernfs_unbreak_active_protection(). 15086b0afc2aSTejun Heo * 15096b0afc2aSTejun Heo * This function releases the active reference of @kn the caller is 15106b0afc2aSTejun Heo * holding. Once this function is called, @kn may be removed at any point 15116b0afc2aSTejun Heo * and the caller is solely responsible for ensuring that the objects it 15126b0afc2aSTejun Heo * dereferences are accessible. 15136b0afc2aSTejun Heo */ 15146b0afc2aSTejun Heo void kernfs_break_active_protection(struct kernfs_node *kn) 15156b0afc2aSTejun Heo { 15166b0afc2aSTejun Heo /* 15176b0afc2aSTejun Heo * Take out ourself out of the active ref dependency chain. If 15186b0afc2aSTejun Heo * we're called without an active ref, lockdep will complain. 15196b0afc2aSTejun Heo */ 15206b0afc2aSTejun Heo kernfs_put_active(kn); 15216b0afc2aSTejun Heo } 15226b0afc2aSTejun Heo 15236b0afc2aSTejun Heo /** 15246b0afc2aSTejun Heo * kernfs_unbreak_active_protection - undo kernfs_break_active_protection() 15256b0afc2aSTejun Heo * @kn: the self kernfs_node 15266b0afc2aSTejun Heo * 15276b0afc2aSTejun Heo * If kernfs_break_active_protection() was called, this function must be 15286b0afc2aSTejun Heo * invoked before finishing the kernfs operation. Note that while this 15296b0afc2aSTejun Heo * function restores the active reference, it doesn't and can't actually 15306b0afc2aSTejun Heo * restore the active protection - @kn may already or be in the process of 15316b0afc2aSTejun Heo * being removed. Once kernfs_break_active_protection() is invoked, that 15326b0afc2aSTejun Heo * protection is irreversibly gone for the kernfs operation instance. 15336b0afc2aSTejun Heo * 15346b0afc2aSTejun Heo * While this function may be called at any point after 15356b0afc2aSTejun Heo * kernfs_break_active_protection() is invoked, its most useful location 15366b0afc2aSTejun Heo * would be right before the enclosing kernfs operation returns. 15376b0afc2aSTejun Heo */ 15386b0afc2aSTejun Heo void kernfs_unbreak_active_protection(struct kernfs_node *kn) 15396b0afc2aSTejun Heo { 15406b0afc2aSTejun Heo /* 15416b0afc2aSTejun Heo * @kn->active could be in any state; however, the increment we do 15426b0afc2aSTejun Heo * here will be undone as soon as the enclosing kernfs operation 15436b0afc2aSTejun Heo * finishes and this temporary bump can't break anything. If @kn 15446b0afc2aSTejun Heo * is alive, nothing changes. If @kn is being deactivated, the 15456b0afc2aSTejun Heo * soon-to-follow put will either finish deactivation or restore 15466b0afc2aSTejun Heo * deactivated state. If @kn is already removed, the temporary 15476b0afc2aSTejun Heo * bump is guaranteed to be gone before @kn is released. 15486b0afc2aSTejun Heo */ 15496b0afc2aSTejun Heo atomic_inc(&kn->active); 15506b0afc2aSTejun Heo if (kernfs_lockdep(kn)) 15516b0afc2aSTejun Heo rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_); 15526b0afc2aSTejun Heo } 15536b0afc2aSTejun Heo 15546b0afc2aSTejun Heo /** 15556b0afc2aSTejun Heo * kernfs_remove_self - remove a kernfs_node from its own method 15566b0afc2aSTejun Heo * @kn: the self kernfs_node to remove 15576b0afc2aSTejun Heo * 15586b0afc2aSTejun Heo * The caller must be running off of a kernfs operation which is invoked 15596b0afc2aSTejun Heo * with an active reference - e.g. one of kernfs_ops. This can be used to 15606b0afc2aSTejun Heo * implement a file operation which deletes itself. 15616b0afc2aSTejun Heo * 15626b0afc2aSTejun Heo * For example, the "delete" file for a sysfs device directory can be 15636b0afc2aSTejun Heo * implemented by invoking kernfs_remove_self() on the "delete" file 15646b0afc2aSTejun Heo * itself. This function breaks the circular dependency of trying to 15656b0afc2aSTejun Heo * deactivate self while holding an active ref itself. It isn't necessary 15666b0afc2aSTejun Heo * to modify the usual removal path to use kernfs_remove_self(). The 15676b0afc2aSTejun Heo * "delete" implementation can simply invoke kernfs_remove_self() on self 15686b0afc2aSTejun Heo * before proceeding with the usual removal path. kernfs will ignore later 15696b0afc2aSTejun Heo * kernfs_remove() on self. 15706b0afc2aSTejun Heo * 15716b0afc2aSTejun Heo * kernfs_remove_self() can be called multiple times concurrently on the 15726b0afc2aSTejun Heo * same kernfs_node. Only the first one actually performs removal and 15736b0afc2aSTejun Heo * returns %true. All others will wait until the kernfs operation which 15746b0afc2aSTejun Heo * won self-removal finishes and return %false. Note that the losers wait 15756b0afc2aSTejun Heo * for the completion of not only the winning kernfs_remove_self() but also 15766b0afc2aSTejun Heo * the whole kernfs_ops which won the arbitration. This can be used to 15776b0afc2aSTejun Heo * guarantee, for example, all concurrent writes to a "delete" file to 15786b0afc2aSTejun Heo * finish only after the whole operation is complete. 1579*24b3e3ddSRandy Dunlap * 1580*24b3e3ddSRandy Dunlap * Return: %true if @kn is removed by this call, otherwise %false. 15816b0afc2aSTejun Heo */ 15826b0afc2aSTejun Heo bool kernfs_remove_self(struct kernfs_node *kn) 15836b0afc2aSTejun Heo { 15846b0afc2aSTejun Heo bool ret; 1585393c3714SMinchan Kim struct kernfs_root *root = kernfs_root(kn); 15866b0afc2aSTejun Heo 1587393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 15886b0afc2aSTejun Heo kernfs_break_active_protection(kn); 15896b0afc2aSTejun Heo 15906b0afc2aSTejun Heo /* 15916b0afc2aSTejun Heo * SUICIDAL is used to arbitrate among competing invocations. Only 15926b0afc2aSTejun Heo * the first one will actually perform removal. When the removal 15936b0afc2aSTejun Heo * is complete, SUICIDED is set and the active ref is restored 15947ba0273bSIan Kent * while kernfs_rwsem for held exclusive. The ones which lost 15957ba0273bSIan Kent * arbitration waits for SUICIDED && drained which can happen only 15967ba0273bSIan Kent * after the enclosing kernfs operation which executed the winning 15977ba0273bSIan Kent * instance of kernfs_remove_self() finished. 15986b0afc2aSTejun Heo */ 15996b0afc2aSTejun Heo if (!(kn->flags & KERNFS_SUICIDAL)) { 16006b0afc2aSTejun Heo kn->flags |= KERNFS_SUICIDAL; 16016b0afc2aSTejun Heo __kernfs_remove(kn); 16026b0afc2aSTejun Heo kn->flags |= KERNFS_SUICIDED; 16036b0afc2aSTejun Heo ret = true; 16046b0afc2aSTejun Heo } else { 16056b0afc2aSTejun Heo wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq; 16066b0afc2aSTejun Heo DEFINE_WAIT(wait); 16076b0afc2aSTejun Heo 16086b0afc2aSTejun Heo while (true) { 16096b0afc2aSTejun Heo prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE); 16106b0afc2aSTejun Heo 16116b0afc2aSTejun Heo if ((kn->flags & KERNFS_SUICIDED) && 16126b0afc2aSTejun Heo atomic_read(&kn->active) == KN_DEACTIVATED_BIAS) 16136b0afc2aSTejun Heo break; 16146b0afc2aSTejun Heo 1615393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 16166b0afc2aSTejun Heo schedule(); 1617393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 16186b0afc2aSTejun Heo } 16196b0afc2aSTejun Heo finish_wait(waitq, &wait); 16206b0afc2aSTejun Heo WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb)); 16216b0afc2aSTejun Heo ret = false; 16226b0afc2aSTejun Heo } 16236b0afc2aSTejun Heo 16246b0afc2aSTejun Heo /* 16257ba0273bSIan Kent * This must be done while kernfs_rwsem held exclusive; otherwise, 16267ba0273bSIan Kent * waiting for SUICIDED && deactivated could finish prematurely. 16276b0afc2aSTejun Heo */ 16286b0afc2aSTejun Heo kernfs_unbreak_active_protection(kn); 16296b0afc2aSTejun Heo 1630393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 16316b0afc2aSTejun Heo return ret; 16326b0afc2aSTejun Heo } 16336b0afc2aSTejun Heo 16346b0afc2aSTejun Heo /** 1635324a56e1STejun Heo * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it 1636324a56e1STejun Heo * @parent: parent of the target 1637324a56e1STejun Heo * @name: name of the kernfs_node to remove 1638324a56e1STejun Heo * @ns: namespace tag of the kernfs_node to remove 1639fd7b9f7bSTejun Heo * 1640324a56e1STejun Heo * Look for the kernfs_node with @name and @ns under @parent and remove it. 1641*24b3e3ddSRandy Dunlap * 1642*24b3e3ddSRandy Dunlap * Return: %0 on success, -ENOENT if such entry doesn't exist. 1643fd7b9f7bSTejun Heo */ 1644324a56e1STejun Heo int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 1645fd7b9f7bSTejun Heo const void *ns) 1646fd7b9f7bSTejun Heo { 1647324a56e1STejun Heo struct kernfs_node *kn; 1648393c3714SMinchan Kim struct kernfs_root *root; 1649fd7b9f7bSTejun Heo 1650324a56e1STejun Heo if (!parent) { 1651c637b8acSTejun Heo WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n", 1652fd7b9f7bSTejun Heo name); 1653fd7b9f7bSTejun Heo return -ENOENT; 1654fd7b9f7bSTejun Heo } 1655fd7b9f7bSTejun Heo 1656393c3714SMinchan Kim root = kernfs_root(parent); 1657393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 1658fd7b9f7bSTejun Heo 1659324a56e1STejun Heo kn = kernfs_find_ns(parent, name, ns); 16604abc9965SChristian A. Ehrhardt if (kn) { 16614abc9965SChristian A. Ehrhardt kernfs_get(kn); 1662988cd7afSTejun Heo __kernfs_remove(kn); 16634abc9965SChristian A. Ehrhardt kernfs_put(kn); 16644abc9965SChristian A. Ehrhardt } 1665fd7b9f7bSTejun Heo 1666393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 1667fd7b9f7bSTejun Heo 1668324a56e1STejun Heo if (kn) 1669fd7b9f7bSTejun Heo return 0; 1670fd7b9f7bSTejun Heo else 1671fd7b9f7bSTejun Heo return -ENOENT; 1672fd7b9f7bSTejun Heo } 1673fd7b9f7bSTejun Heo 1674fd7b9f7bSTejun Heo /** 1675fd7b9f7bSTejun Heo * kernfs_rename_ns - move and rename a kernfs_node 1676324a56e1STejun Heo * @kn: target node 1677fd7b9f7bSTejun Heo * @new_parent: new parent to put @sd under 1678fd7b9f7bSTejun Heo * @new_name: new name 1679fd7b9f7bSTejun Heo * @new_ns: new namespace tag 1680*24b3e3ddSRandy Dunlap * 1681*24b3e3ddSRandy Dunlap * Return: %0 on success, -errno on failure. 1682fd7b9f7bSTejun Heo */ 1683324a56e1STejun Heo int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 1684fd7b9f7bSTejun Heo const char *new_name, const void *new_ns) 1685fd7b9f7bSTejun Heo { 16863eef34adSTejun Heo struct kernfs_node *old_parent; 1687393c3714SMinchan Kim struct kernfs_root *root; 16883eef34adSTejun Heo const char *old_name = NULL; 1689fd7b9f7bSTejun Heo int error; 1690fd7b9f7bSTejun Heo 16913eef34adSTejun Heo /* can't move or rename root */ 16923eef34adSTejun Heo if (!kn->parent) 16933eef34adSTejun Heo return -EINVAL; 16943eef34adSTejun Heo 1695393c3714SMinchan Kim root = kernfs_root(kn); 1696393c3714SMinchan Kim down_write(&root->kernfs_rwsem); 1697d0ae3d43STejun Heo 1698798c75a0SGreg Kroah-Hartman error = -ENOENT; 1699ea015218SEric W. Biederman if (!kernfs_active(kn) || !kernfs_active(new_parent) || 1700ea015218SEric W. Biederman (new_parent->flags & KERNFS_EMPTY_DIR)) 1701798c75a0SGreg Kroah-Hartman goto out; 1702798c75a0SGreg Kroah-Hartman 1703fd7b9f7bSTejun Heo error = 0; 1704adc5e8b5STejun Heo if ((kn->parent == new_parent) && (kn->ns == new_ns) && 1705adc5e8b5STejun Heo (strcmp(kn->name, new_name) == 0)) 1706798c75a0SGreg Kroah-Hartman goto out; /* nothing to rename */ 1707fd7b9f7bSTejun Heo 1708fd7b9f7bSTejun Heo error = -EEXIST; 1709fd7b9f7bSTejun Heo if (kernfs_find_ns(new_parent, new_name, new_ns)) 1710798c75a0SGreg Kroah-Hartman goto out; 1711fd7b9f7bSTejun Heo 1712324a56e1STejun Heo /* rename kernfs_node */ 1713adc5e8b5STejun Heo if (strcmp(kn->name, new_name) != 0) { 1714fd7b9f7bSTejun Heo error = -ENOMEM; 171575287a67SAndrzej Hajda new_name = kstrdup_const(new_name, GFP_KERNEL); 1716fd7b9f7bSTejun Heo if (!new_name) 1717798c75a0SGreg Kroah-Hartman goto out; 17183eef34adSTejun Heo } else { 17193eef34adSTejun Heo new_name = NULL; 1720fd7b9f7bSTejun Heo } 1721fd7b9f7bSTejun Heo 1722fd7b9f7bSTejun Heo /* 1723fd7b9f7bSTejun Heo * Move to the appropriate place in the appropriate directories rbtree. 1724fd7b9f7bSTejun Heo */ 1725c637b8acSTejun Heo kernfs_unlink_sibling(kn); 1726fd7b9f7bSTejun Heo kernfs_get(new_parent); 17273eef34adSTejun Heo 17283eef34adSTejun Heo /* rename_lock protects ->parent and ->name accessors */ 17293eef34adSTejun Heo spin_lock_irq(&kernfs_rename_lock); 17303eef34adSTejun Heo 17313eef34adSTejun Heo old_parent = kn->parent; 1732adc5e8b5STejun Heo kn->parent = new_parent; 17333eef34adSTejun Heo 17343eef34adSTejun Heo kn->ns = new_ns; 17353eef34adSTejun Heo if (new_name) { 17363eef34adSTejun Heo old_name = kn->name; 17373eef34adSTejun Heo kn->name = new_name; 17383eef34adSTejun Heo } 17393eef34adSTejun Heo 17403eef34adSTejun Heo spin_unlock_irq(&kernfs_rename_lock); 17413eef34adSTejun Heo 17429561a896STejun Heo kn->hash = kernfs_name_hash(kn->name, kn->ns); 1743c637b8acSTejun Heo kernfs_link_sibling(kn); 1744fd7b9f7bSTejun Heo 17453eef34adSTejun Heo kernfs_put(old_parent); 174675287a67SAndrzej Hajda kfree_const(old_name); 17473eef34adSTejun Heo 1748fd7b9f7bSTejun Heo error = 0; 1749ae34372eSTejun Heo out: 1750393c3714SMinchan Kim up_write(&root->kernfs_rwsem); 1751fd7b9f7bSTejun Heo return error; 1752fd7b9f7bSTejun Heo } 1753fd7b9f7bSTejun Heo 175421774fd8SWillem de Bruijn /* Relationship between mode and the DT_xxx types */ 1755324a56e1STejun Heo static inline unsigned char dt_type(struct kernfs_node *kn) 1756fd7b9f7bSTejun Heo { 1757adc5e8b5STejun Heo return (kn->mode >> 12) & 15; 1758fd7b9f7bSTejun Heo } 1759fd7b9f7bSTejun Heo 1760c637b8acSTejun Heo static int kernfs_dir_fop_release(struct inode *inode, struct file *filp) 1761fd7b9f7bSTejun Heo { 1762fd7b9f7bSTejun Heo kernfs_put(filp->private_data); 1763fd7b9f7bSTejun Heo return 0; 1764fd7b9f7bSTejun Heo } 1765fd7b9f7bSTejun Heo 1766c637b8acSTejun Heo static struct kernfs_node *kernfs_dir_pos(const void *ns, 1767324a56e1STejun Heo struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos) 1768fd7b9f7bSTejun Heo { 1769fd7b9f7bSTejun Heo if (pos) { 177081c173cbSTejun Heo int valid = kernfs_active(pos) && 1771798c75a0SGreg Kroah-Hartman pos->parent == parent && hash == pos->hash; 1772fd7b9f7bSTejun Heo kernfs_put(pos); 1773fd7b9f7bSTejun Heo if (!valid) 1774fd7b9f7bSTejun Heo pos = NULL; 1775fd7b9f7bSTejun Heo } 1776fd7b9f7bSTejun Heo if (!pos && (hash > 1) && (hash < INT_MAX)) { 1777adc5e8b5STejun Heo struct rb_node *node = parent->dir.children.rb_node; 1778fd7b9f7bSTejun Heo while (node) { 1779324a56e1STejun Heo pos = rb_to_kn(node); 1780fd7b9f7bSTejun Heo 1781adc5e8b5STejun Heo if (hash < pos->hash) 1782fd7b9f7bSTejun Heo node = node->rb_left; 1783adc5e8b5STejun Heo else if (hash > pos->hash) 1784fd7b9f7bSTejun Heo node = node->rb_right; 1785fd7b9f7bSTejun Heo else 1786fd7b9f7bSTejun Heo break; 1787fd7b9f7bSTejun Heo } 1788fd7b9f7bSTejun Heo } 1789b9c9dad0STejun Heo /* Skip over entries which are dying/dead or in the wrong namespace */ 1790b9c9dad0STejun Heo while (pos && (!kernfs_active(pos) || pos->ns != ns)) { 1791adc5e8b5STejun Heo struct rb_node *node = rb_next(&pos->rb); 1792fd7b9f7bSTejun Heo if (!node) 1793fd7b9f7bSTejun Heo pos = NULL; 1794fd7b9f7bSTejun Heo else 1795324a56e1STejun Heo pos = rb_to_kn(node); 1796fd7b9f7bSTejun Heo } 1797fd7b9f7bSTejun Heo return pos; 1798fd7b9f7bSTejun Heo } 1799fd7b9f7bSTejun Heo 1800c637b8acSTejun Heo static struct kernfs_node *kernfs_dir_next_pos(const void *ns, 1801324a56e1STejun Heo struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos) 1802fd7b9f7bSTejun Heo { 1803c637b8acSTejun Heo pos = kernfs_dir_pos(ns, parent, ino, pos); 1804b9c9dad0STejun Heo if (pos) { 1805fd7b9f7bSTejun Heo do { 1806adc5e8b5STejun Heo struct rb_node *node = rb_next(&pos->rb); 1807fd7b9f7bSTejun Heo if (!node) 1808fd7b9f7bSTejun Heo pos = NULL; 1809fd7b9f7bSTejun Heo else 1810324a56e1STejun Heo pos = rb_to_kn(node); 1811b9c9dad0STejun Heo } while (pos && (!kernfs_active(pos) || pos->ns != ns)); 1812b9c9dad0STejun Heo } 1813fd7b9f7bSTejun Heo return pos; 1814fd7b9f7bSTejun Heo } 1815fd7b9f7bSTejun Heo 1816c637b8acSTejun Heo static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx) 1817fd7b9f7bSTejun Heo { 1818fd7b9f7bSTejun Heo struct dentry *dentry = file->f_path.dentry; 1819319ba91dSShaohua Li struct kernfs_node *parent = kernfs_dentry_node(dentry); 1820324a56e1STejun Heo struct kernfs_node *pos = file->private_data; 1821393c3714SMinchan Kim struct kernfs_root *root; 1822fd7b9f7bSTejun Heo const void *ns = NULL; 1823fd7b9f7bSTejun Heo 1824fd7b9f7bSTejun Heo if (!dir_emit_dots(file, ctx)) 1825fd7b9f7bSTejun Heo return 0; 1826393c3714SMinchan Kim 1827393c3714SMinchan Kim root = kernfs_root(parent); 1828393c3714SMinchan Kim down_read(&root->kernfs_rwsem); 1829fd7b9f7bSTejun Heo 1830324a56e1STejun Heo if (kernfs_ns_enabled(parent)) 1831c525aaddSTejun Heo ns = kernfs_info(dentry->d_sb)->ns; 1832fd7b9f7bSTejun Heo 1833c637b8acSTejun Heo for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos); 1834fd7b9f7bSTejun Heo pos; 1835c637b8acSTejun Heo pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) { 1836adc5e8b5STejun Heo const char *name = pos->name; 1837fd7b9f7bSTejun Heo unsigned int type = dt_type(pos); 1838fd7b9f7bSTejun Heo int len = strlen(name); 183967c0496eSTejun Heo ino_t ino = kernfs_ino(pos); 1840fd7b9f7bSTejun Heo 1841adc5e8b5STejun Heo ctx->pos = pos->hash; 1842fd7b9f7bSTejun Heo file->private_data = pos; 1843fd7b9f7bSTejun Heo kernfs_get(pos); 1844fd7b9f7bSTejun Heo 1845393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1846fd7b9f7bSTejun Heo if (!dir_emit(ctx, name, len, ino, type)) 1847fd7b9f7bSTejun Heo return 0; 1848393c3714SMinchan Kim down_read(&root->kernfs_rwsem); 1849fd7b9f7bSTejun Heo } 1850393c3714SMinchan Kim up_read(&root->kernfs_rwsem); 1851fd7b9f7bSTejun Heo file->private_data = NULL; 1852fd7b9f7bSTejun Heo ctx->pos = INT_MAX; 1853fd7b9f7bSTejun Heo return 0; 1854fd7b9f7bSTejun Heo } 1855fd7b9f7bSTejun Heo 1856a797bfc3STejun Heo const struct file_operations kernfs_dir_fops = { 1857fd7b9f7bSTejun Heo .read = generic_read_dir, 18588cb0d2c1SAl Viro .iterate_shared = kernfs_fop_readdir, 1859c637b8acSTejun Heo .release = kernfs_dir_fop_release, 18608cb0d2c1SAl Viro .llseek = generic_file_llseek, 1861fd7b9f7bSTejun Heo }; 1862