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 20a797bfc3STejun Heo DEFINE_MUTEX(kernfs_mutex); 213eef34adSTejun Heo static DEFINE_SPINLOCK(kernfs_rename_lock); /* kn->parent and ->name */ 223eef34adSTejun Heo static char kernfs_pr_cont_buf[PATH_MAX]; /* protected by rename_lock */ 237d35079fSShaohua Li static DEFINE_SPINLOCK(kernfs_idr_lock); /* root->ino_idr */ 24fd7b9f7bSTejun Heo 25adc5e8b5STejun Heo #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb) 26fd7b9f7bSTejun Heo 2781c173cbSTejun Heo static bool kernfs_active(struct kernfs_node *kn) 2881c173cbSTejun Heo { 2981c173cbSTejun Heo lockdep_assert_held(&kernfs_mutex); 3081c173cbSTejun Heo return atomic_read(&kn->active) >= 0; 3181c173cbSTejun Heo } 3281c173cbSTejun Heo 33182fd64bSTejun Heo static bool kernfs_lockdep(struct kernfs_node *kn) 34182fd64bSTejun Heo { 35182fd64bSTejun Heo #ifdef CONFIG_DEBUG_LOCK_ALLOC 36182fd64bSTejun Heo return kn->flags & KERNFS_LOCKDEP; 37182fd64bSTejun Heo #else 38182fd64bSTejun Heo return false; 39182fd64bSTejun Heo #endif 40182fd64bSTejun Heo } 41182fd64bSTejun Heo 423eef34adSTejun Heo static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen) 433eef34adSTejun Heo { 4417627157SKonstantin Khlebnikov if (!kn) 4517627157SKonstantin Khlebnikov return strlcpy(buf, "(null)", buflen); 4617627157SKonstantin Khlebnikov 473eef34adSTejun Heo return strlcpy(buf, kn->parent ? kn->name : "/", buflen); 483eef34adSTejun Heo } 493eef34adSTejun Heo 509f6df573SAditya Kali /* kernfs_node_depth - compute depth from @from to @to */ 519f6df573SAditya Kali static size_t kernfs_depth(struct kernfs_node *from, struct kernfs_node *to) 523eef34adSTejun Heo { 539f6df573SAditya Kali size_t depth = 0; 543eef34adSTejun Heo 559f6df573SAditya Kali while (to->parent && to != from) { 569f6df573SAditya Kali depth++; 579f6df573SAditya Kali to = to->parent; 583eef34adSTejun Heo } 599f6df573SAditya Kali return depth; 609f6df573SAditya Kali } 613eef34adSTejun Heo 629f6df573SAditya Kali static struct kernfs_node *kernfs_common_ancestor(struct kernfs_node *a, 639f6df573SAditya Kali struct kernfs_node *b) 649f6df573SAditya Kali { 659f6df573SAditya Kali size_t da, db; 669f6df573SAditya Kali struct kernfs_root *ra = kernfs_root(a), *rb = kernfs_root(b); 679f6df573SAditya Kali 689f6df573SAditya Kali if (ra != rb) 699f6df573SAditya Kali return NULL; 709f6df573SAditya Kali 719f6df573SAditya Kali da = kernfs_depth(ra->kn, a); 729f6df573SAditya Kali db = kernfs_depth(rb->kn, b); 739f6df573SAditya Kali 749f6df573SAditya Kali while (da > db) { 759f6df573SAditya Kali a = a->parent; 769f6df573SAditya Kali da--; 779f6df573SAditya Kali } 789f6df573SAditya Kali while (db > da) { 799f6df573SAditya Kali b = b->parent; 809f6df573SAditya Kali db--; 819f6df573SAditya Kali } 829f6df573SAditya Kali 839f6df573SAditya Kali /* worst case b and a will be the same at root */ 849f6df573SAditya Kali while (b != a) { 859f6df573SAditya Kali b = b->parent; 869f6df573SAditya Kali a = a->parent; 879f6df573SAditya Kali } 889f6df573SAditya Kali 899f6df573SAditya Kali return a; 909f6df573SAditya Kali } 919f6df573SAditya Kali 929f6df573SAditya Kali /** 939f6df573SAditya Kali * kernfs_path_from_node_locked - find a pseudo-absolute path to @kn_to, 949f6df573SAditya Kali * where kn_from is treated as root of the path. 959f6df573SAditya Kali * @kn_from: kernfs node which should be treated as root for the path 969f6df573SAditya Kali * @kn_to: kernfs node to which path is needed 979f6df573SAditya Kali * @buf: buffer to copy the path into 989f6df573SAditya Kali * @buflen: size of @buf 999f6df573SAditya Kali * 1009f6df573SAditya Kali * We need to handle couple of scenarios here: 1019f6df573SAditya Kali * [1] when @kn_from is an ancestor of @kn_to at some level 1029f6df573SAditya Kali * kn_from: /n1/n2/n3 1039f6df573SAditya Kali * kn_to: /n1/n2/n3/n4/n5 1049f6df573SAditya Kali * result: /n4/n5 1059f6df573SAditya Kali * 1069f6df573SAditya Kali * [2] when @kn_from is on a different hierarchy and we need to find common 1079f6df573SAditya Kali * ancestor between @kn_from and @kn_to. 1089f6df573SAditya Kali * kn_from: /n1/n2/n3/n4 1099f6df573SAditya Kali * kn_to: /n1/n2/n5 1109f6df573SAditya Kali * result: /../../n5 1119f6df573SAditya Kali * OR 1129f6df573SAditya Kali * kn_from: /n1/n2/n3/n4/n5 [depth=5] 1139f6df573SAditya Kali * kn_to: /n1/n2/n3 [depth=3] 1149f6df573SAditya Kali * result: /../.. 1159f6df573SAditya Kali * 11617627157SKonstantin Khlebnikov * [3] when @kn_to is NULL result will be "(null)" 11717627157SKonstantin Khlebnikov * 1183abb1d90STejun Heo * Returns the length of the full path. If the full length is equal to or 1193abb1d90STejun Heo * greater than @buflen, @buf contains the truncated path with the trailing 1203abb1d90STejun Heo * '\0'. On error, -errno is returned. 1219f6df573SAditya Kali */ 1229f6df573SAditya Kali static int kernfs_path_from_node_locked(struct kernfs_node *kn_to, 1239f6df573SAditya Kali struct kernfs_node *kn_from, 1249f6df573SAditya Kali char *buf, size_t buflen) 1259f6df573SAditya Kali { 1269f6df573SAditya Kali struct kernfs_node *kn, *common; 1279f6df573SAditya Kali const char parent_str[] = "/.."; 1283abb1d90STejun Heo size_t depth_from, depth_to, len = 0; 1293abb1d90STejun Heo int i, j; 1309f6df573SAditya Kali 13117627157SKonstantin Khlebnikov if (!kn_to) 13217627157SKonstantin Khlebnikov return strlcpy(buf, "(null)", buflen); 13317627157SKonstantin Khlebnikov 1349f6df573SAditya Kali if (!kn_from) 1359f6df573SAditya Kali kn_from = kernfs_root(kn_to)->kn; 1369f6df573SAditya Kali 1379f6df573SAditya Kali if (kn_from == kn_to) 1389f6df573SAditya Kali return strlcpy(buf, "/", buflen); 1399f6df573SAditya Kali 140bbe70e4eSJia-Ju Bai if (!buf) 141bbe70e4eSJia-Ju Bai return -EINVAL; 142bbe70e4eSJia-Ju Bai 1439f6df573SAditya Kali common = kernfs_common_ancestor(kn_from, kn_to); 1449f6df573SAditya Kali if (WARN_ON(!common)) 1453abb1d90STejun Heo return -EINVAL; 1469f6df573SAditya Kali 1479f6df573SAditya Kali depth_to = kernfs_depth(common, kn_to); 1489f6df573SAditya Kali depth_from = kernfs_depth(common, kn_from); 1499f6df573SAditya Kali 1509f6df573SAditya Kali buf[0] = '\0'; 1519f6df573SAditya Kali 1529f6df573SAditya Kali for (i = 0; i < depth_from; i++) 1539f6df573SAditya Kali len += strlcpy(buf + len, parent_str, 1549f6df573SAditya Kali len < buflen ? buflen - len : 0); 1559f6df573SAditya Kali 1569f6df573SAditya Kali /* Calculate how many bytes we need for the rest */ 1573abb1d90STejun Heo for (i = depth_to - 1; i >= 0; i--) { 1583abb1d90STejun Heo for (kn = kn_to, j = 0; j < i; j++) 1593abb1d90STejun Heo kn = kn->parent; 1603abb1d90STejun Heo len += strlcpy(buf + len, "/", 1613abb1d90STejun Heo len < buflen ? buflen - len : 0); 1623abb1d90STejun Heo len += strlcpy(buf + len, kn->name, 1633abb1d90STejun Heo len < buflen ? buflen - len : 0); 1649f6df573SAditya Kali } 1659f6df573SAditya Kali 1663abb1d90STejun Heo return len; 1673eef34adSTejun Heo } 1683eef34adSTejun Heo 1693eef34adSTejun Heo /** 1703eef34adSTejun Heo * kernfs_name - obtain the name of a given node 1713eef34adSTejun Heo * @kn: kernfs_node of interest 1723eef34adSTejun Heo * @buf: buffer to copy @kn's name into 1733eef34adSTejun Heo * @buflen: size of @buf 1743eef34adSTejun Heo * 1753eef34adSTejun Heo * Copies the name of @kn into @buf of @buflen bytes. The behavior is 1763eef34adSTejun Heo * similar to strlcpy(). It returns the length of @kn's name and if @buf 1773eef34adSTejun Heo * isn't long enough, it's filled upto @buflen-1 and nul terminated. 1783eef34adSTejun Heo * 17917627157SKonstantin Khlebnikov * Fills buffer with "(null)" if @kn is NULL. 18017627157SKonstantin Khlebnikov * 1813eef34adSTejun Heo * This function can be called from any context. 1823eef34adSTejun Heo */ 1833eef34adSTejun Heo int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 1843eef34adSTejun Heo { 1853eef34adSTejun Heo unsigned long flags; 1863eef34adSTejun Heo int ret; 1873eef34adSTejun Heo 1883eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 1893eef34adSTejun Heo ret = kernfs_name_locked(kn, buf, buflen); 1903eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 1913eef34adSTejun Heo return ret; 1923eef34adSTejun Heo } 1933eef34adSTejun Heo 1943eef34adSTejun Heo /** 1959f6df573SAditya Kali * kernfs_path_from_node - build path of node @to relative to @from. 1969f6df573SAditya Kali * @from: parent kernfs_node relative to which we need to build the path 1979f6df573SAditya Kali * @to: kernfs_node of interest 1989f6df573SAditya Kali * @buf: buffer to copy @to's path into 1999f6df573SAditya Kali * @buflen: size of @buf 2009f6df573SAditya Kali * 2019f6df573SAditya Kali * Builds @to's path relative to @from in @buf. @from and @to must 2029f6df573SAditya Kali * be on the same kernfs-root. If @from is not parent of @to, then a relative 2039f6df573SAditya Kali * path (which includes '..'s) as needed to reach from @from to @to is 2049f6df573SAditya Kali * returned. 2059f6df573SAditya Kali * 2063abb1d90STejun Heo * Returns the length of the full path. If the full length is equal to or 2073abb1d90STejun Heo * greater than @buflen, @buf contains the truncated path with the trailing 2083abb1d90STejun Heo * '\0'. On error, -errno is returned. 2099f6df573SAditya Kali */ 2109f6df573SAditya Kali int kernfs_path_from_node(struct kernfs_node *to, struct kernfs_node *from, 2119f6df573SAditya Kali char *buf, size_t buflen) 2129f6df573SAditya Kali { 2139f6df573SAditya Kali unsigned long flags; 2149f6df573SAditya Kali int ret; 2159f6df573SAditya Kali 2169f6df573SAditya Kali spin_lock_irqsave(&kernfs_rename_lock, flags); 2179f6df573SAditya Kali ret = kernfs_path_from_node_locked(to, from, buf, buflen); 2189f6df573SAditya Kali spin_unlock_irqrestore(&kernfs_rename_lock, flags); 2199f6df573SAditya Kali return ret; 2209f6df573SAditya Kali } 2219f6df573SAditya Kali EXPORT_SYMBOL_GPL(kernfs_path_from_node); 2229f6df573SAditya Kali 2239f6df573SAditya Kali /** 2243eef34adSTejun Heo * pr_cont_kernfs_name - pr_cont name of a kernfs_node 2253eef34adSTejun Heo * @kn: kernfs_node of interest 2263eef34adSTejun Heo * 2273eef34adSTejun Heo * This function can be called from any context. 2283eef34adSTejun Heo */ 2293eef34adSTejun Heo void pr_cont_kernfs_name(struct kernfs_node *kn) 2303eef34adSTejun Heo { 2313eef34adSTejun Heo unsigned long flags; 2323eef34adSTejun Heo 2333eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 2343eef34adSTejun Heo 2353eef34adSTejun Heo kernfs_name_locked(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf)); 2363eef34adSTejun Heo pr_cont("%s", kernfs_pr_cont_buf); 2373eef34adSTejun Heo 2383eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 2393eef34adSTejun Heo } 2403eef34adSTejun Heo 2413eef34adSTejun Heo /** 2423eef34adSTejun Heo * pr_cont_kernfs_path - pr_cont path of a kernfs_node 2433eef34adSTejun Heo * @kn: kernfs_node of interest 2443eef34adSTejun Heo * 2453eef34adSTejun Heo * This function can be called from any context. 2463eef34adSTejun Heo */ 2473eef34adSTejun Heo void pr_cont_kernfs_path(struct kernfs_node *kn) 2483eef34adSTejun Heo { 2493eef34adSTejun Heo unsigned long flags; 2509f6df573SAditya Kali int sz; 2513eef34adSTejun Heo 2523eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 2533eef34adSTejun Heo 2549f6df573SAditya Kali sz = kernfs_path_from_node_locked(kn, NULL, kernfs_pr_cont_buf, 2553eef34adSTejun Heo sizeof(kernfs_pr_cont_buf)); 2569f6df573SAditya Kali if (sz < 0) { 2579f6df573SAditya Kali pr_cont("(error)"); 2589f6df573SAditya Kali goto out; 2599f6df573SAditya Kali } 2603eef34adSTejun Heo 2619f6df573SAditya Kali if (sz >= sizeof(kernfs_pr_cont_buf)) { 2629f6df573SAditya Kali pr_cont("(name too long)"); 2639f6df573SAditya Kali goto out; 2649f6df573SAditya Kali } 2659f6df573SAditya Kali 2669f6df573SAditya Kali pr_cont("%s", kernfs_pr_cont_buf); 2679f6df573SAditya Kali 2689f6df573SAditya Kali out: 2693eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 2703eef34adSTejun Heo } 2713eef34adSTejun Heo 2723eef34adSTejun Heo /** 2733eef34adSTejun Heo * kernfs_get_parent - determine the parent node and pin it 2743eef34adSTejun Heo * @kn: kernfs_node of interest 2753eef34adSTejun Heo * 2763eef34adSTejun Heo * Determines @kn's parent, pins and returns it. This function can be 2773eef34adSTejun Heo * called from any context. 2783eef34adSTejun Heo */ 2793eef34adSTejun Heo struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 2803eef34adSTejun Heo { 2813eef34adSTejun Heo struct kernfs_node *parent; 2823eef34adSTejun Heo unsigned long flags; 2833eef34adSTejun Heo 2843eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 2853eef34adSTejun Heo parent = kn->parent; 2863eef34adSTejun Heo kernfs_get(parent); 2873eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 2883eef34adSTejun Heo 2893eef34adSTejun Heo return parent; 2903eef34adSTejun Heo } 2913eef34adSTejun Heo 292fd7b9f7bSTejun Heo /** 293c637b8acSTejun Heo * kernfs_name_hash 294fd7b9f7bSTejun Heo * @name: Null terminated string to hash 295fd7b9f7bSTejun Heo * @ns: Namespace tag to hash 296fd7b9f7bSTejun Heo * 297fd7b9f7bSTejun Heo * Returns 31 bit hash of ns + name (so it fits in an off_t ) 298fd7b9f7bSTejun Heo */ 299c637b8acSTejun Heo static unsigned int kernfs_name_hash(const char *name, const void *ns) 300fd7b9f7bSTejun Heo { 3018387ff25SLinus Torvalds unsigned long hash = init_name_hash(ns); 302fd7b9f7bSTejun Heo unsigned int len = strlen(name); 303fd7b9f7bSTejun Heo while (len--) 304fd7b9f7bSTejun Heo hash = partial_name_hash(*name++, hash); 3058387ff25SLinus Torvalds hash = end_name_hash(hash); 306fd7b9f7bSTejun Heo hash &= 0x7fffffffU; 307fd7b9f7bSTejun Heo /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */ 30888391d49SRichard Cochran if (hash < 2) 309fd7b9f7bSTejun Heo hash += 2; 310fd7b9f7bSTejun Heo if (hash >= INT_MAX) 311fd7b9f7bSTejun Heo hash = INT_MAX - 1; 312fd7b9f7bSTejun Heo return hash; 313fd7b9f7bSTejun Heo } 314fd7b9f7bSTejun Heo 315c637b8acSTejun Heo static int kernfs_name_compare(unsigned int hash, const char *name, 316324a56e1STejun Heo const void *ns, const struct kernfs_node *kn) 317fd7b9f7bSTejun Heo { 31872392ed0SRasmus Villemoes if (hash < kn->hash) 31972392ed0SRasmus Villemoes return -1; 32072392ed0SRasmus Villemoes if (hash > kn->hash) 32172392ed0SRasmus Villemoes return 1; 32272392ed0SRasmus Villemoes if (ns < kn->ns) 32372392ed0SRasmus Villemoes return -1; 32472392ed0SRasmus Villemoes if (ns > kn->ns) 32572392ed0SRasmus Villemoes return 1; 326adc5e8b5STejun Heo return strcmp(name, kn->name); 327fd7b9f7bSTejun Heo } 328fd7b9f7bSTejun Heo 329c637b8acSTejun Heo static int kernfs_sd_compare(const struct kernfs_node *left, 330324a56e1STejun Heo const struct kernfs_node *right) 331fd7b9f7bSTejun Heo { 332c637b8acSTejun Heo return kernfs_name_compare(left->hash, left->name, left->ns, right); 333fd7b9f7bSTejun Heo } 334fd7b9f7bSTejun Heo 335fd7b9f7bSTejun Heo /** 336c637b8acSTejun Heo * kernfs_link_sibling - link kernfs_node into sibling rbtree 337324a56e1STejun Heo * @kn: kernfs_node of interest 338fd7b9f7bSTejun Heo * 339324a56e1STejun Heo * Link @kn into its sibling rbtree which starts from 340adc5e8b5STejun Heo * @kn->parent->dir.children. 341fd7b9f7bSTejun Heo * 342fd7b9f7bSTejun Heo * Locking: 343a797bfc3STejun Heo * mutex_lock(kernfs_mutex) 344fd7b9f7bSTejun Heo * 345fd7b9f7bSTejun Heo * RETURNS: 346fd7b9f7bSTejun Heo * 0 on susccess -EEXIST on failure. 347fd7b9f7bSTejun Heo */ 348c637b8acSTejun Heo static int kernfs_link_sibling(struct kernfs_node *kn) 349fd7b9f7bSTejun Heo { 350adc5e8b5STejun Heo struct rb_node **node = &kn->parent->dir.children.rb_node; 351fd7b9f7bSTejun Heo struct rb_node *parent = NULL; 352fd7b9f7bSTejun Heo 353fd7b9f7bSTejun Heo while (*node) { 354324a56e1STejun Heo struct kernfs_node *pos; 355fd7b9f7bSTejun Heo int result; 356fd7b9f7bSTejun Heo 357324a56e1STejun Heo pos = rb_to_kn(*node); 358fd7b9f7bSTejun Heo parent = *node; 359c637b8acSTejun Heo result = kernfs_sd_compare(kn, pos); 360fd7b9f7bSTejun Heo if (result < 0) 361adc5e8b5STejun Heo node = &pos->rb.rb_left; 362fd7b9f7bSTejun Heo else if (result > 0) 363adc5e8b5STejun Heo node = &pos->rb.rb_right; 364fd7b9f7bSTejun Heo else 365fd7b9f7bSTejun Heo return -EEXIST; 366fd7b9f7bSTejun Heo } 367c1befb88SJianyu Zhan 368fd7b9f7bSTejun Heo /* add new node and rebalance the tree */ 369adc5e8b5STejun Heo rb_link_node(&kn->rb, parent, node); 370adc5e8b5STejun Heo rb_insert_color(&kn->rb, &kn->parent->dir.children); 371c1befb88SJianyu Zhan 372c1befb88SJianyu Zhan /* successfully added, account subdir number */ 373c1befb88SJianyu Zhan if (kernfs_type(kn) == KERNFS_DIR) 374c1befb88SJianyu Zhan kn->parent->dir.subdirs++; 375*895adbecSIan Kent kernfs_inc_rev(kn->parent); 376c1befb88SJianyu Zhan 377fd7b9f7bSTejun Heo return 0; 378fd7b9f7bSTejun Heo } 379fd7b9f7bSTejun Heo 380fd7b9f7bSTejun Heo /** 381c637b8acSTejun Heo * kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree 382324a56e1STejun Heo * @kn: kernfs_node of interest 383fd7b9f7bSTejun Heo * 38435beab06STejun Heo * Try to unlink @kn from its sibling rbtree which starts from 38535beab06STejun Heo * kn->parent->dir.children. Returns %true if @kn was actually 38635beab06STejun Heo * removed, %false if @kn wasn't on the rbtree. 387fd7b9f7bSTejun Heo * 388fd7b9f7bSTejun Heo * Locking: 389a797bfc3STejun Heo * mutex_lock(kernfs_mutex) 390fd7b9f7bSTejun Heo */ 39135beab06STejun Heo static bool kernfs_unlink_sibling(struct kernfs_node *kn) 392fd7b9f7bSTejun Heo { 39335beab06STejun Heo if (RB_EMPTY_NODE(&kn->rb)) 39435beab06STejun Heo return false; 39535beab06STejun Heo 396df23fc39STejun Heo if (kernfs_type(kn) == KERNFS_DIR) 397adc5e8b5STejun Heo kn->parent->dir.subdirs--; 398*895adbecSIan Kent kernfs_inc_rev(kn->parent); 399fd7b9f7bSTejun Heo 400adc5e8b5STejun Heo rb_erase(&kn->rb, &kn->parent->dir.children); 40135beab06STejun Heo RB_CLEAR_NODE(&kn->rb); 40235beab06STejun Heo return true; 403fd7b9f7bSTejun Heo } 404fd7b9f7bSTejun Heo 405fd7b9f7bSTejun Heo /** 406c637b8acSTejun Heo * kernfs_get_active - get an active reference to kernfs_node 407324a56e1STejun Heo * @kn: kernfs_node to get an active reference to 408fd7b9f7bSTejun Heo * 409324a56e1STejun Heo * Get an active reference of @kn. This function is noop if @kn 410fd7b9f7bSTejun Heo * is NULL. 411fd7b9f7bSTejun Heo * 412fd7b9f7bSTejun Heo * RETURNS: 413324a56e1STejun Heo * Pointer to @kn on success, NULL on failure. 414fd7b9f7bSTejun Heo */ 415c637b8acSTejun Heo struct kernfs_node *kernfs_get_active(struct kernfs_node *kn) 416fd7b9f7bSTejun Heo { 417324a56e1STejun Heo if (unlikely(!kn)) 418fd7b9f7bSTejun Heo return NULL; 419fd7b9f7bSTejun Heo 420f4b3e631SGreg Kroah-Hartman if (!atomic_inc_unless_negative(&kn->active)) 421f4b3e631SGreg Kroah-Hartman return NULL; 422f4b3e631SGreg Kroah-Hartman 423182fd64bSTejun Heo if (kernfs_lockdep(kn)) 424324a56e1STejun Heo rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_); 425324a56e1STejun Heo return kn; 426fd7b9f7bSTejun Heo } 427fd7b9f7bSTejun Heo 428fd7b9f7bSTejun Heo /** 429c637b8acSTejun Heo * kernfs_put_active - put an active reference to kernfs_node 430324a56e1STejun Heo * @kn: kernfs_node to put an active reference to 431fd7b9f7bSTejun Heo * 432324a56e1STejun Heo * Put an active reference to @kn. This function is noop if @kn 433fd7b9f7bSTejun Heo * is NULL. 434fd7b9f7bSTejun Heo */ 435c637b8acSTejun Heo void kernfs_put_active(struct kernfs_node *kn) 436fd7b9f7bSTejun Heo { 437fd7b9f7bSTejun Heo int v; 438fd7b9f7bSTejun Heo 439324a56e1STejun Heo if (unlikely(!kn)) 440fd7b9f7bSTejun Heo return; 441fd7b9f7bSTejun Heo 442182fd64bSTejun Heo if (kernfs_lockdep(kn)) 4435facae4fSQian Cai rwsem_release(&kn->dep_map, _RET_IP_); 444adc5e8b5STejun Heo v = atomic_dec_return(&kn->active); 445df23fc39STejun Heo if (likely(v != KN_DEACTIVATED_BIAS)) 446fd7b9f7bSTejun Heo return; 447fd7b9f7bSTejun Heo 4482fd60da4SPeng Wang wake_up_all(&kernfs_root(kn)->deactivate_waitq); 449fd7b9f7bSTejun Heo } 450fd7b9f7bSTejun Heo 451fd7b9f7bSTejun Heo /** 45281c173cbSTejun Heo * kernfs_drain - drain kernfs_node 45381c173cbSTejun Heo * @kn: kernfs_node to drain 454fd7b9f7bSTejun Heo * 45581c173cbSTejun Heo * Drain existing usages and nuke all existing mmaps of @kn. Mutiple 45681c173cbSTejun Heo * removers may invoke this function concurrently on @kn and all will 45781c173cbSTejun Heo * return after draining is complete. 458fd7b9f7bSTejun Heo */ 45981c173cbSTejun Heo static void kernfs_drain(struct kernfs_node *kn) 46035beab06STejun Heo __releases(&kernfs_mutex) __acquires(&kernfs_mutex) 461fd7b9f7bSTejun Heo { 462abd54f02STejun Heo struct kernfs_root *root = kernfs_root(kn); 463fd7b9f7bSTejun Heo 46435beab06STejun Heo lockdep_assert_held(&kernfs_mutex); 46581c173cbSTejun Heo WARN_ON_ONCE(kernfs_active(kn)); 466abd54f02STejun Heo 46735beab06STejun Heo mutex_unlock(&kernfs_mutex); 468abd54f02STejun Heo 469182fd64bSTejun Heo if (kernfs_lockdep(kn)) { 47035beab06STejun Heo rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_); 47135beab06STejun Heo if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS) 47235beab06STejun Heo lock_contended(&kn->dep_map, _RET_IP_); 47335beab06STejun Heo } 47435beab06STejun Heo 47535beab06STejun Heo /* but everyone should wait for draining */ 476abd54f02STejun Heo wait_event(root->deactivate_waitq, 477abd54f02STejun Heo atomic_read(&kn->active) == KN_DEACTIVATED_BIAS); 478fd7b9f7bSTejun Heo 479182fd64bSTejun Heo if (kernfs_lockdep(kn)) { 480324a56e1STejun Heo lock_acquired(&kn->dep_map, _RET_IP_); 4815facae4fSQian Cai rwsem_release(&kn->dep_map, _RET_IP_); 482fd7b9f7bSTejun Heo } 48335beab06STejun Heo 4840e67db2fSTejun Heo kernfs_drain_open_files(kn); 485ccf02aafSTejun Heo 48635beab06STejun Heo mutex_lock(&kernfs_mutex); 487a6607930STejun Heo } 488fd7b9f7bSTejun Heo 489fd7b9f7bSTejun Heo /** 490324a56e1STejun Heo * kernfs_get - get a reference count on a kernfs_node 491324a56e1STejun Heo * @kn: the target kernfs_node 492fd7b9f7bSTejun Heo */ 493324a56e1STejun Heo void kernfs_get(struct kernfs_node *kn) 494fd7b9f7bSTejun Heo { 495324a56e1STejun Heo if (kn) { 496adc5e8b5STejun Heo WARN_ON(!atomic_read(&kn->count)); 497adc5e8b5STejun Heo atomic_inc(&kn->count); 498fd7b9f7bSTejun Heo } 499fd7b9f7bSTejun Heo } 500fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_get); 501fd7b9f7bSTejun Heo 502fd7b9f7bSTejun Heo /** 503324a56e1STejun Heo * kernfs_put - put a reference count on a kernfs_node 504324a56e1STejun Heo * @kn: the target kernfs_node 505fd7b9f7bSTejun Heo * 506324a56e1STejun Heo * Put a reference count of @kn and destroy it if it reached zero. 507fd7b9f7bSTejun Heo */ 508324a56e1STejun Heo void kernfs_put(struct kernfs_node *kn) 509fd7b9f7bSTejun Heo { 510324a56e1STejun Heo struct kernfs_node *parent; 511ba7443bcSTejun Heo struct kernfs_root *root; 512fd7b9f7bSTejun Heo 513adc5e8b5STejun Heo if (!kn || !atomic_dec_and_test(&kn->count)) 514fd7b9f7bSTejun Heo return; 515324a56e1STejun Heo root = kernfs_root(kn); 516fd7b9f7bSTejun Heo repeat: 51781c173cbSTejun Heo /* 51881c173cbSTejun Heo * Moving/renaming is always done while holding reference. 519adc5e8b5STejun Heo * kn->parent won't change beneath us. 520fd7b9f7bSTejun Heo */ 521adc5e8b5STejun Heo parent = kn->parent; 522fd7b9f7bSTejun Heo 52381c173cbSTejun Heo WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS, 52481c173cbSTejun Heo "kernfs_put: %s/%s: released with incorrect active_ref %d\n", 52581c173cbSTejun Heo parent ? parent->name : "", kn->name, atomic_read(&kn->active)); 526fd7b9f7bSTejun Heo 527df23fc39STejun Heo if (kernfs_type(kn) == KERNFS_LINK) 528adc5e8b5STejun Heo kernfs_put(kn->symlink.target_kn); 529dfeb0750STejun Heo 53075287a67SAndrzej Hajda kfree_const(kn->name); 531dfeb0750STejun Heo 532adc5e8b5STejun Heo if (kn->iattr) { 533adc5e8b5STejun Heo simple_xattrs_free(&kn->iattr->xattrs); 53426e28d68SAyush Mittal kmem_cache_free(kernfs_iattrs_cache, kn->iattr); 5352322392bSTejun Heo } 5367d35079fSShaohua Li spin_lock(&kernfs_idr_lock); 53740430452STejun Heo idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); 5387d35079fSShaohua Li spin_unlock(&kernfs_idr_lock); 539a797bfc3STejun Heo kmem_cache_free(kernfs_node_cache, kn); 540fd7b9f7bSTejun Heo 541324a56e1STejun Heo kn = parent; 542324a56e1STejun Heo if (kn) { 543adc5e8b5STejun Heo if (atomic_dec_and_test(&kn->count)) 544fd7b9f7bSTejun Heo goto repeat; 545ba7443bcSTejun Heo } else { 546324a56e1STejun Heo /* just released the root kn, free @root too */ 5477d35079fSShaohua Li idr_destroy(&root->ino_idr); 548ba7443bcSTejun Heo kfree(root); 549ba7443bcSTejun Heo } 550fd7b9f7bSTejun Heo } 551fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_put); 552fd7b9f7bSTejun Heo 5530c23b225STejun Heo /** 5540c23b225STejun Heo * kernfs_node_from_dentry - determine kernfs_node associated with a dentry 5550c23b225STejun Heo * @dentry: the dentry in question 5560c23b225STejun Heo * 5570c23b225STejun Heo * Return the kernfs_node associated with @dentry. If @dentry is not a 5580c23b225STejun Heo * kernfs one, %NULL is returned. 5590c23b225STejun Heo * 5600c23b225STejun Heo * While the returned kernfs_node will stay accessible as long as @dentry 5610c23b225STejun Heo * is accessible, the returned node can be in any state and the caller is 5620c23b225STejun Heo * fully responsible for determining what's accessible. 5630c23b225STejun Heo */ 5640c23b225STejun Heo struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 5650c23b225STejun Heo { 5660288e7faSHui Su if (dentry->d_sb->s_op == &kernfs_sops) 567319ba91dSShaohua Li return kernfs_dentry_node(dentry); 5680c23b225STejun Heo return NULL; 5690c23b225STejun Heo } 5700c23b225STejun Heo 571db4aad20STejun Heo static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root, 572e19dfdc8SOndrej Mosnacek struct kernfs_node *parent, 573db4aad20STejun Heo const char *name, umode_t mode, 574488dee96SDmitry Torokhov kuid_t uid, kgid_t gid, 575db4aad20STejun Heo unsigned flags) 576fd7b9f7bSTejun Heo { 577324a56e1STejun Heo struct kernfs_node *kn; 57840430452STejun Heo u32 id_highbits; 579bc755553STejun Heo int ret; 580fd7b9f7bSTejun Heo 581dfeb0750STejun Heo name = kstrdup_const(name, GFP_KERNEL); 582fd7b9f7bSTejun Heo if (!name) 583fd7b9f7bSTejun Heo return NULL; 584fd7b9f7bSTejun Heo 585a797bfc3STejun Heo kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL); 586324a56e1STejun Heo if (!kn) 587fd7b9f7bSTejun Heo goto err_out1; 588fd7b9f7bSTejun Heo 5897d35079fSShaohua Li idr_preload(GFP_KERNEL); 5907d35079fSShaohua Li spin_lock(&kernfs_idr_lock); 5914a3ef68aSShaohua Li ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC); 59240430452STejun Heo if (ret >= 0 && ret < root->last_id_lowbits) 59340430452STejun Heo root->id_highbits++; 59440430452STejun Heo id_highbits = root->id_highbits; 59540430452STejun Heo root->last_id_lowbits = ret; 5967d35079fSShaohua Li spin_unlock(&kernfs_idr_lock); 5977d35079fSShaohua Li idr_preload_end(); 598bc755553STejun Heo if (ret < 0) 599fd7b9f7bSTejun Heo goto err_out2; 60067c0496eSTejun Heo 60140430452STejun Heo kn->id = (u64)id_highbits << 32 | ret; 602fd7b9f7bSTejun Heo 603b680b081STejun Heo atomic_set(&kn->count, 1); 60481c173cbSTejun Heo atomic_set(&kn->active, KN_DEACTIVATED_BIAS); 60535beab06STejun Heo RB_CLEAR_NODE(&kn->rb); 606fd7b9f7bSTejun Heo 607adc5e8b5STejun Heo kn->name = name; 608adc5e8b5STejun Heo kn->mode = mode; 60981c173cbSTejun Heo kn->flags = flags; 610fd7b9f7bSTejun Heo 611488dee96SDmitry Torokhov if (!uid_eq(uid, GLOBAL_ROOT_UID) || !gid_eq(gid, GLOBAL_ROOT_GID)) { 612488dee96SDmitry Torokhov struct iattr iattr = { 613488dee96SDmitry Torokhov .ia_valid = ATTR_UID | ATTR_GID, 614488dee96SDmitry Torokhov .ia_uid = uid, 615488dee96SDmitry Torokhov .ia_gid = gid, 616488dee96SDmitry Torokhov }; 617488dee96SDmitry Torokhov 618488dee96SDmitry Torokhov ret = __kernfs_setattr(kn, &iattr); 619488dee96SDmitry Torokhov if (ret < 0) 620488dee96SDmitry Torokhov goto err_out3; 621488dee96SDmitry Torokhov } 622488dee96SDmitry Torokhov 623e19dfdc8SOndrej Mosnacek if (parent) { 624e19dfdc8SOndrej Mosnacek ret = security_kernfs_init_security(parent, kn); 625e19dfdc8SOndrej Mosnacek if (ret) 626e19dfdc8SOndrej Mosnacek goto err_out3; 627e19dfdc8SOndrej Mosnacek } 628e19dfdc8SOndrej Mosnacek 629324a56e1STejun Heo return kn; 630fd7b9f7bSTejun Heo 631488dee96SDmitry Torokhov err_out3: 63240430452STejun Heo idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); 633fd7b9f7bSTejun Heo err_out2: 634a797bfc3STejun Heo kmem_cache_free(kernfs_node_cache, kn); 635fd7b9f7bSTejun Heo err_out1: 636dfeb0750STejun Heo kfree_const(name); 637fd7b9f7bSTejun Heo return NULL; 638fd7b9f7bSTejun Heo } 639fd7b9f7bSTejun Heo 640db4aad20STejun Heo struct kernfs_node *kernfs_new_node(struct kernfs_node *parent, 641db4aad20STejun Heo const char *name, umode_t mode, 642488dee96SDmitry Torokhov kuid_t uid, kgid_t gid, 643db4aad20STejun Heo unsigned flags) 644db4aad20STejun Heo { 645db4aad20STejun Heo struct kernfs_node *kn; 646db4aad20STejun Heo 647e19dfdc8SOndrej Mosnacek kn = __kernfs_new_node(kernfs_root(parent), parent, 648488dee96SDmitry Torokhov name, mode, uid, gid, flags); 649db4aad20STejun Heo if (kn) { 650db4aad20STejun Heo kernfs_get(parent); 651db4aad20STejun Heo kn->parent = parent; 652db4aad20STejun Heo } 653db4aad20STejun Heo return kn; 654db4aad20STejun Heo } 655db4aad20STejun Heo 656ba16b284SShaohua Li /* 657fe0f726cSTejun Heo * kernfs_find_and_get_node_by_id - get kernfs_node from node id 658ba16b284SShaohua Li * @root: the kernfs root 659fe0f726cSTejun Heo * @id: the target node id 660fe0f726cSTejun Heo * 661fe0f726cSTejun Heo * @id's lower 32bits encode ino and upper gen. If the gen portion is 662fe0f726cSTejun Heo * zero, all generations are matched. 663ba16b284SShaohua Li * 664ba16b284SShaohua Li * RETURNS: 665ba16b284SShaohua Li * NULL on failure. Return a kernfs node with reference counter incremented 666ba16b284SShaohua Li */ 667fe0f726cSTejun Heo struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root, 668fe0f726cSTejun Heo u64 id) 669ba16b284SShaohua Li { 670ba16b284SShaohua Li struct kernfs_node *kn; 671fe0f726cSTejun Heo ino_t ino = kernfs_id_ino(id); 672fe0f726cSTejun Heo u32 gen = kernfs_id_gen(id); 673ba16b284SShaohua Li 674b680b081STejun Heo spin_lock(&kernfs_idr_lock); 675b680b081STejun Heo 67640430452STejun Heo kn = idr_find(&root->ino_idr, (u32)ino); 677ba16b284SShaohua Li if (!kn) 678b680b081STejun Heo goto err_unlock; 679ba16b284SShaohua Li 68040430452STejun Heo if (sizeof(ino_t) >= sizeof(u64)) { 68140430452STejun Heo /* we looked up with the low 32bits, compare the whole */ 68240430452STejun Heo if (kernfs_ino(kn) != ino) 68340430452STejun Heo goto err_unlock; 68440430452STejun Heo } else { 685fe0f726cSTejun Heo /* 0 matches all generations */ 686fe0f726cSTejun Heo if (unlikely(gen && kernfs_gen(kn) != gen)) 687fe0f726cSTejun Heo goto err_unlock; 68840430452STejun Heo } 689fe0f726cSTejun Heo 690880df131STejun Heo /* 691880df131STejun Heo * ACTIVATED is protected with kernfs_mutex but it was clear when 692880df131STejun Heo * @kn was added to idr and we just wanna see it set. No need to 693880df131STejun Heo * grab kernfs_mutex. 694880df131STejun Heo */ 695880df131STejun Heo if (unlikely(!(kn->flags & KERNFS_ACTIVATED) || 696880df131STejun Heo !atomic_inc_not_zero(&kn->count))) 697b680b081STejun Heo goto err_unlock; 698ba16b284SShaohua Li 699b680b081STejun Heo spin_unlock(&kernfs_idr_lock); 700ba16b284SShaohua Li return kn; 701b680b081STejun Heo err_unlock: 702b680b081STejun Heo spin_unlock(&kernfs_idr_lock); 703ba16b284SShaohua Li return NULL; 704ba16b284SShaohua Li } 705ba16b284SShaohua Li 706fd7b9f7bSTejun Heo /** 707c637b8acSTejun Heo * kernfs_add_one - add kernfs_node to parent without warning 708324a56e1STejun Heo * @kn: kernfs_node to be added 709fd7b9f7bSTejun Heo * 710db4aad20STejun Heo * The caller must already have initialized @kn->parent. This 711db4aad20STejun Heo * function increments nlink of the parent's inode if @kn is a 712db4aad20STejun Heo * directory and link into the children list of the parent. 713fd7b9f7bSTejun Heo * 714fd7b9f7bSTejun Heo * RETURNS: 715fd7b9f7bSTejun Heo * 0 on success, -EEXIST if entry with the given name already 716fd7b9f7bSTejun Heo * exists. 717fd7b9f7bSTejun Heo */ 718988cd7afSTejun Heo int kernfs_add_one(struct kernfs_node *kn) 719fd7b9f7bSTejun Heo { 720db4aad20STejun Heo struct kernfs_node *parent = kn->parent; 721c525aaddSTejun Heo struct kernfs_iattrs *ps_iattr; 722988cd7afSTejun Heo bool has_ns; 723fd7b9f7bSTejun Heo int ret; 724fd7b9f7bSTejun Heo 725988cd7afSTejun Heo mutex_lock(&kernfs_mutex); 726988cd7afSTejun Heo 727988cd7afSTejun Heo ret = -EINVAL; 728988cd7afSTejun Heo has_ns = kernfs_ns_enabled(parent); 729988cd7afSTejun Heo if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 730988cd7afSTejun Heo has_ns ? "required" : "invalid", parent->name, kn->name)) 731988cd7afSTejun Heo goto out_unlock; 732fd7b9f7bSTejun Heo 733df23fc39STejun Heo if (kernfs_type(parent) != KERNFS_DIR) 734988cd7afSTejun Heo goto out_unlock; 735fd7b9f7bSTejun Heo 736988cd7afSTejun Heo ret = -ENOENT; 737ea015218SEric W. Biederman if (parent->flags & KERNFS_EMPTY_DIR) 738ea015218SEric W. Biederman goto out_unlock; 739ea015218SEric W. Biederman 740d35258efSTejun Heo if ((parent->flags & KERNFS_ACTIVATED) && !kernfs_active(parent)) 741988cd7afSTejun Heo goto out_unlock; 742798c75a0SGreg Kroah-Hartman 743c637b8acSTejun Heo kn->hash = kernfs_name_hash(kn->name, kn->ns); 744fd7b9f7bSTejun Heo 745c637b8acSTejun Heo ret = kernfs_link_sibling(kn); 746fd7b9f7bSTejun Heo if (ret) 747988cd7afSTejun Heo goto out_unlock; 748fd7b9f7bSTejun Heo 749fd7b9f7bSTejun Heo /* Update timestamps on the parent */ 750adc5e8b5STejun Heo ps_iattr = parent->iattr; 751fd7b9f7bSTejun Heo if (ps_iattr) { 75205895219SOndrej Mosnacek ktime_get_real_ts64(&ps_iattr->ia_ctime); 75305895219SOndrej Mosnacek ps_iattr->ia_mtime = ps_iattr->ia_ctime; 754fd7b9f7bSTejun Heo } 755fd7b9f7bSTejun Heo 756d35258efSTejun Heo mutex_unlock(&kernfs_mutex); 757d35258efSTejun Heo 758d35258efSTejun Heo /* 759d35258efSTejun Heo * Activate the new node unless CREATE_DEACTIVATED is requested. 760d35258efSTejun Heo * If not activated here, the kernfs user is responsible for 761d35258efSTejun Heo * activating the node with kernfs_activate(). A node which hasn't 762d35258efSTejun Heo * been activated is not visible to userland and its removal won't 763d35258efSTejun Heo * trigger deactivation. 764d35258efSTejun Heo */ 765d35258efSTejun Heo if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 766d35258efSTejun Heo kernfs_activate(kn); 767d35258efSTejun Heo return 0; 768d35258efSTejun Heo 769988cd7afSTejun Heo out_unlock: 770a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 771988cd7afSTejun Heo return ret; 772fd7b9f7bSTejun Heo } 773fd7b9f7bSTejun Heo 774fd7b9f7bSTejun Heo /** 775324a56e1STejun Heo * kernfs_find_ns - find kernfs_node with the given name 776324a56e1STejun Heo * @parent: kernfs_node to search under 777fd7b9f7bSTejun Heo * @name: name to look for 778fd7b9f7bSTejun Heo * @ns: the namespace tag to use 779fd7b9f7bSTejun Heo * 780324a56e1STejun Heo * Look for kernfs_node with name @name under @parent. Returns pointer to 781324a56e1STejun Heo * the found kernfs_node on success, %NULL on failure. 782fd7b9f7bSTejun Heo */ 783324a56e1STejun Heo static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent, 784fd7b9f7bSTejun Heo const unsigned char *name, 785fd7b9f7bSTejun Heo const void *ns) 786fd7b9f7bSTejun Heo { 787adc5e8b5STejun Heo struct rb_node *node = parent->dir.children.rb_node; 788ac9bba03STejun Heo bool has_ns = kernfs_ns_enabled(parent); 789fd7b9f7bSTejun Heo unsigned int hash; 790fd7b9f7bSTejun Heo 791a797bfc3STejun Heo lockdep_assert_held(&kernfs_mutex); 792fd7b9f7bSTejun Heo 793fd7b9f7bSTejun Heo if (has_ns != (bool)ns) { 794c637b8acSTejun Heo WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 795adc5e8b5STejun Heo has_ns ? "required" : "invalid", parent->name, name); 796fd7b9f7bSTejun Heo return NULL; 797fd7b9f7bSTejun Heo } 798fd7b9f7bSTejun Heo 799c637b8acSTejun Heo hash = kernfs_name_hash(name, ns); 800fd7b9f7bSTejun Heo while (node) { 801324a56e1STejun Heo struct kernfs_node *kn; 802fd7b9f7bSTejun Heo int result; 803fd7b9f7bSTejun Heo 804324a56e1STejun Heo kn = rb_to_kn(node); 805c637b8acSTejun Heo result = kernfs_name_compare(hash, name, ns, kn); 806fd7b9f7bSTejun Heo if (result < 0) 807fd7b9f7bSTejun Heo node = node->rb_left; 808fd7b9f7bSTejun Heo else if (result > 0) 809fd7b9f7bSTejun Heo node = node->rb_right; 810fd7b9f7bSTejun Heo else 811324a56e1STejun Heo return kn; 812fd7b9f7bSTejun Heo } 813fd7b9f7bSTejun Heo return NULL; 814fd7b9f7bSTejun Heo } 815fd7b9f7bSTejun Heo 816bd96f76aSTejun Heo static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent, 817bd96f76aSTejun Heo const unsigned char *path, 818bd96f76aSTejun Heo const void *ns) 819bd96f76aSTejun Heo { 820e56ed358STejun Heo size_t len; 821e56ed358STejun Heo char *p, *name; 822bd96f76aSTejun Heo 823bd96f76aSTejun Heo lockdep_assert_held(&kernfs_mutex); 824bd96f76aSTejun Heo 825e56ed358STejun Heo /* grab kernfs_rename_lock to piggy back on kernfs_pr_cont_buf */ 826e56ed358STejun Heo spin_lock_irq(&kernfs_rename_lock); 827e56ed358STejun Heo 828e56ed358STejun Heo len = strlcpy(kernfs_pr_cont_buf, path, sizeof(kernfs_pr_cont_buf)); 829e56ed358STejun Heo 830e56ed358STejun Heo if (len >= sizeof(kernfs_pr_cont_buf)) { 831e56ed358STejun Heo spin_unlock_irq(&kernfs_rename_lock); 832bd96f76aSTejun Heo return NULL; 833e56ed358STejun Heo } 834e56ed358STejun Heo 835e56ed358STejun Heo p = kernfs_pr_cont_buf; 836bd96f76aSTejun Heo 837bd96f76aSTejun Heo while ((name = strsep(&p, "/")) && parent) { 838bd96f76aSTejun Heo if (*name == '\0') 839bd96f76aSTejun Heo continue; 840bd96f76aSTejun Heo parent = kernfs_find_ns(parent, name, ns); 841bd96f76aSTejun Heo } 842bd96f76aSTejun Heo 843e56ed358STejun Heo spin_unlock_irq(&kernfs_rename_lock); 844e56ed358STejun Heo 845bd96f76aSTejun Heo return parent; 846bd96f76aSTejun Heo } 847bd96f76aSTejun Heo 848fd7b9f7bSTejun Heo /** 849324a56e1STejun Heo * kernfs_find_and_get_ns - find and get kernfs_node with the given name 850324a56e1STejun Heo * @parent: kernfs_node to search under 851fd7b9f7bSTejun Heo * @name: name to look for 852fd7b9f7bSTejun Heo * @ns: the namespace tag to use 853fd7b9f7bSTejun Heo * 854324a56e1STejun Heo * Look for kernfs_node with name @name under @parent and get a reference 855fd7b9f7bSTejun Heo * if found. This function may sleep and returns pointer to the found 856324a56e1STejun Heo * kernfs_node on success, %NULL on failure. 857fd7b9f7bSTejun Heo */ 858324a56e1STejun Heo struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 859fd7b9f7bSTejun Heo const char *name, const void *ns) 860fd7b9f7bSTejun Heo { 861324a56e1STejun Heo struct kernfs_node *kn; 862fd7b9f7bSTejun Heo 863a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 864324a56e1STejun Heo kn = kernfs_find_ns(parent, name, ns); 865324a56e1STejun Heo kernfs_get(kn); 866a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 867fd7b9f7bSTejun Heo 868324a56e1STejun Heo return kn; 869fd7b9f7bSTejun Heo } 870fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns); 871fd7b9f7bSTejun Heo 872fd7b9f7bSTejun Heo /** 873bd96f76aSTejun Heo * kernfs_walk_and_get_ns - find and get kernfs_node with the given path 874bd96f76aSTejun Heo * @parent: kernfs_node to search under 875bd96f76aSTejun Heo * @path: path to look for 876bd96f76aSTejun Heo * @ns: the namespace tag to use 877bd96f76aSTejun Heo * 878bd96f76aSTejun Heo * Look for kernfs_node with path @path under @parent and get a reference 879bd96f76aSTejun Heo * if found. This function may sleep and returns pointer to the found 880bd96f76aSTejun Heo * kernfs_node on success, %NULL on failure. 881bd96f76aSTejun Heo */ 882bd96f76aSTejun Heo struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent, 883bd96f76aSTejun Heo const char *path, const void *ns) 884bd96f76aSTejun Heo { 885bd96f76aSTejun Heo struct kernfs_node *kn; 886bd96f76aSTejun Heo 887bd96f76aSTejun Heo mutex_lock(&kernfs_mutex); 888bd96f76aSTejun Heo kn = kernfs_walk_ns(parent, path, ns); 889bd96f76aSTejun Heo kernfs_get(kn); 890bd96f76aSTejun Heo mutex_unlock(&kernfs_mutex); 891bd96f76aSTejun Heo 892bd96f76aSTejun Heo return kn; 893bd96f76aSTejun Heo } 894bd96f76aSTejun Heo 895bd96f76aSTejun Heo /** 896ba7443bcSTejun Heo * kernfs_create_root - create a new kernfs hierarchy 89790c07c89STejun Heo * @scops: optional syscall operations for the hierarchy 898d35258efSTejun Heo * @flags: KERNFS_ROOT_* flags 899ba7443bcSTejun Heo * @priv: opaque data associated with the new directory 900ba7443bcSTejun Heo * 901ba7443bcSTejun Heo * Returns the root of the new hierarchy on success, ERR_PTR() value on 902ba7443bcSTejun Heo * failure. 903ba7443bcSTejun Heo */ 90490c07c89STejun Heo struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 905d35258efSTejun Heo unsigned int flags, void *priv) 906ba7443bcSTejun Heo { 907ba7443bcSTejun Heo struct kernfs_root *root; 908324a56e1STejun Heo struct kernfs_node *kn; 909ba7443bcSTejun Heo 910ba7443bcSTejun Heo root = kzalloc(sizeof(*root), GFP_KERNEL); 911ba7443bcSTejun Heo if (!root) 912ba7443bcSTejun Heo return ERR_PTR(-ENOMEM); 913ba7443bcSTejun Heo 9147d35079fSShaohua Li idr_init(&root->ino_idr); 9157d568a83STejun Heo INIT_LIST_HEAD(&root->supers); 91640430452STejun Heo 91740430452STejun Heo /* 91840430452STejun Heo * On 64bit ino setups, id is ino. On 32bit, low 32bits are ino. 91940430452STejun Heo * High bits generation. The starting value for both ino and 92040430452STejun Heo * genenration is 1. Initialize upper 32bit allocation 92140430452STejun Heo * accordingly. 92240430452STejun Heo */ 92340430452STejun Heo if (sizeof(ino_t) >= sizeof(u64)) 92440430452STejun Heo root->id_highbits = 0; 92540430452STejun Heo else 92640430452STejun Heo root->id_highbits = 1; 927bc755553STejun Heo 928e19dfdc8SOndrej Mosnacek kn = __kernfs_new_node(root, NULL, "", S_IFDIR | S_IRUGO | S_IXUGO, 929488dee96SDmitry Torokhov GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 930db4aad20STejun Heo KERNFS_DIR); 931324a56e1STejun Heo if (!kn) { 9327d35079fSShaohua Li idr_destroy(&root->ino_idr); 933ba7443bcSTejun Heo kfree(root); 934ba7443bcSTejun Heo return ERR_PTR(-ENOMEM); 935ba7443bcSTejun Heo } 936ba7443bcSTejun Heo 937324a56e1STejun Heo kn->priv = priv; 938adc5e8b5STejun Heo kn->dir.root = root; 939ba7443bcSTejun Heo 94090c07c89STejun Heo root->syscall_ops = scops; 941d35258efSTejun Heo root->flags = flags; 942324a56e1STejun Heo root->kn = kn; 943abd54f02STejun Heo init_waitqueue_head(&root->deactivate_waitq); 944ba7443bcSTejun Heo 945d35258efSTejun Heo if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 946d35258efSTejun Heo kernfs_activate(kn); 947d35258efSTejun Heo 948ba7443bcSTejun Heo return root; 949ba7443bcSTejun Heo } 950ba7443bcSTejun Heo 951ba7443bcSTejun Heo /** 952ba7443bcSTejun Heo * kernfs_destroy_root - destroy a kernfs hierarchy 953ba7443bcSTejun Heo * @root: root of the hierarchy to destroy 954ba7443bcSTejun Heo * 955ba7443bcSTejun Heo * Destroy the hierarchy anchored at @root by removing all existing 956ba7443bcSTejun Heo * directories and destroying @root. 957ba7443bcSTejun Heo */ 958ba7443bcSTejun Heo void kernfs_destroy_root(struct kernfs_root *root) 959ba7443bcSTejun Heo { 960324a56e1STejun Heo kernfs_remove(root->kn); /* will also free @root */ 961ba7443bcSTejun Heo } 962ba7443bcSTejun Heo 963ba7443bcSTejun Heo /** 964fd7b9f7bSTejun Heo * kernfs_create_dir_ns - create a directory 965fd7b9f7bSTejun Heo * @parent: parent in which to create a new directory 966fd7b9f7bSTejun Heo * @name: name of the new directory 967bb8b9d09STejun Heo * @mode: mode of the new directory 968488dee96SDmitry Torokhov * @uid: uid of the new directory 969488dee96SDmitry Torokhov * @gid: gid of the new directory 970fd7b9f7bSTejun Heo * @priv: opaque data associated with the new directory 971fd7b9f7bSTejun Heo * @ns: optional namespace tag of the directory 972fd7b9f7bSTejun Heo * 973fd7b9f7bSTejun Heo * Returns the created node on success, ERR_PTR() value on failure. 974fd7b9f7bSTejun Heo */ 975324a56e1STejun Heo struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 976bb8b9d09STejun Heo const char *name, umode_t mode, 977488dee96SDmitry Torokhov kuid_t uid, kgid_t gid, 978bb8b9d09STejun Heo void *priv, const void *ns) 979fd7b9f7bSTejun Heo { 980324a56e1STejun Heo struct kernfs_node *kn; 981fd7b9f7bSTejun Heo int rc; 982fd7b9f7bSTejun Heo 983fd7b9f7bSTejun Heo /* allocate */ 984488dee96SDmitry Torokhov kn = kernfs_new_node(parent, name, mode | S_IFDIR, 985488dee96SDmitry Torokhov uid, gid, KERNFS_DIR); 986324a56e1STejun Heo if (!kn) 987fd7b9f7bSTejun Heo return ERR_PTR(-ENOMEM); 988fd7b9f7bSTejun Heo 989adc5e8b5STejun Heo kn->dir.root = parent->dir.root; 990adc5e8b5STejun Heo kn->ns = ns; 991324a56e1STejun Heo kn->priv = priv; 992fd7b9f7bSTejun Heo 993fd7b9f7bSTejun Heo /* link in */ 994988cd7afSTejun Heo rc = kernfs_add_one(kn); 995fd7b9f7bSTejun Heo if (!rc) 996324a56e1STejun Heo return kn; 997fd7b9f7bSTejun Heo 998324a56e1STejun Heo kernfs_put(kn); 999fd7b9f7bSTejun Heo return ERR_PTR(rc); 1000fd7b9f7bSTejun Heo } 1001fd7b9f7bSTejun Heo 1002ea015218SEric W. Biederman /** 1003ea015218SEric W. Biederman * kernfs_create_empty_dir - create an always empty directory 1004ea015218SEric W. Biederman * @parent: parent in which to create a new directory 1005ea015218SEric W. Biederman * @name: name of the new directory 1006ea015218SEric W. Biederman * 1007ea015218SEric W. Biederman * Returns the created node on success, ERR_PTR() value on failure. 1008ea015218SEric W. Biederman */ 1009ea015218SEric W. Biederman struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent, 1010ea015218SEric W. Biederman const char *name) 1011ea015218SEric W. Biederman { 1012ea015218SEric W. Biederman struct kernfs_node *kn; 1013ea015218SEric W. Biederman int rc; 1014ea015218SEric W. Biederman 1015ea015218SEric W. Biederman /* allocate */ 1016488dee96SDmitry Torokhov kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR, 1017488dee96SDmitry Torokhov GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, KERNFS_DIR); 1018ea015218SEric W. Biederman if (!kn) 1019ea015218SEric W. Biederman return ERR_PTR(-ENOMEM); 1020ea015218SEric W. Biederman 1021ea015218SEric W. Biederman kn->flags |= KERNFS_EMPTY_DIR; 1022ea015218SEric W. Biederman kn->dir.root = parent->dir.root; 1023ea015218SEric W. Biederman kn->ns = NULL; 1024ea015218SEric W. Biederman kn->priv = NULL; 1025ea015218SEric W. Biederman 1026ea015218SEric W. Biederman /* link in */ 1027ea015218SEric W. Biederman rc = kernfs_add_one(kn); 1028ea015218SEric W. Biederman if (!rc) 1029ea015218SEric W. Biederman return kn; 1030ea015218SEric W. Biederman 1031ea015218SEric W. Biederman kernfs_put(kn); 1032ea015218SEric W. Biederman return ERR_PTR(rc); 1033ea015218SEric W. Biederman } 1034ea015218SEric W. Biederman 1035d826e036SIan Kent static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags) 1036d826e036SIan Kent { 1037d826e036SIan Kent struct kernfs_node *kn; 1038d826e036SIan Kent 1039d826e036SIan Kent if (flags & LOOKUP_RCU) 1040d826e036SIan Kent return -ECHILD; 1041d826e036SIan Kent 1042d826e036SIan Kent /* Always perform fresh lookup for negatives */ 1043d826e036SIan Kent if (d_really_is_negative(dentry)) 1044d826e036SIan Kent goto out_bad_unlocked; 1045d826e036SIan Kent 1046d826e036SIan Kent kn = kernfs_dentry_node(dentry); 1047d826e036SIan Kent mutex_lock(&kernfs_mutex); 1048d826e036SIan Kent 1049d826e036SIan Kent /* The kernfs node has been deactivated */ 1050d826e036SIan Kent if (!kernfs_active(kn)) 1051d826e036SIan Kent goto out_bad; 1052d826e036SIan Kent 1053d826e036SIan Kent /* The kernfs node has been moved? */ 1054d826e036SIan Kent if (kernfs_dentry_node(dentry->d_parent) != kn->parent) 1055d826e036SIan Kent goto out_bad; 1056d826e036SIan Kent 1057d826e036SIan Kent /* The kernfs node has been renamed */ 1058d826e036SIan Kent if (strcmp(dentry->d_name.name, kn->name) != 0) 1059d826e036SIan Kent goto out_bad; 1060d826e036SIan Kent 1061d826e036SIan Kent /* The kernfs node has been moved to a different namespace */ 1062d826e036SIan Kent if (kn->parent && kernfs_ns_enabled(kn->parent) && 1063d826e036SIan Kent kernfs_info(dentry->d_sb)->ns != kn->ns) 1064d826e036SIan Kent goto out_bad; 1065d826e036SIan Kent 1066d826e036SIan Kent mutex_unlock(&kernfs_mutex); 1067d826e036SIan Kent return 1; 1068d826e036SIan Kent out_bad: 1069d826e036SIan Kent mutex_unlock(&kernfs_mutex); 1070d826e036SIan Kent out_bad_unlocked: 1071d826e036SIan Kent return 0; 1072d826e036SIan Kent } 1073d826e036SIan Kent 1074d826e036SIan Kent const struct dentry_operations kernfs_dops = { 1075d826e036SIan Kent .d_revalidate = kernfs_dop_revalidate, 1076d826e036SIan Kent }; 1077d826e036SIan Kent 1078c637b8acSTejun Heo static struct dentry *kernfs_iop_lookup(struct inode *dir, 1079c637b8acSTejun Heo struct dentry *dentry, 1080fd7b9f7bSTejun Heo unsigned int flags) 1081fd7b9f7bSTejun Heo { 108219bbb926STejun Heo struct dentry *ret; 1083319ba91dSShaohua Li struct kernfs_node *parent = dir->i_private; 1084324a56e1STejun Heo struct kernfs_node *kn; 1085fd7b9f7bSTejun Heo struct inode *inode; 1086fd7b9f7bSTejun Heo const void *ns = NULL; 1087fd7b9f7bSTejun Heo 1088a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 1089fd7b9f7bSTejun Heo 1090324a56e1STejun Heo if (kernfs_ns_enabled(parent)) 1091c525aaddSTejun Heo ns = kernfs_info(dir->i_sb)->ns; 1092fd7b9f7bSTejun Heo 1093324a56e1STejun Heo kn = kernfs_find_ns(parent, dentry->d_name.name, ns); 1094fd7b9f7bSTejun Heo 1095fd7b9f7bSTejun Heo /* no such entry */ 1096b9c9dad0STejun Heo if (!kn || !kernfs_active(kn)) { 109719bbb926STejun Heo ret = NULL; 1098fd7b9f7bSTejun Heo goto out_unlock; 1099fd7b9f7bSTejun Heo } 1100fd7b9f7bSTejun Heo 1101fd7b9f7bSTejun Heo /* attach dentry and inode */ 1102c637b8acSTejun Heo inode = kernfs_get_inode(dir->i_sb, kn); 1103fd7b9f7bSTejun Heo if (!inode) { 1104fd7b9f7bSTejun Heo ret = ERR_PTR(-ENOMEM); 1105fd7b9f7bSTejun Heo goto out_unlock; 1106fd7b9f7bSTejun Heo } 1107fd7b9f7bSTejun Heo 1108fd7b9f7bSTejun Heo /* instantiate and hash dentry */ 110941d28bcaSAl Viro ret = d_splice_alias(inode, dentry); 1110fd7b9f7bSTejun Heo out_unlock: 1111a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 1112fd7b9f7bSTejun Heo return ret; 1113fd7b9f7bSTejun Heo } 1114fd7b9f7bSTejun Heo 1115549c7297SChristian Brauner static int kernfs_iop_mkdir(struct user_namespace *mnt_userns, 1116549c7297SChristian Brauner struct inode *dir, struct dentry *dentry, 111780b9bbefSTejun Heo umode_t mode) 111880b9bbefSTejun Heo { 111980b9bbefSTejun Heo struct kernfs_node *parent = dir->i_private; 112090c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops; 112107c7530dSTejun Heo int ret; 112280b9bbefSTejun Heo 112390c07c89STejun Heo if (!scops || !scops->mkdir) 112480b9bbefSTejun Heo return -EPERM; 112580b9bbefSTejun Heo 112607c7530dSTejun Heo if (!kernfs_get_active(parent)) 112707c7530dSTejun Heo return -ENODEV; 112807c7530dSTejun Heo 112990c07c89STejun Heo ret = scops->mkdir(parent, dentry->d_name.name, mode); 113007c7530dSTejun Heo 113107c7530dSTejun Heo kernfs_put_active(parent); 113207c7530dSTejun Heo return ret; 113380b9bbefSTejun Heo } 113480b9bbefSTejun Heo 113580b9bbefSTejun Heo static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry) 113680b9bbefSTejun Heo { 1137319ba91dSShaohua Li struct kernfs_node *kn = kernfs_dentry_node(dentry); 113890c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 113907c7530dSTejun Heo int ret; 114080b9bbefSTejun Heo 114190c07c89STejun Heo if (!scops || !scops->rmdir) 114280b9bbefSTejun Heo return -EPERM; 114380b9bbefSTejun Heo 114407c7530dSTejun Heo if (!kernfs_get_active(kn)) 114507c7530dSTejun Heo return -ENODEV; 114607c7530dSTejun Heo 114790c07c89STejun Heo ret = scops->rmdir(kn); 114807c7530dSTejun Heo 114907c7530dSTejun Heo kernfs_put_active(kn); 115007c7530dSTejun Heo return ret; 115180b9bbefSTejun Heo } 115280b9bbefSTejun Heo 1153549c7297SChristian Brauner static int kernfs_iop_rename(struct user_namespace *mnt_userns, 1154549c7297SChristian Brauner struct inode *old_dir, struct dentry *old_dentry, 11551cd66c93SMiklos Szeredi struct inode *new_dir, struct dentry *new_dentry, 11561cd66c93SMiklos Szeredi unsigned int flags) 115780b9bbefSTejun Heo { 1158319ba91dSShaohua Li struct kernfs_node *kn = kernfs_dentry_node(old_dentry); 115980b9bbefSTejun Heo struct kernfs_node *new_parent = new_dir->i_private; 116090c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 116107c7530dSTejun Heo int ret; 116280b9bbefSTejun Heo 11631cd66c93SMiklos Szeredi if (flags) 11641cd66c93SMiklos Szeredi return -EINVAL; 11651cd66c93SMiklos Szeredi 116690c07c89STejun Heo if (!scops || !scops->rename) 116780b9bbefSTejun Heo return -EPERM; 116880b9bbefSTejun Heo 116907c7530dSTejun Heo if (!kernfs_get_active(kn)) 117007c7530dSTejun Heo return -ENODEV; 117107c7530dSTejun Heo 117207c7530dSTejun Heo if (!kernfs_get_active(new_parent)) { 117307c7530dSTejun Heo kernfs_put_active(kn); 117407c7530dSTejun Heo return -ENODEV; 117507c7530dSTejun Heo } 117607c7530dSTejun Heo 117790c07c89STejun Heo ret = scops->rename(kn, new_parent, new_dentry->d_name.name); 117807c7530dSTejun Heo 117907c7530dSTejun Heo kernfs_put_active(new_parent); 118007c7530dSTejun Heo kernfs_put_active(kn); 118107c7530dSTejun Heo return ret; 118280b9bbefSTejun Heo } 118380b9bbefSTejun Heo 1184a797bfc3STejun Heo const struct inode_operations kernfs_dir_iops = { 1185c637b8acSTejun Heo .lookup = kernfs_iop_lookup, 1186c637b8acSTejun Heo .permission = kernfs_iop_permission, 1187c637b8acSTejun Heo .setattr = kernfs_iop_setattr, 1188c637b8acSTejun Heo .getattr = kernfs_iop_getattr, 1189c637b8acSTejun Heo .listxattr = kernfs_iop_listxattr, 119080b9bbefSTejun Heo 119180b9bbefSTejun Heo .mkdir = kernfs_iop_mkdir, 119280b9bbefSTejun Heo .rmdir = kernfs_iop_rmdir, 119380b9bbefSTejun Heo .rename = kernfs_iop_rename, 1194fd7b9f7bSTejun Heo }; 1195fd7b9f7bSTejun Heo 1196c637b8acSTejun Heo static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos) 1197fd7b9f7bSTejun Heo { 1198324a56e1STejun Heo struct kernfs_node *last; 1199fd7b9f7bSTejun Heo 1200fd7b9f7bSTejun Heo while (true) { 1201fd7b9f7bSTejun Heo struct rb_node *rbn; 1202fd7b9f7bSTejun Heo 1203fd7b9f7bSTejun Heo last = pos; 1204fd7b9f7bSTejun Heo 1205df23fc39STejun Heo if (kernfs_type(pos) != KERNFS_DIR) 1206fd7b9f7bSTejun Heo break; 1207fd7b9f7bSTejun Heo 1208adc5e8b5STejun Heo rbn = rb_first(&pos->dir.children); 1209fd7b9f7bSTejun Heo if (!rbn) 1210fd7b9f7bSTejun Heo break; 1211fd7b9f7bSTejun Heo 1212324a56e1STejun Heo pos = rb_to_kn(rbn); 1213fd7b9f7bSTejun Heo } 1214fd7b9f7bSTejun Heo 1215fd7b9f7bSTejun Heo return last; 1216fd7b9f7bSTejun Heo } 1217fd7b9f7bSTejun Heo 1218fd7b9f7bSTejun Heo /** 1219c637b8acSTejun Heo * kernfs_next_descendant_post - find the next descendant for post-order walk 1220fd7b9f7bSTejun Heo * @pos: the current position (%NULL to initiate traversal) 1221324a56e1STejun Heo * @root: kernfs_node whose descendants to walk 1222fd7b9f7bSTejun Heo * 1223fd7b9f7bSTejun Heo * Find the next descendant to visit for post-order traversal of @root's 1224fd7b9f7bSTejun Heo * descendants. @root is included in the iteration and the last node to be 1225fd7b9f7bSTejun Heo * visited. 1226fd7b9f7bSTejun Heo */ 1227c637b8acSTejun Heo static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos, 1228324a56e1STejun Heo struct kernfs_node *root) 1229fd7b9f7bSTejun Heo { 1230fd7b9f7bSTejun Heo struct rb_node *rbn; 1231fd7b9f7bSTejun Heo 1232a797bfc3STejun Heo lockdep_assert_held(&kernfs_mutex); 1233fd7b9f7bSTejun Heo 1234fd7b9f7bSTejun Heo /* if first iteration, visit leftmost descendant which may be root */ 1235fd7b9f7bSTejun Heo if (!pos) 1236c637b8acSTejun Heo return kernfs_leftmost_descendant(root); 1237fd7b9f7bSTejun Heo 1238fd7b9f7bSTejun Heo /* if we visited @root, we're done */ 1239fd7b9f7bSTejun Heo if (pos == root) 1240fd7b9f7bSTejun Heo return NULL; 1241fd7b9f7bSTejun Heo 1242fd7b9f7bSTejun Heo /* if there's an unvisited sibling, visit its leftmost descendant */ 1243adc5e8b5STejun Heo rbn = rb_next(&pos->rb); 1244fd7b9f7bSTejun Heo if (rbn) 1245c637b8acSTejun Heo return kernfs_leftmost_descendant(rb_to_kn(rbn)); 1246fd7b9f7bSTejun Heo 1247fd7b9f7bSTejun Heo /* no sibling left, visit parent */ 1248adc5e8b5STejun Heo return pos->parent; 1249fd7b9f7bSTejun Heo } 1250fd7b9f7bSTejun Heo 1251d35258efSTejun Heo /** 1252d35258efSTejun Heo * kernfs_activate - activate a node which started deactivated 1253d35258efSTejun Heo * @kn: kernfs_node whose subtree is to be activated 1254d35258efSTejun Heo * 1255d35258efSTejun Heo * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node 1256d35258efSTejun Heo * needs to be explicitly activated. A node which hasn't been activated 1257d35258efSTejun Heo * isn't visible to userland and deactivation is skipped during its 1258d35258efSTejun Heo * removal. This is useful to construct atomic init sequences where 1259d35258efSTejun Heo * creation of multiple nodes should either succeed or fail atomically. 1260d35258efSTejun Heo * 1261d35258efSTejun Heo * The caller is responsible for ensuring that this function is not called 1262d35258efSTejun Heo * after kernfs_remove*() is invoked on @kn. 1263d35258efSTejun Heo */ 1264d35258efSTejun Heo void kernfs_activate(struct kernfs_node *kn) 1265d35258efSTejun Heo { 1266d35258efSTejun Heo struct kernfs_node *pos; 1267d35258efSTejun Heo 1268d35258efSTejun Heo mutex_lock(&kernfs_mutex); 1269d35258efSTejun Heo 1270d35258efSTejun Heo pos = NULL; 1271d35258efSTejun Heo while ((pos = kernfs_next_descendant_post(pos, kn))) { 12725bf33f04SMateusz Nosek if (pos->flags & KERNFS_ACTIVATED) 1273d35258efSTejun Heo continue; 1274d35258efSTejun Heo 1275d35258efSTejun Heo WARN_ON_ONCE(pos->parent && RB_EMPTY_NODE(&pos->rb)); 1276d35258efSTejun Heo WARN_ON_ONCE(atomic_read(&pos->active) != KN_DEACTIVATED_BIAS); 1277d35258efSTejun Heo 1278d35258efSTejun Heo atomic_sub(KN_DEACTIVATED_BIAS, &pos->active); 1279d35258efSTejun Heo pos->flags |= KERNFS_ACTIVATED; 1280d35258efSTejun Heo } 1281d35258efSTejun Heo 1282d35258efSTejun Heo mutex_unlock(&kernfs_mutex); 1283d35258efSTejun Heo } 1284d35258efSTejun Heo 1285988cd7afSTejun Heo static void __kernfs_remove(struct kernfs_node *kn) 1286fd7b9f7bSTejun Heo { 128735beab06STejun Heo struct kernfs_node *pos; 128835beab06STejun Heo 128935beab06STejun Heo lockdep_assert_held(&kernfs_mutex); 1290fd7b9f7bSTejun Heo 12916b0afc2aSTejun Heo /* 12926b0afc2aSTejun Heo * Short-circuit if non-root @kn has already finished removal. 12936b0afc2aSTejun Heo * This is for kernfs_remove_self() which plays with active ref 12946b0afc2aSTejun Heo * after removal. 12956b0afc2aSTejun Heo */ 12966b0afc2aSTejun Heo if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb))) 1297ce9b499cSGreg Kroah-Hartman return; 1298ce9b499cSGreg Kroah-Hartman 1299c637b8acSTejun Heo pr_debug("kernfs %s: removing\n", kn->name); 1300fd7b9f7bSTejun Heo 130181c173cbSTejun Heo /* prevent any new usage under @kn by deactivating all nodes */ 130235beab06STejun Heo pos = NULL; 130335beab06STejun Heo while ((pos = kernfs_next_descendant_post(pos, kn))) 130481c173cbSTejun Heo if (kernfs_active(pos)) 130581c173cbSTejun Heo atomic_add(KN_DEACTIVATED_BIAS, &pos->active); 130635beab06STejun Heo 130735beab06STejun Heo /* deactivate and unlink the subtree node-by-node */ 1308fd7b9f7bSTejun Heo do { 130935beab06STejun Heo pos = kernfs_leftmost_descendant(kn); 131035beab06STejun Heo 131135beab06STejun Heo /* 131281c173cbSTejun Heo * kernfs_drain() drops kernfs_mutex temporarily and @pos's 131381c173cbSTejun Heo * base ref could have been put by someone else by the time 131481c173cbSTejun Heo * the function returns. Make sure it doesn't go away 131581c173cbSTejun Heo * underneath us. 131635beab06STejun Heo */ 131735beab06STejun Heo kernfs_get(pos); 131835beab06STejun Heo 1319d35258efSTejun Heo /* 1320d35258efSTejun Heo * Drain iff @kn was activated. This avoids draining and 1321d35258efSTejun Heo * its lockdep annotations for nodes which have never been 1322d35258efSTejun Heo * activated and allows embedding kernfs_remove() in create 1323d35258efSTejun Heo * error paths without worrying about draining. 1324d35258efSTejun Heo */ 1325d35258efSTejun Heo if (kn->flags & KERNFS_ACTIVATED) 132681c173cbSTejun Heo kernfs_drain(pos); 1327d35258efSTejun Heo else 1328d35258efSTejun Heo WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS); 132935beab06STejun Heo 133035beab06STejun Heo /* 133135beab06STejun Heo * kernfs_unlink_sibling() succeeds once per node. Use it 133235beab06STejun Heo * to decide who's responsible for cleanups. 133335beab06STejun Heo */ 133435beab06STejun Heo if (!pos->parent || kernfs_unlink_sibling(pos)) { 133535beab06STejun Heo struct kernfs_iattrs *ps_iattr = 133635beab06STejun Heo pos->parent ? pos->parent->iattr : NULL; 133735beab06STejun Heo 133835beab06STejun Heo /* update timestamps on the parent */ 133935beab06STejun Heo if (ps_iattr) { 134005895219SOndrej Mosnacek ktime_get_real_ts64(&ps_iattr->ia_ctime); 134105895219SOndrej Mosnacek ps_iattr->ia_mtime = ps_iattr->ia_ctime; 134235beab06STejun Heo } 134335beab06STejun Heo 1344988cd7afSTejun Heo kernfs_put(pos); 134535beab06STejun Heo } 134635beab06STejun Heo 134735beab06STejun Heo kernfs_put(pos); 134835beab06STejun Heo } while (pos != kn); 1349fd7b9f7bSTejun Heo } 1350fd7b9f7bSTejun Heo 1351fd7b9f7bSTejun Heo /** 1352324a56e1STejun Heo * kernfs_remove - remove a kernfs_node recursively 1353324a56e1STejun Heo * @kn: the kernfs_node to remove 1354fd7b9f7bSTejun Heo * 1355324a56e1STejun Heo * Remove @kn along with all its subdirectories and files. 1356fd7b9f7bSTejun Heo */ 1357324a56e1STejun Heo void kernfs_remove(struct kernfs_node *kn) 1358fd7b9f7bSTejun Heo { 1359988cd7afSTejun Heo mutex_lock(&kernfs_mutex); 1360988cd7afSTejun Heo __kernfs_remove(kn); 1361988cd7afSTejun Heo mutex_unlock(&kernfs_mutex); 1362fd7b9f7bSTejun Heo } 1363fd7b9f7bSTejun Heo 1364fd7b9f7bSTejun Heo /** 13656b0afc2aSTejun Heo * kernfs_break_active_protection - break out of active protection 13666b0afc2aSTejun Heo * @kn: the self kernfs_node 13676b0afc2aSTejun Heo * 13686b0afc2aSTejun Heo * The caller must be running off of a kernfs operation which is invoked 13696b0afc2aSTejun Heo * with an active reference - e.g. one of kernfs_ops. Each invocation of 13706b0afc2aSTejun Heo * this function must also be matched with an invocation of 13716b0afc2aSTejun Heo * kernfs_unbreak_active_protection(). 13726b0afc2aSTejun Heo * 13736b0afc2aSTejun Heo * This function releases the active reference of @kn the caller is 13746b0afc2aSTejun Heo * holding. Once this function is called, @kn may be removed at any point 13756b0afc2aSTejun Heo * and the caller is solely responsible for ensuring that the objects it 13766b0afc2aSTejun Heo * dereferences are accessible. 13776b0afc2aSTejun Heo */ 13786b0afc2aSTejun Heo void kernfs_break_active_protection(struct kernfs_node *kn) 13796b0afc2aSTejun Heo { 13806b0afc2aSTejun Heo /* 13816b0afc2aSTejun Heo * Take out ourself out of the active ref dependency chain. If 13826b0afc2aSTejun Heo * we're called without an active ref, lockdep will complain. 13836b0afc2aSTejun Heo */ 13846b0afc2aSTejun Heo kernfs_put_active(kn); 13856b0afc2aSTejun Heo } 13866b0afc2aSTejun Heo 13876b0afc2aSTejun Heo /** 13886b0afc2aSTejun Heo * kernfs_unbreak_active_protection - undo kernfs_break_active_protection() 13896b0afc2aSTejun Heo * @kn: the self kernfs_node 13906b0afc2aSTejun Heo * 13916b0afc2aSTejun Heo * If kernfs_break_active_protection() was called, this function must be 13926b0afc2aSTejun Heo * invoked before finishing the kernfs operation. Note that while this 13936b0afc2aSTejun Heo * function restores the active reference, it doesn't and can't actually 13946b0afc2aSTejun Heo * restore the active protection - @kn may already or be in the process of 13956b0afc2aSTejun Heo * being removed. Once kernfs_break_active_protection() is invoked, that 13966b0afc2aSTejun Heo * protection is irreversibly gone for the kernfs operation instance. 13976b0afc2aSTejun Heo * 13986b0afc2aSTejun Heo * While this function may be called at any point after 13996b0afc2aSTejun Heo * kernfs_break_active_protection() is invoked, its most useful location 14006b0afc2aSTejun Heo * would be right before the enclosing kernfs operation returns. 14016b0afc2aSTejun Heo */ 14026b0afc2aSTejun Heo void kernfs_unbreak_active_protection(struct kernfs_node *kn) 14036b0afc2aSTejun Heo { 14046b0afc2aSTejun Heo /* 14056b0afc2aSTejun Heo * @kn->active could be in any state; however, the increment we do 14066b0afc2aSTejun Heo * here will be undone as soon as the enclosing kernfs operation 14076b0afc2aSTejun Heo * finishes and this temporary bump can't break anything. If @kn 14086b0afc2aSTejun Heo * is alive, nothing changes. If @kn is being deactivated, the 14096b0afc2aSTejun Heo * soon-to-follow put will either finish deactivation or restore 14106b0afc2aSTejun Heo * deactivated state. If @kn is already removed, the temporary 14116b0afc2aSTejun Heo * bump is guaranteed to be gone before @kn is released. 14126b0afc2aSTejun Heo */ 14136b0afc2aSTejun Heo atomic_inc(&kn->active); 14146b0afc2aSTejun Heo if (kernfs_lockdep(kn)) 14156b0afc2aSTejun Heo rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_); 14166b0afc2aSTejun Heo } 14176b0afc2aSTejun Heo 14186b0afc2aSTejun Heo /** 14196b0afc2aSTejun Heo * kernfs_remove_self - remove a kernfs_node from its own method 14206b0afc2aSTejun Heo * @kn: the self kernfs_node to remove 14216b0afc2aSTejun Heo * 14226b0afc2aSTejun Heo * The caller must be running off of a kernfs operation which is invoked 14236b0afc2aSTejun Heo * with an active reference - e.g. one of kernfs_ops. This can be used to 14246b0afc2aSTejun Heo * implement a file operation which deletes itself. 14256b0afc2aSTejun Heo * 14266b0afc2aSTejun Heo * For example, the "delete" file for a sysfs device directory can be 14276b0afc2aSTejun Heo * implemented by invoking kernfs_remove_self() on the "delete" file 14286b0afc2aSTejun Heo * itself. This function breaks the circular dependency of trying to 14296b0afc2aSTejun Heo * deactivate self while holding an active ref itself. It isn't necessary 14306b0afc2aSTejun Heo * to modify the usual removal path to use kernfs_remove_self(). The 14316b0afc2aSTejun Heo * "delete" implementation can simply invoke kernfs_remove_self() on self 14326b0afc2aSTejun Heo * before proceeding with the usual removal path. kernfs will ignore later 14336b0afc2aSTejun Heo * kernfs_remove() on self. 14346b0afc2aSTejun Heo * 14356b0afc2aSTejun Heo * kernfs_remove_self() can be called multiple times concurrently on the 14366b0afc2aSTejun Heo * same kernfs_node. Only the first one actually performs removal and 14376b0afc2aSTejun Heo * returns %true. All others will wait until the kernfs operation which 14386b0afc2aSTejun Heo * won self-removal finishes and return %false. Note that the losers wait 14396b0afc2aSTejun Heo * for the completion of not only the winning kernfs_remove_self() but also 14406b0afc2aSTejun Heo * the whole kernfs_ops which won the arbitration. This can be used to 14416b0afc2aSTejun Heo * guarantee, for example, all concurrent writes to a "delete" file to 14426b0afc2aSTejun Heo * finish only after the whole operation is complete. 14436b0afc2aSTejun Heo */ 14446b0afc2aSTejun Heo bool kernfs_remove_self(struct kernfs_node *kn) 14456b0afc2aSTejun Heo { 14466b0afc2aSTejun Heo bool ret; 14476b0afc2aSTejun Heo 14486b0afc2aSTejun Heo mutex_lock(&kernfs_mutex); 14496b0afc2aSTejun Heo kernfs_break_active_protection(kn); 14506b0afc2aSTejun Heo 14516b0afc2aSTejun Heo /* 14526b0afc2aSTejun Heo * SUICIDAL is used to arbitrate among competing invocations. Only 14536b0afc2aSTejun Heo * the first one will actually perform removal. When the removal 14546b0afc2aSTejun Heo * is complete, SUICIDED is set and the active ref is restored 14556b0afc2aSTejun Heo * while holding kernfs_mutex. The ones which lost arbitration 14566b0afc2aSTejun Heo * waits for SUICDED && drained which can happen only after the 14576b0afc2aSTejun Heo * enclosing kernfs operation which executed the winning instance 14586b0afc2aSTejun Heo * of kernfs_remove_self() finished. 14596b0afc2aSTejun Heo */ 14606b0afc2aSTejun Heo if (!(kn->flags & KERNFS_SUICIDAL)) { 14616b0afc2aSTejun Heo kn->flags |= KERNFS_SUICIDAL; 14626b0afc2aSTejun Heo __kernfs_remove(kn); 14636b0afc2aSTejun Heo kn->flags |= KERNFS_SUICIDED; 14646b0afc2aSTejun Heo ret = true; 14656b0afc2aSTejun Heo } else { 14666b0afc2aSTejun Heo wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq; 14676b0afc2aSTejun Heo DEFINE_WAIT(wait); 14686b0afc2aSTejun Heo 14696b0afc2aSTejun Heo while (true) { 14706b0afc2aSTejun Heo prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE); 14716b0afc2aSTejun Heo 14726b0afc2aSTejun Heo if ((kn->flags & KERNFS_SUICIDED) && 14736b0afc2aSTejun Heo atomic_read(&kn->active) == KN_DEACTIVATED_BIAS) 14746b0afc2aSTejun Heo break; 14756b0afc2aSTejun Heo 14766b0afc2aSTejun Heo mutex_unlock(&kernfs_mutex); 14776b0afc2aSTejun Heo schedule(); 14786b0afc2aSTejun Heo mutex_lock(&kernfs_mutex); 14796b0afc2aSTejun Heo } 14806b0afc2aSTejun Heo finish_wait(waitq, &wait); 14816b0afc2aSTejun Heo WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb)); 14826b0afc2aSTejun Heo ret = false; 14836b0afc2aSTejun Heo } 14846b0afc2aSTejun Heo 14856b0afc2aSTejun Heo /* 14866b0afc2aSTejun Heo * This must be done while holding kernfs_mutex; otherwise, waiting 14876b0afc2aSTejun Heo * for SUICIDED && deactivated could finish prematurely. 14886b0afc2aSTejun Heo */ 14896b0afc2aSTejun Heo kernfs_unbreak_active_protection(kn); 14906b0afc2aSTejun Heo 14916b0afc2aSTejun Heo mutex_unlock(&kernfs_mutex); 14926b0afc2aSTejun Heo return ret; 14936b0afc2aSTejun Heo } 14946b0afc2aSTejun Heo 14956b0afc2aSTejun Heo /** 1496324a56e1STejun Heo * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it 1497324a56e1STejun Heo * @parent: parent of the target 1498324a56e1STejun Heo * @name: name of the kernfs_node to remove 1499324a56e1STejun Heo * @ns: namespace tag of the kernfs_node to remove 1500fd7b9f7bSTejun Heo * 1501324a56e1STejun Heo * Look for the kernfs_node with @name and @ns under @parent and remove it. 1502324a56e1STejun Heo * Returns 0 on success, -ENOENT if such entry doesn't exist. 1503fd7b9f7bSTejun Heo */ 1504324a56e1STejun Heo int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 1505fd7b9f7bSTejun Heo const void *ns) 1506fd7b9f7bSTejun Heo { 1507324a56e1STejun Heo struct kernfs_node *kn; 1508fd7b9f7bSTejun Heo 1509324a56e1STejun Heo if (!parent) { 1510c637b8acSTejun Heo WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n", 1511fd7b9f7bSTejun Heo name); 1512fd7b9f7bSTejun Heo return -ENOENT; 1513fd7b9f7bSTejun Heo } 1514fd7b9f7bSTejun Heo 1515988cd7afSTejun Heo mutex_lock(&kernfs_mutex); 1516fd7b9f7bSTejun Heo 1517324a56e1STejun Heo kn = kernfs_find_ns(parent, name, ns); 1518324a56e1STejun Heo if (kn) 1519988cd7afSTejun Heo __kernfs_remove(kn); 1520fd7b9f7bSTejun Heo 1521988cd7afSTejun Heo mutex_unlock(&kernfs_mutex); 1522fd7b9f7bSTejun Heo 1523324a56e1STejun Heo if (kn) 1524fd7b9f7bSTejun Heo return 0; 1525fd7b9f7bSTejun Heo else 1526fd7b9f7bSTejun Heo return -ENOENT; 1527fd7b9f7bSTejun Heo } 1528fd7b9f7bSTejun Heo 1529fd7b9f7bSTejun Heo /** 1530fd7b9f7bSTejun Heo * kernfs_rename_ns - move and rename a kernfs_node 1531324a56e1STejun Heo * @kn: target node 1532fd7b9f7bSTejun Heo * @new_parent: new parent to put @sd under 1533fd7b9f7bSTejun Heo * @new_name: new name 1534fd7b9f7bSTejun Heo * @new_ns: new namespace tag 1535fd7b9f7bSTejun Heo */ 1536324a56e1STejun Heo int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 1537fd7b9f7bSTejun Heo const char *new_name, const void *new_ns) 1538fd7b9f7bSTejun Heo { 15393eef34adSTejun Heo struct kernfs_node *old_parent; 15403eef34adSTejun Heo const char *old_name = NULL; 1541fd7b9f7bSTejun Heo int error; 1542fd7b9f7bSTejun Heo 15433eef34adSTejun Heo /* can't move or rename root */ 15443eef34adSTejun Heo if (!kn->parent) 15453eef34adSTejun Heo return -EINVAL; 15463eef34adSTejun Heo 1547ae34372eSTejun Heo mutex_lock(&kernfs_mutex); 1548d0ae3d43STejun Heo 1549798c75a0SGreg Kroah-Hartman error = -ENOENT; 1550ea015218SEric W. Biederman if (!kernfs_active(kn) || !kernfs_active(new_parent) || 1551ea015218SEric W. Biederman (new_parent->flags & KERNFS_EMPTY_DIR)) 1552798c75a0SGreg Kroah-Hartman goto out; 1553798c75a0SGreg Kroah-Hartman 1554fd7b9f7bSTejun Heo error = 0; 1555adc5e8b5STejun Heo if ((kn->parent == new_parent) && (kn->ns == new_ns) && 1556adc5e8b5STejun Heo (strcmp(kn->name, new_name) == 0)) 1557798c75a0SGreg Kroah-Hartman goto out; /* nothing to rename */ 1558fd7b9f7bSTejun Heo 1559fd7b9f7bSTejun Heo error = -EEXIST; 1560fd7b9f7bSTejun Heo if (kernfs_find_ns(new_parent, new_name, new_ns)) 1561798c75a0SGreg Kroah-Hartman goto out; 1562fd7b9f7bSTejun Heo 1563324a56e1STejun Heo /* rename kernfs_node */ 1564adc5e8b5STejun Heo if (strcmp(kn->name, new_name) != 0) { 1565fd7b9f7bSTejun Heo error = -ENOMEM; 156675287a67SAndrzej Hajda new_name = kstrdup_const(new_name, GFP_KERNEL); 1567fd7b9f7bSTejun Heo if (!new_name) 1568798c75a0SGreg Kroah-Hartman goto out; 15693eef34adSTejun Heo } else { 15703eef34adSTejun Heo new_name = NULL; 1571fd7b9f7bSTejun Heo } 1572fd7b9f7bSTejun Heo 1573fd7b9f7bSTejun Heo /* 1574fd7b9f7bSTejun Heo * Move to the appropriate place in the appropriate directories rbtree. 1575fd7b9f7bSTejun Heo */ 1576c637b8acSTejun Heo kernfs_unlink_sibling(kn); 1577fd7b9f7bSTejun Heo kernfs_get(new_parent); 15783eef34adSTejun Heo 15793eef34adSTejun Heo /* rename_lock protects ->parent and ->name accessors */ 15803eef34adSTejun Heo spin_lock_irq(&kernfs_rename_lock); 15813eef34adSTejun Heo 15823eef34adSTejun Heo old_parent = kn->parent; 1583adc5e8b5STejun Heo kn->parent = new_parent; 15843eef34adSTejun Heo 15853eef34adSTejun Heo kn->ns = new_ns; 15863eef34adSTejun Heo if (new_name) { 15873eef34adSTejun Heo old_name = kn->name; 15883eef34adSTejun Heo kn->name = new_name; 15893eef34adSTejun Heo } 15903eef34adSTejun Heo 15913eef34adSTejun Heo spin_unlock_irq(&kernfs_rename_lock); 15923eef34adSTejun Heo 15939561a896STejun Heo kn->hash = kernfs_name_hash(kn->name, kn->ns); 1594c637b8acSTejun Heo kernfs_link_sibling(kn); 1595fd7b9f7bSTejun Heo 15963eef34adSTejun Heo kernfs_put(old_parent); 159775287a67SAndrzej Hajda kfree_const(old_name); 15983eef34adSTejun Heo 1599fd7b9f7bSTejun Heo error = 0; 1600ae34372eSTejun Heo out: 1601798c75a0SGreg Kroah-Hartman mutex_unlock(&kernfs_mutex); 1602fd7b9f7bSTejun Heo return error; 1603fd7b9f7bSTejun Heo } 1604fd7b9f7bSTejun Heo 160521774fd8SWillem de Bruijn /* Relationship between mode and the DT_xxx types */ 1606324a56e1STejun Heo static inline unsigned char dt_type(struct kernfs_node *kn) 1607fd7b9f7bSTejun Heo { 1608adc5e8b5STejun Heo return (kn->mode >> 12) & 15; 1609fd7b9f7bSTejun Heo } 1610fd7b9f7bSTejun Heo 1611c637b8acSTejun Heo static int kernfs_dir_fop_release(struct inode *inode, struct file *filp) 1612fd7b9f7bSTejun Heo { 1613fd7b9f7bSTejun Heo kernfs_put(filp->private_data); 1614fd7b9f7bSTejun Heo return 0; 1615fd7b9f7bSTejun Heo } 1616fd7b9f7bSTejun Heo 1617c637b8acSTejun Heo static struct kernfs_node *kernfs_dir_pos(const void *ns, 1618324a56e1STejun Heo struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos) 1619fd7b9f7bSTejun Heo { 1620fd7b9f7bSTejun Heo if (pos) { 162181c173cbSTejun Heo int valid = kernfs_active(pos) && 1622798c75a0SGreg Kroah-Hartman pos->parent == parent && hash == pos->hash; 1623fd7b9f7bSTejun Heo kernfs_put(pos); 1624fd7b9f7bSTejun Heo if (!valid) 1625fd7b9f7bSTejun Heo pos = NULL; 1626fd7b9f7bSTejun Heo } 1627fd7b9f7bSTejun Heo if (!pos && (hash > 1) && (hash < INT_MAX)) { 1628adc5e8b5STejun Heo struct rb_node *node = parent->dir.children.rb_node; 1629fd7b9f7bSTejun Heo while (node) { 1630324a56e1STejun Heo pos = rb_to_kn(node); 1631fd7b9f7bSTejun Heo 1632adc5e8b5STejun Heo if (hash < pos->hash) 1633fd7b9f7bSTejun Heo node = node->rb_left; 1634adc5e8b5STejun Heo else if (hash > pos->hash) 1635fd7b9f7bSTejun Heo node = node->rb_right; 1636fd7b9f7bSTejun Heo else 1637fd7b9f7bSTejun Heo break; 1638fd7b9f7bSTejun Heo } 1639fd7b9f7bSTejun Heo } 1640b9c9dad0STejun Heo /* Skip over entries which are dying/dead or in the wrong namespace */ 1641b9c9dad0STejun Heo while (pos && (!kernfs_active(pos) || pos->ns != ns)) { 1642adc5e8b5STejun Heo struct rb_node *node = rb_next(&pos->rb); 1643fd7b9f7bSTejun Heo if (!node) 1644fd7b9f7bSTejun Heo pos = NULL; 1645fd7b9f7bSTejun Heo else 1646324a56e1STejun Heo pos = rb_to_kn(node); 1647fd7b9f7bSTejun Heo } 1648fd7b9f7bSTejun Heo return pos; 1649fd7b9f7bSTejun Heo } 1650fd7b9f7bSTejun Heo 1651c637b8acSTejun Heo static struct kernfs_node *kernfs_dir_next_pos(const void *ns, 1652324a56e1STejun Heo struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos) 1653fd7b9f7bSTejun Heo { 1654c637b8acSTejun Heo pos = kernfs_dir_pos(ns, parent, ino, pos); 1655b9c9dad0STejun Heo if (pos) { 1656fd7b9f7bSTejun Heo do { 1657adc5e8b5STejun Heo struct rb_node *node = rb_next(&pos->rb); 1658fd7b9f7bSTejun Heo if (!node) 1659fd7b9f7bSTejun Heo pos = NULL; 1660fd7b9f7bSTejun Heo else 1661324a56e1STejun Heo pos = rb_to_kn(node); 1662b9c9dad0STejun Heo } while (pos && (!kernfs_active(pos) || pos->ns != ns)); 1663b9c9dad0STejun Heo } 1664fd7b9f7bSTejun Heo return pos; 1665fd7b9f7bSTejun Heo } 1666fd7b9f7bSTejun Heo 1667c637b8acSTejun Heo static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx) 1668fd7b9f7bSTejun Heo { 1669fd7b9f7bSTejun Heo struct dentry *dentry = file->f_path.dentry; 1670319ba91dSShaohua Li struct kernfs_node *parent = kernfs_dentry_node(dentry); 1671324a56e1STejun Heo struct kernfs_node *pos = file->private_data; 1672fd7b9f7bSTejun Heo const void *ns = NULL; 1673fd7b9f7bSTejun Heo 1674fd7b9f7bSTejun Heo if (!dir_emit_dots(file, ctx)) 1675fd7b9f7bSTejun Heo return 0; 1676a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 1677fd7b9f7bSTejun Heo 1678324a56e1STejun Heo if (kernfs_ns_enabled(parent)) 1679c525aaddSTejun Heo ns = kernfs_info(dentry->d_sb)->ns; 1680fd7b9f7bSTejun Heo 1681c637b8acSTejun Heo for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos); 1682fd7b9f7bSTejun Heo pos; 1683c637b8acSTejun Heo pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) { 1684adc5e8b5STejun Heo const char *name = pos->name; 1685fd7b9f7bSTejun Heo unsigned int type = dt_type(pos); 1686fd7b9f7bSTejun Heo int len = strlen(name); 168767c0496eSTejun Heo ino_t ino = kernfs_ino(pos); 1688fd7b9f7bSTejun Heo 1689adc5e8b5STejun Heo ctx->pos = pos->hash; 1690fd7b9f7bSTejun Heo file->private_data = pos; 1691fd7b9f7bSTejun Heo kernfs_get(pos); 1692fd7b9f7bSTejun Heo 1693a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 1694fd7b9f7bSTejun Heo if (!dir_emit(ctx, name, len, ino, type)) 1695fd7b9f7bSTejun Heo return 0; 1696a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 1697fd7b9f7bSTejun Heo } 1698a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 1699fd7b9f7bSTejun Heo file->private_data = NULL; 1700fd7b9f7bSTejun Heo ctx->pos = INT_MAX; 1701fd7b9f7bSTejun Heo return 0; 1702fd7b9f7bSTejun Heo } 1703fd7b9f7bSTejun Heo 1704a797bfc3STejun Heo const struct file_operations kernfs_dir_fops = { 1705fd7b9f7bSTejun Heo .read = generic_read_dir, 17068cb0d2c1SAl Viro .iterate_shared = kernfs_fop_readdir, 1707c637b8acSTejun Heo .release = kernfs_dir_fop_release, 17088cb0d2c1SAl Viro .llseek = generic_file_llseek, 1709fd7b9f7bSTejun Heo }; 1710