1b8441ed2STejun Heo /* 2b8441ed2STejun Heo * fs/kernfs/dir.c - kernfs directory implementation 3b8441ed2STejun Heo * 4b8441ed2STejun Heo * Copyright (c) 2001-3 Patrick Mochel 5b8441ed2STejun Heo * Copyright (c) 2007 SUSE Linux Products GmbH 6b8441ed2STejun Heo * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 7b8441ed2STejun Heo * 8b8441ed2STejun Heo * This file is released under the GPLv2. 9b8441ed2STejun Heo */ 10fd7b9f7bSTejun Heo 11abd54f02STejun Heo #include <linux/sched.h> 12fd7b9f7bSTejun Heo #include <linux/fs.h> 13fd7b9f7bSTejun Heo #include <linux/namei.h> 14fd7b9f7bSTejun Heo #include <linux/idr.h> 15fd7b9f7bSTejun Heo #include <linux/slab.h> 16fd7b9f7bSTejun Heo #include <linux/security.h> 17fd7b9f7bSTejun Heo #include <linux/hash.h> 18fd7b9f7bSTejun Heo 19fd7b9f7bSTejun Heo #include "kernfs-internal.h" 20fd7b9f7bSTejun Heo 21a797bfc3STejun Heo DEFINE_MUTEX(kernfs_mutex); 223eef34adSTejun Heo static DEFINE_SPINLOCK(kernfs_rename_lock); /* kn->parent and ->name */ 233eef34adSTejun Heo static char kernfs_pr_cont_buf[PATH_MAX]; /* protected by rename_lock */ 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 { 443eef34adSTejun Heo return strlcpy(buf, kn->parent ? kn->name : "/", buflen); 453eef34adSTejun Heo } 463eef34adSTejun Heo 473eef34adSTejun Heo static char * __must_check kernfs_path_locked(struct kernfs_node *kn, char *buf, 483eef34adSTejun Heo size_t buflen) 493eef34adSTejun Heo { 503eef34adSTejun Heo char *p = buf + buflen; 513eef34adSTejun Heo int len; 523eef34adSTejun Heo 533eef34adSTejun Heo *--p = '\0'; 543eef34adSTejun Heo 553eef34adSTejun Heo do { 563eef34adSTejun Heo len = strlen(kn->name); 573eef34adSTejun Heo if (p - buf < len + 1) { 583eef34adSTejun Heo buf[0] = '\0'; 593eef34adSTejun Heo p = NULL; 603eef34adSTejun Heo break; 613eef34adSTejun Heo } 623eef34adSTejun Heo p -= len; 633eef34adSTejun Heo memcpy(p, kn->name, len); 643eef34adSTejun Heo *--p = '/'; 653eef34adSTejun Heo kn = kn->parent; 663eef34adSTejun Heo } while (kn && kn->parent); 673eef34adSTejun Heo 683eef34adSTejun Heo return p; 693eef34adSTejun Heo } 703eef34adSTejun Heo 713eef34adSTejun Heo /** 723eef34adSTejun Heo * kernfs_name - obtain the name of a given node 733eef34adSTejun Heo * @kn: kernfs_node of interest 743eef34adSTejun Heo * @buf: buffer to copy @kn's name into 753eef34adSTejun Heo * @buflen: size of @buf 763eef34adSTejun Heo * 773eef34adSTejun Heo * Copies the name of @kn into @buf of @buflen bytes. The behavior is 783eef34adSTejun Heo * similar to strlcpy(). It returns the length of @kn's name and if @buf 793eef34adSTejun Heo * isn't long enough, it's filled upto @buflen-1 and nul terminated. 803eef34adSTejun Heo * 813eef34adSTejun Heo * This function can be called from any context. 823eef34adSTejun Heo */ 833eef34adSTejun Heo int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 843eef34adSTejun Heo { 853eef34adSTejun Heo unsigned long flags; 863eef34adSTejun Heo int ret; 873eef34adSTejun Heo 883eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 893eef34adSTejun Heo ret = kernfs_name_locked(kn, buf, buflen); 903eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 913eef34adSTejun Heo return ret; 923eef34adSTejun Heo } 933eef34adSTejun Heo 943eef34adSTejun Heo /** 953eef34adSTejun Heo * kernfs_path - build full path of a given node 963eef34adSTejun Heo * @kn: kernfs_node of interest 973eef34adSTejun Heo * @buf: buffer to copy @kn's name into 983eef34adSTejun Heo * @buflen: size of @buf 993eef34adSTejun Heo * 1003eef34adSTejun Heo * Builds and returns the full path of @kn in @buf of @buflen bytes. The 1013eef34adSTejun Heo * path is built from the end of @buf so the returned pointer usually 1023eef34adSTejun Heo * doesn't match @buf. If @buf isn't long enough, @buf is nul terminated 1033eef34adSTejun Heo * and %NULL is returned. 1043eef34adSTejun Heo */ 1053eef34adSTejun Heo char *kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen) 1063eef34adSTejun Heo { 1073eef34adSTejun Heo unsigned long flags; 1083eef34adSTejun Heo char *p; 1093eef34adSTejun Heo 1103eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 1113eef34adSTejun Heo p = kernfs_path_locked(kn, buf, buflen); 1123eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 1133eef34adSTejun Heo return p; 1143eef34adSTejun Heo } 115e61734c5STejun Heo EXPORT_SYMBOL_GPL(kernfs_path); 1163eef34adSTejun Heo 1173eef34adSTejun Heo /** 1183eef34adSTejun Heo * pr_cont_kernfs_name - pr_cont name of a kernfs_node 1193eef34adSTejun Heo * @kn: kernfs_node of interest 1203eef34adSTejun Heo * 1213eef34adSTejun Heo * This function can be called from any context. 1223eef34adSTejun Heo */ 1233eef34adSTejun Heo void pr_cont_kernfs_name(struct kernfs_node *kn) 1243eef34adSTejun Heo { 1253eef34adSTejun Heo unsigned long flags; 1263eef34adSTejun Heo 1273eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 1283eef34adSTejun Heo 1293eef34adSTejun Heo kernfs_name_locked(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf)); 1303eef34adSTejun Heo pr_cont("%s", kernfs_pr_cont_buf); 1313eef34adSTejun Heo 1323eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 1333eef34adSTejun Heo } 1343eef34adSTejun Heo 1353eef34adSTejun Heo /** 1363eef34adSTejun Heo * pr_cont_kernfs_path - pr_cont path of a kernfs_node 1373eef34adSTejun Heo * @kn: kernfs_node of interest 1383eef34adSTejun Heo * 1393eef34adSTejun Heo * This function can be called from any context. 1403eef34adSTejun Heo */ 1413eef34adSTejun Heo void pr_cont_kernfs_path(struct kernfs_node *kn) 1423eef34adSTejun Heo { 1433eef34adSTejun Heo unsigned long flags; 1443eef34adSTejun Heo char *p; 1453eef34adSTejun Heo 1463eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 1473eef34adSTejun Heo 1483eef34adSTejun Heo p = kernfs_path_locked(kn, kernfs_pr_cont_buf, 1493eef34adSTejun Heo sizeof(kernfs_pr_cont_buf)); 1503eef34adSTejun Heo if (p) 1513eef34adSTejun Heo pr_cont("%s", p); 1523eef34adSTejun Heo else 1533eef34adSTejun Heo pr_cont("<name too long>"); 1543eef34adSTejun Heo 1553eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 1563eef34adSTejun Heo } 1573eef34adSTejun Heo 1583eef34adSTejun Heo /** 1593eef34adSTejun Heo * kernfs_get_parent - determine the parent node and pin it 1603eef34adSTejun Heo * @kn: kernfs_node of interest 1613eef34adSTejun Heo * 1623eef34adSTejun Heo * Determines @kn's parent, pins and returns it. This function can be 1633eef34adSTejun Heo * called from any context. 1643eef34adSTejun Heo */ 1653eef34adSTejun Heo struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 1663eef34adSTejun Heo { 1673eef34adSTejun Heo struct kernfs_node *parent; 1683eef34adSTejun Heo unsigned long flags; 1693eef34adSTejun Heo 1703eef34adSTejun Heo spin_lock_irqsave(&kernfs_rename_lock, flags); 1713eef34adSTejun Heo parent = kn->parent; 1723eef34adSTejun Heo kernfs_get(parent); 1733eef34adSTejun Heo spin_unlock_irqrestore(&kernfs_rename_lock, flags); 1743eef34adSTejun Heo 1753eef34adSTejun Heo return parent; 1763eef34adSTejun Heo } 1773eef34adSTejun Heo 178fd7b9f7bSTejun Heo /** 179c637b8acSTejun Heo * kernfs_name_hash 180fd7b9f7bSTejun Heo * @name: Null terminated string to hash 181fd7b9f7bSTejun Heo * @ns: Namespace tag to hash 182fd7b9f7bSTejun Heo * 183fd7b9f7bSTejun Heo * Returns 31 bit hash of ns + name (so it fits in an off_t ) 184fd7b9f7bSTejun Heo */ 185c637b8acSTejun Heo static unsigned int kernfs_name_hash(const char *name, const void *ns) 186fd7b9f7bSTejun Heo { 187fd7b9f7bSTejun Heo unsigned long hash = init_name_hash(); 188fd7b9f7bSTejun Heo unsigned int len = strlen(name); 189fd7b9f7bSTejun Heo while (len--) 190fd7b9f7bSTejun Heo hash = partial_name_hash(*name++, hash); 191fd7b9f7bSTejun Heo hash = (end_name_hash(hash) ^ hash_ptr((void *)ns, 31)); 192fd7b9f7bSTejun Heo hash &= 0x7fffffffU; 193fd7b9f7bSTejun Heo /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */ 19488391d49SRichard Cochran if (hash < 2) 195fd7b9f7bSTejun Heo hash += 2; 196fd7b9f7bSTejun Heo if (hash >= INT_MAX) 197fd7b9f7bSTejun Heo hash = INT_MAX - 1; 198fd7b9f7bSTejun Heo return hash; 199fd7b9f7bSTejun Heo } 200fd7b9f7bSTejun Heo 201c637b8acSTejun Heo static int kernfs_name_compare(unsigned int hash, const char *name, 202324a56e1STejun Heo const void *ns, const struct kernfs_node *kn) 203fd7b9f7bSTejun Heo { 20472392ed0SRasmus Villemoes if (hash < kn->hash) 20572392ed0SRasmus Villemoes return -1; 20672392ed0SRasmus Villemoes if (hash > kn->hash) 20772392ed0SRasmus Villemoes return 1; 20872392ed0SRasmus Villemoes if (ns < kn->ns) 20972392ed0SRasmus Villemoes return -1; 21072392ed0SRasmus Villemoes if (ns > kn->ns) 21172392ed0SRasmus Villemoes return 1; 212adc5e8b5STejun Heo return strcmp(name, kn->name); 213fd7b9f7bSTejun Heo } 214fd7b9f7bSTejun Heo 215c637b8acSTejun Heo static int kernfs_sd_compare(const struct kernfs_node *left, 216324a56e1STejun Heo const struct kernfs_node *right) 217fd7b9f7bSTejun Heo { 218c637b8acSTejun Heo return kernfs_name_compare(left->hash, left->name, left->ns, right); 219fd7b9f7bSTejun Heo } 220fd7b9f7bSTejun Heo 221fd7b9f7bSTejun Heo /** 222c637b8acSTejun Heo * kernfs_link_sibling - link kernfs_node into sibling rbtree 223324a56e1STejun Heo * @kn: kernfs_node of interest 224fd7b9f7bSTejun Heo * 225324a56e1STejun Heo * Link @kn into its sibling rbtree which starts from 226adc5e8b5STejun Heo * @kn->parent->dir.children. 227fd7b9f7bSTejun Heo * 228fd7b9f7bSTejun Heo * Locking: 229a797bfc3STejun Heo * mutex_lock(kernfs_mutex) 230fd7b9f7bSTejun Heo * 231fd7b9f7bSTejun Heo * RETURNS: 232fd7b9f7bSTejun Heo * 0 on susccess -EEXIST on failure. 233fd7b9f7bSTejun Heo */ 234c637b8acSTejun Heo static int kernfs_link_sibling(struct kernfs_node *kn) 235fd7b9f7bSTejun Heo { 236adc5e8b5STejun Heo struct rb_node **node = &kn->parent->dir.children.rb_node; 237fd7b9f7bSTejun Heo struct rb_node *parent = NULL; 238fd7b9f7bSTejun Heo 239fd7b9f7bSTejun Heo while (*node) { 240324a56e1STejun Heo struct kernfs_node *pos; 241fd7b9f7bSTejun Heo int result; 242fd7b9f7bSTejun Heo 243324a56e1STejun Heo pos = rb_to_kn(*node); 244fd7b9f7bSTejun Heo parent = *node; 245c637b8acSTejun Heo result = kernfs_sd_compare(kn, pos); 246fd7b9f7bSTejun Heo if (result < 0) 247adc5e8b5STejun Heo node = &pos->rb.rb_left; 248fd7b9f7bSTejun Heo else if (result > 0) 249adc5e8b5STejun Heo node = &pos->rb.rb_right; 250fd7b9f7bSTejun Heo else 251fd7b9f7bSTejun Heo return -EEXIST; 252fd7b9f7bSTejun Heo } 253c1befb88SJianyu Zhan 254fd7b9f7bSTejun Heo /* add new node and rebalance the tree */ 255adc5e8b5STejun Heo rb_link_node(&kn->rb, parent, node); 256adc5e8b5STejun Heo rb_insert_color(&kn->rb, &kn->parent->dir.children); 257c1befb88SJianyu Zhan 258c1befb88SJianyu Zhan /* successfully added, account subdir number */ 259c1befb88SJianyu Zhan if (kernfs_type(kn) == KERNFS_DIR) 260c1befb88SJianyu Zhan kn->parent->dir.subdirs++; 261c1befb88SJianyu Zhan 262fd7b9f7bSTejun Heo return 0; 263fd7b9f7bSTejun Heo } 264fd7b9f7bSTejun Heo 265fd7b9f7bSTejun Heo /** 266c637b8acSTejun Heo * kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree 267324a56e1STejun Heo * @kn: kernfs_node of interest 268fd7b9f7bSTejun Heo * 26935beab06STejun Heo * Try to unlink @kn from its sibling rbtree which starts from 27035beab06STejun Heo * kn->parent->dir.children. Returns %true if @kn was actually 27135beab06STejun Heo * removed, %false if @kn wasn't on the rbtree. 272fd7b9f7bSTejun Heo * 273fd7b9f7bSTejun Heo * Locking: 274a797bfc3STejun Heo * mutex_lock(kernfs_mutex) 275fd7b9f7bSTejun Heo */ 27635beab06STejun Heo static bool kernfs_unlink_sibling(struct kernfs_node *kn) 277fd7b9f7bSTejun Heo { 27835beab06STejun Heo if (RB_EMPTY_NODE(&kn->rb)) 27935beab06STejun Heo return false; 28035beab06STejun Heo 281df23fc39STejun Heo if (kernfs_type(kn) == KERNFS_DIR) 282adc5e8b5STejun Heo kn->parent->dir.subdirs--; 283fd7b9f7bSTejun Heo 284adc5e8b5STejun Heo rb_erase(&kn->rb, &kn->parent->dir.children); 28535beab06STejun Heo RB_CLEAR_NODE(&kn->rb); 28635beab06STejun Heo return true; 287fd7b9f7bSTejun Heo } 288fd7b9f7bSTejun Heo 289fd7b9f7bSTejun Heo /** 290c637b8acSTejun Heo * kernfs_get_active - get an active reference to kernfs_node 291324a56e1STejun Heo * @kn: kernfs_node to get an active reference to 292fd7b9f7bSTejun Heo * 293324a56e1STejun Heo * Get an active reference of @kn. This function is noop if @kn 294fd7b9f7bSTejun Heo * is NULL. 295fd7b9f7bSTejun Heo * 296fd7b9f7bSTejun Heo * RETURNS: 297324a56e1STejun Heo * Pointer to @kn on success, NULL on failure. 298fd7b9f7bSTejun Heo */ 299c637b8acSTejun Heo struct kernfs_node *kernfs_get_active(struct kernfs_node *kn) 300fd7b9f7bSTejun Heo { 301324a56e1STejun Heo if (unlikely(!kn)) 302fd7b9f7bSTejun Heo return NULL; 303fd7b9f7bSTejun Heo 304f4b3e631SGreg Kroah-Hartman if (!atomic_inc_unless_negative(&kn->active)) 305f4b3e631SGreg Kroah-Hartman return NULL; 306f4b3e631SGreg Kroah-Hartman 307182fd64bSTejun Heo if (kernfs_lockdep(kn)) 308324a56e1STejun Heo rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_); 309324a56e1STejun Heo return kn; 310fd7b9f7bSTejun Heo } 311fd7b9f7bSTejun Heo 312fd7b9f7bSTejun Heo /** 313c637b8acSTejun Heo * kernfs_put_active - put an active reference to kernfs_node 314324a56e1STejun Heo * @kn: kernfs_node to put an active reference to 315fd7b9f7bSTejun Heo * 316324a56e1STejun Heo * Put an active reference to @kn. This function is noop if @kn 317fd7b9f7bSTejun Heo * is NULL. 318fd7b9f7bSTejun Heo */ 319c637b8acSTejun Heo void kernfs_put_active(struct kernfs_node *kn) 320fd7b9f7bSTejun Heo { 321abd54f02STejun Heo struct kernfs_root *root = kernfs_root(kn); 322fd7b9f7bSTejun Heo int v; 323fd7b9f7bSTejun Heo 324324a56e1STejun Heo if (unlikely(!kn)) 325fd7b9f7bSTejun Heo return; 326fd7b9f7bSTejun Heo 327182fd64bSTejun Heo if (kernfs_lockdep(kn)) 328324a56e1STejun Heo rwsem_release(&kn->dep_map, 1, _RET_IP_); 329adc5e8b5STejun Heo v = atomic_dec_return(&kn->active); 330df23fc39STejun Heo if (likely(v != KN_DEACTIVATED_BIAS)) 331fd7b9f7bSTejun Heo return; 332fd7b9f7bSTejun Heo 333abd54f02STejun Heo wake_up_all(&root->deactivate_waitq); 334fd7b9f7bSTejun Heo } 335fd7b9f7bSTejun Heo 336fd7b9f7bSTejun Heo /** 33781c173cbSTejun Heo * kernfs_drain - drain kernfs_node 33881c173cbSTejun Heo * @kn: kernfs_node to drain 339fd7b9f7bSTejun Heo * 34081c173cbSTejun Heo * Drain existing usages and nuke all existing mmaps of @kn. Mutiple 34181c173cbSTejun Heo * removers may invoke this function concurrently on @kn and all will 34281c173cbSTejun Heo * return after draining is complete. 343fd7b9f7bSTejun Heo */ 34481c173cbSTejun Heo static void kernfs_drain(struct kernfs_node *kn) 34535beab06STejun Heo __releases(&kernfs_mutex) __acquires(&kernfs_mutex) 346fd7b9f7bSTejun Heo { 347abd54f02STejun Heo struct kernfs_root *root = kernfs_root(kn); 348fd7b9f7bSTejun Heo 34935beab06STejun Heo lockdep_assert_held(&kernfs_mutex); 35081c173cbSTejun Heo WARN_ON_ONCE(kernfs_active(kn)); 351abd54f02STejun Heo 35235beab06STejun Heo mutex_unlock(&kernfs_mutex); 353abd54f02STejun Heo 354182fd64bSTejun Heo if (kernfs_lockdep(kn)) { 35535beab06STejun Heo rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_); 35635beab06STejun Heo if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS) 35735beab06STejun Heo lock_contended(&kn->dep_map, _RET_IP_); 35835beab06STejun Heo } 35935beab06STejun Heo 36035beab06STejun Heo /* but everyone should wait for draining */ 361abd54f02STejun Heo wait_event(root->deactivate_waitq, 362abd54f02STejun Heo atomic_read(&kn->active) == KN_DEACTIVATED_BIAS); 363fd7b9f7bSTejun Heo 364182fd64bSTejun Heo if (kernfs_lockdep(kn)) { 365324a56e1STejun Heo lock_acquired(&kn->dep_map, _RET_IP_); 366324a56e1STejun Heo rwsem_release(&kn->dep_map, 1, _RET_IP_); 367fd7b9f7bSTejun Heo } 36835beab06STejun Heo 369ccf02aafSTejun Heo kernfs_unmap_bin_file(kn); 370ccf02aafSTejun Heo 37135beab06STejun Heo mutex_lock(&kernfs_mutex); 372a6607930STejun Heo } 373fd7b9f7bSTejun Heo 374fd7b9f7bSTejun Heo /** 375324a56e1STejun Heo * kernfs_get - get a reference count on a kernfs_node 376324a56e1STejun Heo * @kn: the target kernfs_node 377fd7b9f7bSTejun Heo */ 378324a56e1STejun Heo void kernfs_get(struct kernfs_node *kn) 379fd7b9f7bSTejun Heo { 380324a56e1STejun Heo if (kn) { 381adc5e8b5STejun Heo WARN_ON(!atomic_read(&kn->count)); 382adc5e8b5STejun Heo atomic_inc(&kn->count); 383fd7b9f7bSTejun Heo } 384fd7b9f7bSTejun Heo } 385fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_get); 386fd7b9f7bSTejun Heo 387fd7b9f7bSTejun Heo /** 388324a56e1STejun Heo * kernfs_put - put a reference count on a kernfs_node 389324a56e1STejun Heo * @kn: the target kernfs_node 390fd7b9f7bSTejun Heo * 391324a56e1STejun Heo * Put a reference count of @kn and destroy it if it reached zero. 392fd7b9f7bSTejun Heo */ 393324a56e1STejun Heo void kernfs_put(struct kernfs_node *kn) 394fd7b9f7bSTejun Heo { 395324a56e1STejun Heo struct kernfs_node *parent; 396ba7443bcSTejun Heo struct kernfs_root *root; 397fd7b9f7bSTejun Heo 398adc5e8b5STejun Heo if (!kn || !atomic_dec_and_test(&kn->count)) 399fd7b9f7bSTejun Heo return; 400324a56e1STejun Heo root = kernfs_root(kn); 401fd7b9f7bSTejun Heo repeat: 40281c173cbSTejun Heo /* 40381c173cbSTejun Heo * Moving/renaming is always done while holding reference. 404adc5e8b5STejun Heo * kn->parent won't change beneath us. 405fd7b9f7bSTejun Heo */ 406adc5e8b5STejun Heo parent = kn->parent; 407fd7b9f7bSTejun Heo 40881c173cbSTejun Heo WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS, 40981c173cbSTejun Heo "kernfs_put: %s/%s: released with incorrect active_ref %d\n", 41081c173cbSTejun Heo parent ? parent->name : "", kn->name, atomic_read(&kn->active)); 411fd7b9f7bSTejun Heo 412df23fc39STejun Heo if (kernfs_type(kn) == KERNFS_LINK) 413adc5e8b5STejun Heo kernfs_put(kn->symlink.target_kn); 414dfeb0750STejun Heo 41575287a67SAndrzej Hajda kfree_const(kn->name); 416dfeb0750STejun Heo 417adc5e8b5STejun Heo if (kn->iattr) { 418adc5e8b5STejun Heo if (kn->iattr->ia_secdata) 419adc5e8b5STejun Heo security_release_secctx(kn->iattr->ia_secdata, 420adc5e8b5STejun Heo kn->iattr->ia_secdata_len); 421adc5e8b5STejun Heo simple_xattrs_free(&kn->iattr->xattrs); 4222322392bSTejun Heo } 423adc5e8b5STejun Heo kfree(kn->iattr); 424adc5e8b5STejun Heo ida_simple_remove(&root->ino_ida, kn->ino); 425a797bfc3STejun Heo kmem_cache_free(kernfs_node_cache, kn); 426fd7b9f7bSTejun Heo 427324a56e1STejun Heo kn = parent; 428324a56e1STejun Heo if (kn) { 429adc5e8b5STejun Heo if (atomic_dec_and_test(&kn->count)) 430fd7b9f7bSTejun Heo goto repeat; 431ba7443bcSTejun Heo } else { 432324a56e1STejun Heo /* just released the root kn, free @root too */ 433bc755553STejun Heo ida_destroy(&root->ino_ida); 434ba7443bcSTejun Heo kfree(root); 435ba7443bcSTejun Heo } 436fd7b9f7bSTejun Heo } 437fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_put); 438fd7b9f7bSTejun Heo 439c637b8acSTejun Heo static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags) 440fd7b9f7bSTejun Heo { 441324a56e1STejun Heo struct kernfs_node *kn; 442fd7b9f7bSTejun Heo 443fd7b9f7bSTejun Heo if (flags & LOOKUP_RCU) 444fd7b9f7bSTejun Heo return -ECHILD; 445fd7b9f7bSTejun Heo 44619bbb926STejun Heo /* Always perform fresh lookup for negatives */ 4472b0143b5SDavid Howells if (d_really_is_negative(dentry)) 44819bbb926STejun Heo goto out_bad_unlocked; 44919bbb926STejun Heo 450324a56e1STejun Heo kn = dentry->d_fsdata; 451a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 452fd7b9f7bSTejun Heo 45381c173cbSTejun Heo /* The kernfs node has been deactivated */ 45481c173cbSTejun Heo if (!kernfs_active(kn)) 455fd7b9f7bSTejun Heo goto out_bad; 456fd7b9f7bSTejun Heo 457c637b8acSTejun Heo /* The kernfs node has been moved? */ 458adc5e8b5STejun Heo if (dentry->d_parent->d_fsdata != kn->parent) 459fd7b9f7bSTejun Heo goto out_bad; 460fd7b9f7bSTejun Heo 461c637b8acSTejun Heo /* The kernfs node has been renamed */ 462adc5e8b5STejun Heo if (strcmp(dentry->d_name.name, kn->name) != 0) 463fd7b9f7bSTejun Heo goto out_bad; 464fd7b9f7bSTejun Heo 465c637b8acSTejun Heo /* The kernfs node has been moved to a different namespace */ 466adc5e8b5STejun Heo if (kn->parent && kernfs_ns_enabled(kn->parent) && 467c525aaddSTejun Heo kernfs_info(dentry->d_sb)->ns != kn->ns) 468fd7b9f7bSTejun Heo goto out_bad; 469fd7b9f7bSTejun Heo 470a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 471fd7b9f7bSTejun Heo return 1; 472fd7b9f7bSTejun Heo out_bad: 473a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 47419bbb926STejun Heo out_bad_unlocked: 475fd7b9f7bSTejun Heo return 0; 476fd7b9f7bSTejun Heo } 477fd7b9f7bSTejun Heo 478c637b8acSTejun Heo static void kernfs_dop_release(struct dentry *dentry) 479fd7b9f7bSTejun Heo { 480fd7b9f7bSTejun Heo kernfs_put(dentry->d_fsdata); 481fd7b9f7bSTejun Heo } 482fd7b9f7bSTejun Heo 483a797bfc3STejun Heo const struct dentry_operations kernfs_dops = { 484c637b8acSTejun Heo .d_revalidate = kernfs_dop_revalidate, 485c637b8acSTejun Heo .d_release = kernfs_dop_release, 486fd7b9f7bSTejun Heo }; 487fd7b9f7bSTejun Heo 4880c23b225STejun Heo /** 4890c23b225STejun Heo * kernfs_node_from_dentry - determine kernfs_node associated with a dentry 4900c23b225STejun Heo * @dentry: the dentry in question 4910c23b225STejun Heo * 4920c23b225STejun Heo * Return the kernfs_node associated with @dentry. If @dentry is not a 4930c23b225STejun Heo * kernfs one, %NULL is returned. 4940c23b225STejun Heo * 4950c23b225STejun Heo * While the returned kernfs_node will stay accessible as long as @dentry 4960c23b225STejun Heo * is accessible, the returned node can be in any state and the caller is 4970c23b225STejun Heo * fully responsible for determining what's accessible. 4980c23b225STejun Heo */ 4990c23b225STejun Heo struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 5000c23b225STejun Heo { 501f41c5934SLi Zefan if (dentry->d_sb->s_op == &kernfs_sops) 5020c23b225STejun Heo return dentry->d_fsdata; 5030c23b225STejun Heo return NULL; 5040c23b225STejun Heo } 5050c23b225STejun Heo 506db4aad20STejun Heo static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root, 507db4aad20STejun Heo const char *name, umode_t mode, 508db4aad20STejun Heo unsigned flags) 509fd7b9f7bSTejun Heo { 510324a56e1STejun Heo struct kernfs_node *kn; 511bc755553STejun Heo int ret; 512fd7b9f7bSTejun Heo 513dfeb0750STejun Heo name = kstrdup_const(name, GFP_KERNEL); 514fd7b9f7bSTejun Heo if (!name) 515fd7b9f7bSTejun Heo return NULL; 516fd7b9f7bSTejun Heo 517a797bfc3STejun Heo kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL); 518324a56e1STejun Heo if (!kn) 519fd7b9f7bSTejun Heo goto err_out1; 520fd7b9f7bSTejun Heo 521bc755553STejun Heo ret = ida_simple_get(&root->ino_ida, 1, 0, GFP_KERNEL); 522bc755553STejun Heo if (ret < 0) 523fd7b9f7bSTejun Heo goto err_out2; 524adc5e8b5STejun Heo kn->ino = ret; 525fd7b9f7bSTejun Heo 526adc5e8b5STejun Heo atomic_set(&kn->count, 1); 52781c173cbSTejun Heo atomic_set(&kn->active, KN_DEACTIVATED_BIAS); 52835beab06STejun Heo RB_CLEAR_NODE(&kn->rb); 529fd7b9f7bSTejun Heo 530adc5e8b5STejun Heo kn->name = name; 531adc5e8b5STejun Heo kn->mode = mode; 53281c173cbSTejun Heo kn->flags = flags; 533fd7b9f7bSTejun Heo 534324a56e1STejun Heo return kn; 535fd7b9f7bSTejun Heo 536fd7b9f7bSTejun Heo err_out2: 537a797bfc3STejun Heo kmem_cache_free(kernfs_node_cache, kn); 538fd7b9f7bSTejun Heo err_out1: 539dfeb0750STejun Heo kfree_const(name); 540fd7b9f7bSTejun Heo return NULL; 541fd7b9f7bSTejun Heo } 542fd7b9f7bSTejun Heo 543db4aad20STejun Heo struct kernfs_node *kernfs_new_node(struct kernfs_node *parent, 544db4aad20STejun Heo const char *name, umode_t mode, 545db4aad20STejun Heo unsigned flags) 546db4aad20STejun Heo { 547db4aad20STejun Heo struct kernfs_node *kn; 548db4aad20STejun Heo 549db4aad20STejun Heo kn = __kernfs_new_node(kernfs_root(parent), name, mode, flags); 550db4aad20STejun Heo if (kn) { 551db4aad20STejun Heo kernfs_get(parent); 552db4aad20STejun Heo kn->parent = parent; 553db4aad20STejun Heo } 554db4aad20STejun Heo return kn; 555db4aad20STejun Heo } 556db4aad20STejun Heo 557fd7b9f7bSTejun Heo /** 558c637b8acSTejun Heo * kernfs_add_one - add kernfs_node to parent without warning 559324a56e1STejun Heo * @kn: kernfs_node to be added 560fd7b9f7bSTejun Heo * 561db4aad20STejun Heo * The caller must already have initialized @kn->parent. This 562db4aad20STejun Heo * function increments nlink of the parent's inode if @kn is a 563db4aad20STejun Heo * directory and link into the children list of the parent. 564fd7b9f7bSTejun Heo * 565fd7b9f7bSTejun Heo * RETURNS: 566fd7b9f7bSTejun Heo * 0 on success, -EEXIST if entry with the given name already 567fd7b9f7bSTejun Heo * exists. 568fd7b9f7bSTejun Heo */ 569988cd7afSTejun Heo int kernfs_add_one(struct kernfs_node *kn) 570fd7b9f7bSTejun Heo { 571db4aad20STejun Heo struct kernfs_node *parent = kn->parent; 572c525aaddSTejun Heo struct kernfs_iattrs *ps_iattr; 573988cd7afSTejun Heo bool has_ns; 574fd7b9f7bSTejun Heo int ret; 575fd7b9f7bSTejun Heo 576988cd7afSTejun Heo mutex_lock(&kernfs_mutex); 577988cd7afSTejun Heo 578988cd7afSTejun Heo ret = -EINVAL; 579988cd7afSTejun Heo has_ns = kernfs_ns_enabled(parent); 580988cd7afSTejun Heo if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 581988cd7afSTejun Heo has_ns ? "required" : "invalid", parent->name, kn->name)) 582988cd7afSTejun Heo goto out_unlock; 583fd7b9f7bSTejun Heo 584df23fc39STejun Heo if (kernfs_type(parent) != KERNFS_DIR) 585988cd7afSTejun Heo goto out_unlock; 586fd7b9f7bSTejun Heo 587988cd7afSTejun Heo ret = -ENOENT; 588ea015218SEric W. Biederman if (parent->flags & KERNFS_EMPTY_DIR) 589ea015218SEric W. Biederman goto out_unlock; 590ea015218SEric W. Biederman 591d35258efSTejun Heo if ((parent->flags & KERNFS_ACTIVATED) && !kernfs_active(parent)) 592988cd7afSTejun Heo goto out_unlock; 593798c75a0SGreg Kroah-Hartman 594c637b8acSTejun Heo kn->hash = kernfs_name_hash(kn->name, kn->ns); 595fd7b9f7bSTejun Heo 596c637b8acSTejun Heo ret = kernfs_link_sibling(kn); 597fd7b9f7bSTejun Heo if (ret) 598988cd7afSTejun Heo goto out_unlock; 599fd7b9f7bSTejun Heo 600fd7b9f7bSTejun Heo /* Update timestamps on the parent */ 601adc5e8b5STejun Heo ps_iattr = parent->iattr; 602fd7b9f7bSTejun Heo if (ps_iattr) { 603fd7b9f7bSTejun Heo struct iattr *ps_iattrs = &ps_iattr->ia_iattr; 604fd7b9f7bSTejun Heo ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME; 605fd7b9f7bSTejun Heo } 606fd7b9f7bSTejun Heo 607d35258efSTejun Heo mutex_unlock(&kernfs_mutex); 608d35258efSTejun Heo 609d35258efSTejun Heo /* 610d35258efSTejun Heo * Activate the new node unless CREATE_DEACTIVATED is requested. 611d35258efSTejun Heo * If not activated here, the kernfs user is responsible for 612d35258efSTejun Heo * activating the node with kernfs_activate(). A node which hasn't 613d35258efSTejun Heo * been activated is not visible to userland and its removal won't 614d35258efSTejun Heo * trigger deactivation. 615d35258efSTejun Heo */ 616d35258efSTejun Heo if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 617d35258efSTejun Heo kernfs_activate(kn); 618d35258efSTejun Heo return 0; 619d35258efSTejun Heo 620988cd7afSTejun Heo out_unlock: 621a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 622988cd7afSTejun Heo return ret; 623fd7b9f7bSTejun Heo } 624fd7b9f7bSTejun Heo 625fd7b9f7bSTejun Heo /** 626324a56e1STejun Heo * kernfs_find_ns - find kernfs_node with the given name 627324a56e1STejun Heo * @parent: kernfs_node to search under 628fd7b9f7bSTejun Heo * @name: name to look for 629fd7b9f7bSTejun Heo * @ns: the namespace tag to use 630fd7b9f7bSTejun Heo * 631324a56e1STejun Heo * Look for kernfs_node with name @name under @parent. Returns pointer to 632324a56e1STejun Heo * the found kernfs_node on success, %NULL on failure. 633fd7b9f7bSTejun Heo */ 634324a56e1STejun Heo static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent, 635fd7b9f7bSTejun Heo const unsigned char *name, 636fd7b9f7bSTejun Heo const void *ns) 637fd7b9f7bSTejun Heo { 638adc5e8b5STejun Heo struct rb_node *node = parent->dir.children.rb_node; 639ac9bba03STejun Heo bool has_ns = kernfs_ns_enabled(parent); 640fd7b9f7bSTejun Heo unsigned int hash; 641fd7b9f7bSTejun Heo 642a797bfc3STejun Heo lockdep_assert_held(&kernfs_mutex); 643fd7b9f7bSTejun Heo 644fd7b9f7bSTejun Heo if (has_ns != (bool)ns) { 645c637b8acSTejun Heo WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 646adc5e8b5STejun Heo has_ns ? "required" : "invalid", parent->name, name); 647fd7b9f7bSTejun Heo return NULL; 648fd7b9f7bSTejun Heo } 649fd7b9f7bSTejun Heo 650c637b8acSTejun Heo hash = kernfs_name_hash(name, ns); 651fd7b9f7bSTejun Heo while (node) { 652324a56e1STejun Heo struct kernfs_node *kn; 653fd7b9f7bSTejun Heo int result; 654fd7b9f7bSTejun Heo 655324a56e1STejun Heo kn = rb_to_kn(node); 656c637b8acSTejun Heo result = kernfs_name_compare(hash, name, ns, kn); 657fd7b9f7bSTejun Heo if (result < 0) 658fd7b9f7bSTejun Heo node = node->rb_left; 659fd7b9f7bSTejun Heo else if (result > 0) 660fd7b9f7bSTejun Heo node = node->rb_right; 661fd7b9f7bSTejun Heo else 662324a56e1STejun Heo return kn; 663fd7b9f7bSTejun Heo } 664fd7b9f7bSTejun Heo return NULL; 665fd7b9f7bSTejun Heo } 666fd7b9f7bSTejun Heo 667fd7b9f7bSTejun Heo /** 668324a56e1STejun Heo * kernfs_find_and_get_ns - find and get kernfs_node with the given name 669324a56e1STejun Heo * @parent: kernfs_node to search under 670fd7b9f7bSTejun Heo * @name: name to look for 671fd7b9f7bSTejun Heo * @ns: the namespace tag to use 672fd7b9f7bSTejun Heo * 673324a56e1STejun Heo * Look for kernfs_node with name @name under @parent and get a reference 674fd7b9f7bSTejun Heo * if found. This function may sleep and returns pointer to the found 675324a56e1STejun Heo * kernfs_node on success, %NULL on failure. 676fd7b9f7bSTejun Heo */ 677324a56e1STejun Heo struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 678fd7b9f7bSTejun Heo const char *name, const void *ns) 679fd7b9f7bSTejun Heo { 680324a56e1STejun Heo struct kernfs_node *kn; 681fd7b9f7bSTejun Heo 682a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 683324a56e1STejun Heo kn = kernfs_find_ns(parent, name, ns); 684324a56e1STejun Heo kernfs_get(kn); 685a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 686fd7b9f7bSTejun Heo 687324a56e1STejun Heo return kn; 688fd7b9f7bSTejun Heo } 689fd7b9f7bSTejun Heo EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns); 690fd7b9f7bSTejun Heo 691fd7b9f7bSTejun Heo /** 692ba7443bcSTejun Heo * kernfs_create_root - create a new kernfs hierarchy 69390c07c89STejun Heo * @scops: optional syscall operations for the hierarchy 694d35258efSTejun Heo * @flags: KERNFS_ROOT_* flags 695ba7443bcSTejun Heo * @priv: opaque data associated with the new directory 696ba7443bcSTejun Heo * 697ba7443bcSTejun Heo * Returns the root of the new hierarchy on success, ERR_PTR() value on 698ba7443bcSTejun Heo * failure. 699ba7443bcSTejun Heo */ 70090c07c89STejun Heo struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 701d35258efSTejun Heo unsigned int flags, void *priv) 702ba7443bcSTejun Heo { 703ba7443bcSTejun Heo struct kernfs_root *root; 704324a56e1STejun Heo struct kernfs_node *kn; 705ba7443bcSTejun Heo 706ba7443bcSTejun Heo root = kzalloc(sizeof(*root), GFP_KERNEL); 707ba7443bcSTejun Heo if (!root) 708ba7443bcSTejun Heo return ERR_PTR(-ENOMEM); 709ba7443bcSTejun Heo 710bc755553STejun Heo ida_init(&root->ino_ida); 7117d568a83STejun Heo INIT_LIST_HEAD(&root->supers); 712bc755553STejun Heo 713db4aad20STejun Heo kn = __kernfs_new_node(root, "", S_IFDIR | S_IRUGO | S_IXUGO, 714db4aad20STejun Heo KERNFS_DIR); 715324a56e1STejun Heo if (!kn) { 716bc755553STejun Heo ida_destroy(&root->ino_ida); 717ba7443bcSTejun Heo kfree(root); 718ba7443bcSTejun Heo return ERR_PTR(-ENOMEM); 719ba7443bcSTejun Heo } 720ba7443bcSTejun Heo 721324a56e1STejun Heo kn->priv = priv; 722adc5e8b5STejun Heo kn->dir.root = root; 723ba7443bcSTejun Heo 72490c07c89STejun Heo root->syscall_ops = scops; 725d35258efSTejun Heo root->flags = flags; 726324a56e1STejun Heo root->kn = kn; 727abd54f02STejun Heo init_waitqueue_head(&root->deactivate_waitq); 728ba7443bcSTejun Heo 729d35258efSTejun Heo if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 730d35258efSTejun Heo kernfs_activate(kn); 731d35258efSTejun Heo 732ba7443bcSTejun Heo return root; 733ba7443bcSTejun Heo } 734ba7443bcSTejun Heo 735ba7443bcSTejun Heo /** 736ba7443bcSTejun Heo * kernfs_destroy_root - destroy a kernfs hierarchy 737ba7443bcSTejun Heo * @root: root of the hierarchy to destroy 738ba7443bcSTejun Heo * 739ba7443bcSTejun Heo * Destroy the hierarchy anchored at @root by removing all existing 740ba7443bcSTejun Heo * directories and destroying @root. 741ba7443bcSTejun Heo */ 742ba7443bcSTejun Heo void kernfs_destroy_root(struct kernfs_root *root) 743ba7443bcSTejun Heo { 744324a56e1STejun Heo kernfs_remove(root->kn); /* will also free @root */ 745ba7443bcSTejun Heo } 746ba7443bcSTejun Heo 747ba7443bcSTejun Heo /** 748fd7b9f7bSTejun Heo * kernfs_create_dir_ns - create a directory 749fd7b9f7bSTejun Heo * @parent: parent in which to create a new directory 750fd7b9f7bSTejun Heo * @name: name of the new directory 751bb8b9d09STejun Heo * @mode: mode of the new directory 752fd7b9f7bSTejun Heo * @priv: opaque data associated with the new directory 753fd7b9f7bSTejun Heo * @ns: optional namespace tag of the directory 754fd7b9f7bSTejun Heo * 755fd7b9f7bSTejun Heo * Returns the created node on success, ERR_PTR() value on failure. 756fd7b9f7bSTejun Heo */ 757324a56e1STejun Heo struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 758bb8b9d09STejun Heo const char *name, umode_t mode, 759bb8b9d09STejun Heo void *priv, const void *ns) 760fd7b9f7bSTejun Heo { 761324a56e1STejun Heo struct kernfs_node *kn; 762fd7b9f7bSTejun Heo int rc; 763fd7b9f7bSTejun Heo 764fd7b9f7bSTejun Heo /* allocate */ 765db4aad20STejun Heo kn = kernfs_new_node(parent, name, mode | S_IFDIR, KERNFS_DIR); 766324a56e1STejun Heo if (!kn) 767fd7b9f7bSTejun Heo return ERR_PTR(-ENOMEM); 768fd7b9f7bSTejun Heo 769adc5e8b5STejun Heo kn->dir.root = parent->dir.root; 770adc5e8b5STejun Heo kn->ns = ns; 771324a56e1STejun Heo kn->priv = priv; 772fd7b9f7bSTejun Heo 773fd7b9f7bSTejun Heo /* link in */ 774988cd7afSTejun Heo rc = kernfs_add_one(kn); 775fd7b9f7bSTejun Heo if (!rc) 776324a56e1STejun Heo return kn; 777fd7b9f7bSTejun Heo 778324a56e1STejun Heo kernfs_put(kn); 779fd7b9f7bSTejun Heo return ERR_PTR(rc); 780fd7b9f7bSTejun Heo } 781fd7b9f7bSTejun Heo 782ea015218SEric W. Biederman /** 783ea015218SEric W. Biederman * kernfs_create_empty_dir - create an always empty directory 784ea015218SEric W. Biederman * @parent: parent in which to create a new directory 785ea015218SEric W. Biederman * @name: name of the new directory 786ea015218SEric W. Biederman * 787ea015218SEric W. Biederman * Returns the created node on success, ERR_PTR() value on failure. 788ea015218SEric W. Biederman */ 789ea015218SEric W. Biederman struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent, 790ea015218SEric W. Biederman const char *name) 791ea015218SEric W. Biederman { 792ea015218SEric W. Biederman struct kernfs_node *kn; 793ea015218SEric W. Biederman int rc; 794ea015218SEric W. Biederman 795ea015218SEric W. Biederman /* allocate */ 796ea015218SEric W. Biederman kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR, KERNFS_DIR); 797ea015218SEric W. Biederman if (!kn) 798ea015218SEric W. Biederman return ERR_PTR(-ENOMEM); 799ea015218SEric W. Biederman 800ea015218SEric W. Biederman kn->flags |= KERNFS_EMPTY_DIR; 801ea015218SEric W. Biederman kn->dir.root = parent->dir.root; 802ea015218SEric W. Biederman kn->ns = NULL; 803ea015218SEric W. Biederman kn->priv = NULL; 804ea015218SEric W. Biederman 805ea015218SEric W. Biederman /* link in */ 806ea015218SEric W. Biederman rc = kernfs_add_one(kn); 807ea015218SEric W. Biederman if (!rc) 808ea015218SEric W. Biederman return kn; 809ea015218SEric W. Biederman 810ea015218SEric W. Biederman kernfs_put(kn); 811ea015218SEric W. Biederman return ERR_PTR(rc); 812ea015218SEric W. Biederman } 813ea015218SEric W. Biederman 814c637b8acSTejun Heo static struct dentry *kernfs_iop_lookup(struct inode *dir, 815c637b8acSTejun Heo struct dentry *dentry, 816fd7b9f7bSTejun Heo unsigned int flags) 817fd7b9f7bSTejun Heo { 81819bbb926STejun Heo struct dentry *ret; 819324a56e1STejun Heo struct kernfs_node *parent = dentry->d_parent->d_fsdata; 820324a56e1STejun Heo struct kernfs_node *kn; 821fd7b9f7bSTejun Heo struct inode *inode; 822fd7b9f7bSTejun Heo const void *ns = NULL; 823fd7b9f7bSTejun Heo 824a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 825fd7b9f7bSTejun Heo 826324a56e1STejun Heo if (kernfs_ns_enabled(parent)) 827c525aaddSTejun Heo ns = kernfs_info(dir->i_sb)->ns; 828fd7b9f7bSTejun Heo 829324a56e1STejun Heo kn = kernfs_find_ns(parent, dentry->d_name.name, ns); 830fd7b9f7bSTejun Heo 831fd7b9f7bSTejun Heo /* no such entry */ 832b9c9dad0STejun Heo if (!kn || !kernfs_active(kn)) { 83319bbb926STejun Heo ret = NULL; 834fd7b9f7bSTejun Heo goto out_unlock; 835fd7b9f7bSTejun Heo } 836324a56e1STejun Heo kernfs_get(kn); 837324a56e1STejun Heo dentry->d_fsdata = kn; 838fd7b9f7bSTejun Heo 839fd7b9f7bSTejun Heo /* attach dentry and inode */ 840c637b8acSTejun Heo inode = kernfs_get_inode(dir->i_sb, kn); 841fd7b9f7bSTejun Heo if (!inode) { 842fd7b9f7bSTejun Heo ret = ERR_PTR(-ENOMEM); 843fd7b9f7bSTejun Heo goto out_unlock; 844fd7b9f7bSTejun Heo } 845fd7b9f7bSTejun Heo 846fd7b9f7bSTejun Heo /* instantiate and hash dentry */ 84741d28bcaSAl Viro ret = d_splice_alias(inode, dentry); 848fd7b9f7bSTejun Heo out_unlock: 849a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 850fd7b9f7bSTejun Heo return ret; 851fd7b9f7bSTejun Heo } 852fd7b9f7bSTejun Heo 85380b9bbefSTejun Heo static int kernfs_iop_mkdir(struct inode *dir, struct dentry *dentry, 85480b9bbefSTejun Heo umode_t mode) 85580b9bbefSTejun Heo { 85680b9bbefSTejun Heo struct kernfs_node *parent = dir->i_private; 85790c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops; 85807c7530dSTejun Heo int ret; 85980b9bbefSTejun Heo 86090c07c89STejun Heo if (!scops || !scops->mkdir) 86180b9bbefSTejun Heo return -EPERM; 86280b9bbefSTejun Heo 86307c7530dSTejun Heo if (!kernfs_get_active(parent)) 86407c7530dSTejun Heo return -ENODEV; 86507c7530dSTejun Heo 86690c07c89STejun Heo ret = scops->mkdir(parent, dentry->d_name.name, mode); 86707c7530dSTejun Heo 86807c7530dSTejun Heo kernfs_put_active(parent); 86907c7530dSTejun Heo return ret; 87080b9bbefSTejun Heo } 87180b9bbefSTejun Heo 87280b9bbefSTejun Heo static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry) 87380b9bbefSTejun Heo { 87480b9bbefSTejun Heo struct kernfs_node *kn = dentry->d_fsdata; 87590c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 87607c7530dSTejun Heo int ret; 87780b9bbefSTejun Heo 87890c07c89STejun Heo if (!scops || !scops->rmdir) 87980b9bbefSTejun Heo return -EPERM; 88080b9bbefSTejun Heo 88107c7530dSTejun Heo if (!kernfs_get_active(kn)) 88207c7530dSTejun Heo return -ENODEV; 88307c7530dSTejun Heo 88490c07c89STejun Heo ret = scops->rmdir(kn); 88507c7530dSTejun Heo 88607c7530dSTejun Heo kernfs_put_active(kn); 88707c7530dSTejun Heo return ret; 88880b9bbefSTejun Heo } 88980b9bbefSTejun Heo 89080b9bbefSTejun Heo static int kernfs_iop_rename(struct inode *old_dir, struct dentry *old_dentry, 89180b9bbefSTejun Heo struct inode *new_dir, struct dentry *new_dentry) 89280b9bbefSTejun Heo { 89380b9bbefSTejun Heo struct kernfs_node *kn = old_dentry->d_fsdata; 89480b9bbefSTejun Heo struct kernfs_node *new_parent = new_dir->i_private; 89590c07c89STejun Heo struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 89607c7530dSTejun Heo int ret; 89780b9bbefSTejun Heo 89890c07c89STejun Heo if (!scops || !scops->rename) 89980b9bbefSTejun Heo return -EPERM; 90080b9bbefSTejun Heo 90107c7530dSTejun Heo if (!kernfs_get_active(kn)) 90207c7530dSTejun Heo return -ENODEV; 90307c7530dSTejun Heo 90407c7530dSTejun Heo if (!kernfs_get_active(new_parent)) { 90507c7530dSTejun Heo kernfs_put_active(kn); 90607c7530dSTejun Heo return -ENODEV; 90707c7530dSTejun Heo } 90807c7530dSTejun Heo 90990c07c89STejun Heo ret = scops->rename(kn, new_parent, new_dentry->d_name.name); 91007c7530dSTejun Heo 91107c7530dSTejun Heo kernfs_put_active(new_parent); 91207c7530dSTejun Heo kernfs_put_active(kn); 91307c7530dSTejun Heo return ret; 91480b9bbefSTejun Heo } 91580b9bbefSTejun Heo 916a797bfc3STejun Heo const struct inode_operations kernfs_dir_iops = { 917c637b8acSTejun Heo .lookup = kernfs_iop_lookup, 918c637b8acSTejun Heo .permission = kernfs_iop_permission, 919c637b8acSTejun Heo .setattr = kernfs_iop_setattr, 920c637b8acSTejun Heo .getattr = kernfs_iop_getattr, 921c637b8acSTejun Heo .setxattr = kernfs_iop_setxattr, 922c637b8acSTejun Heo .removexattr = kernfs_iop_removexattr, 923c637b8acSTejun Heo .getxattr = kernfs_iop_getxattr, 924c637b8acSTejun Heo .listxattr = kernfs_iop_listxattr, 92580b9bbefSTejun Heo 92680b9bbefSTejun Heo .mkdir = kernfs_iop_mkdir, 92780b9bbefSTejun Heo .rmdir = kernfs_iop_rmdir, 92880b9bbefSTejun Heo .rename = kernfs_iop_rename, 929fd7b9f7bSTejun Heo }; 930fd7b9f7bSTejun Heo 931c637b8acSTejun Heo static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos) 932fd7b9f7bSTejun Heo { 933324a56e1STejun Heo struct kernfs_node *last; 934fd7b9f7bSTejun Heo 935fd7b9f7bSTejun Heo while (true) { 936fd7b9f7bSTejun Heo struct rb_node *rbn; 937fd7b9f7bSTejun Heo 938fd7b9f7bSTejun Heo last = pos; 939fd7b9f7bSTejun Heo 940df23fc39STejun Heo if (kernfs_type(pos) != KERNFS_DIR) 941fd7b9f7bSTejun Heo break; 942fd7b9f7bSTejun Heo 943adc5e8b5STejun Heo rbn = rb_first(&pos->dir.children); 944fd7b9f7bSTejun Heo if (!rbn) 945fd7b9f7bSTejun Heo break; 946fd7b9f7bSTejun Heo 947324a56e1STejun Heo pos = rb_to_kn(rbn); 948fd7b9f7bSTejun Heo } 949fd7b9f7bSTejun Heo 950fd7b9f7bSTejun Heo return last; 951fd7b9f7bSTejun Heo } 952fd7b9f7bSTejun Heo 953fd7b9f7bSTejun Heo /** 954c637b8acSTejun Heo * kernfs_next_descendant_post - find the next descendant for post-order walk 955fd7b9f7bSTejun Heo * @pos: the current position (%NULL to initiate traversal) 956324a56e1STejun Heo * @root: kernfs_node whose descendants to walk 957fd7b9f7bSTejun Heo * 958fd7b9f7bSTejun Heo * Find the next descendant to visit for post-order traversal of @root's 959fd7b9f7bSTejun Heo * descendants. @root is included in the iteration and the last node to be 960fd7b9f7bSTejun Heo * visited. 961fd7b9f7bSTejun Heo */ 962c637b8acSTejun Heo static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos, 963324a56e1STejun Heo struct kernfs_node *root) 964fd7b9f7bSTejun Heo { 965fd7b9f7bSTejun Heo struct rb_node *rbn; 966fd7b9f7bSTejun Heo 967a797bfc3STejun Heo lockdep_assert_held(&kernfs_mutex); 968fd7b9f7bSTejun Heo 969fd7b9f7bSTejun Heo /* if first iteration, visit leftmost descendant which may be root */ 970fd7b9f7bSTejun Heo if (!pos) 971c637b8acSTejun Heo return kernfs_leftmost_descendant(root); 972fd7b9f7bSTejun Heo 973fd7b9f7bSTejun Heo /* if we visited @root, we're done */ 974fd7b9f7bSTejun Heo if (pos == root) 975fd7b9f7bSTejun Heo return NULL; 976fd7b9f7bSTejun Heo 977fd7b9f7bSTejun Heo /* if there's an unvisited sibling, visit its leftmost descendant */ 978adc5e8b5STejun Heo rbn = rb_next(&pos->rb); 979fd7b9f7bSTejun Heo if (rbn) 980c637b8acSTejun Heo return kernfs_leftmost_descendant(rb_to_kn(rbn)); 981fd7b9f7bSTejun Heo 982fd7b9f7bSTejun Heo /* no sibling left, visit parent */ 983adc5e8b5STejun Heo return pos->parent; 984fd7b9f7bSTejun Heo } 985fd7b9f7bSTejun Heo 986d35258efSTejun Heo /** 987d35258efSTejun Heo * kernfs_activate - activate a node which started deactivated 988d35258efSTejun Heo * @kn: kernfs_node whose subtree is to be activated 989d35258efSTejun Heo * 990d35258efSTejun Heo * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node 991d35258efSTejun Heo * needs to be explicitly activated. A node which hasn't been activated 992d35258efSTejun Heo * isn't visible to userland and deactivation is skipped during its 993d35258efSTejun Heo * removal. This is useful to construct atomic init sequences where 994d35258efSTejun Heo * creation of multiple nodes should either succeed or fail atomically. 995d35258efSTejun Heo * 996d35258efSTejun Heo * The caller is responsible for ensuring that this function is not called 997d35258efSTejun Heo * after kernfs_remove*() is invoked on @kn. 998d35258efSTejun Heo */ 999d35258efSTejun Heo void kernfs_activate(struct kernfs_node *kn) 1000d35258efSTejun Heo { 1001d35258efSTejun Heo struct kernfs_node *pos; 1002d35258efSTejun Heo 1003d35258efSTejun Heo mutex_lock(&kernfs_mutex); 1004d35258efSTejun Heo 1005d35258efSTejun Heo pos = NULL; 1006d35258efSTejun Heo while ((pos = kernfs_next_descendant_post(pos, kn))) { 1007d35258efSTejun Heo if (!pos || (pos->flags & KERNFS_ACTIVATED)) 1008d35258efSTejun Heo continue; 1009d35258efSTejun Heo 1010d35258efSTejun Heo WARN_ON_ONCE(pos->parent && RB_EMPTY_NODE(&pos->rb)); 1011d35258efSTejun Heo WARN_ON_ONCE(atomic_read(&pos->active) != KN_DEACTIVATED_BIAS); 1012d35258efSTejun Heo 1013d35258efSTejun Heo atomic_sub(KN_DEACTIVATED_BIAS, &pos->active); 1014d35258efSTejun Heo pos->flags |= KERNFS_ACTIVATED; 1015d35258efSTejun Heo } 1016d35258efSTejun Heo 1017d35258efSTejun Heo mutex_unlock(&kernfs_mutex); 1018d35258efSTejun Heo } 1019d35258efSTejun Heo 1020988cd7afSTejun Heo static void __kernfs_remove(struct kernfs_node *kn) 1021fd7b9f7bSTejun Heo { 102235beab06STejun Heo struct kernfs_node *pos; 102335beab06STejun Heo 102435beab06STejun Heo lockdep_assert_held(&kernfs_mutex); 1025fd7b9f7bSTejun Heo 10266b0afc2aSTejun Heo /* 10276b0afc2aSTejun Heo * Short-circuit if non-root @kn has already finished removal. 10286b0afc2aSTejun Heo * This is for kernfs_remove_self() which plays with active ref 10296b0afc2aSTejun Heo * after removal. 10306b0afc2aSTejun Heo */ 10316b0afc2aSTejun Heo if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb))) 1032ce9b499cSGreg Kroah-Hartman return; 1033ce9b499cSGreg Kroah-Hartman 1034c637b8acSTejun Heo pr_debug("kernfs %s: removing\n", kn->name); 1035fd7b9f7bSTejun Heo 103681c173cbSTejun Heo /* prevent any new usage under @kn by deactivating all nodes */ 103735beab06STejun Heo pos = NULL; 103835beab06STejun Heo while ((pos = kernfs_next_descendant_post(pos, kn))) 103981c173cbSTejun Heo if (kernfs_active(pos)) 104081c173cbSTejun Heo atomic_add(KN_DEACTIVATED_BIAS, &pos->active); 104135beab06STejun Heo 104235beab06STejun Heo /* deactivate and unlink the subtree node-by-node */ 1043fd7b9f7bSTejun Heo do { 104435beab06STejun Heo pos = kernfs_leftmost_descendant(kn); 104535beab06STejun Heo 104635beab06STejun Heo /* 104781c173cbSTejun Heo * kernfs_drain() drops kernfs_mutex temporarily and @pos's 104881c173cbSTejun Heo * base ref could have been put by someone else by the time 104981c173cbSTejun Heo * the function returns. Make sure it doesn't go away 105081c173cbSTejun Heo * underneath us. 105135beab06STejun Heo */ 105235beab06STejun Heo kernfs_get(pos); 105335beab06STejun Heo 1054d35258efSTejun Heo /* 1055d35258efSTejun Heo * Drain iff @kn was activated. This avoids draining and 1056d35258efSTejun Heo * its lockdep annotations for nodes which have never been 1057d35258efSTejun Heo * activated and allows embedding kernfs_remove() in create 1058d35258efSTejun Heo * error paths without worrying about draining. 1059d35258efSTejun Heo */ 1060d35258efSTejun Heo if (kn->flags & KERNFS_ACTIVATED) 106181c173cbSTejun Heo kernfs_drain(pos); 1062d35258efSTejun Heo else 1063d35258efSTejun Heo WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS); 106435beab06STejun Heo 106535beab06STejun Heo /* 106635beab06STejun Heo * kernfs_unlink_sibling() succeeds once per node. Use it 106735beab06STejun Heo * to decide who's responsible for cleanups. 106835beab06STejun Heo */ 106935beab06STejun Heo if (!pos->parent || kernfs_unlink_sibling(pos)) { 107035beab06STejun Heo struct kernfs_iattrs *ps_iattr = 107135beab06STejun Heo pos->parent ? pos->parent->iattr : NULL; 107235beab06STejun Heo 107335beab06STejun Heo /* update timestamps on the parent */ 107435beab06STejun Heo if (ps_iattr) { 107535beab06STejun Heo ps_iattr->ia_iattr.ia_ctime = CURRENT_TIME; 107635beab06STejun Heo ps_iattr->ia_iattr.ia_mtime = CURRENT_TIME; 107735beab06STejun Heo } 107835beab06STejun Heo 1079988cd7afSTejun Heo kernfs_put(pos); 108035beab06STejun Heo } 108135beab06STejun Heo 108235beab06STejun Heo kernfs_put(pos); 108335beab06STejun Heo } while (pos != kn); 1084fd7b9f7bSTejun Heo } 1085fd7b9f7bSTejun Heo 1086fd7b9f7bSTejun Heo /** 1087324a56e1STejun Heo * kernfs_remove - remove a kernfs_node recursively 1088324a56e1STejun Heo * @kn: the kernfs_node to remove 1089fd7b9f7bSTejun Heo * 1090324a56e1STejun Heo * Remove @kn along with all its subdirectories and files. 1091fd7b9f7bSTejun Heo */ 1092324a56e1STejun Heo void kernfs_remove(struct kernfs_node *kn) 1093fd7b9f7bSTejun Heo { 1094988cd7afSTejun Heo mutex_lock(&kernfs_mutex); 1095988cd7afSTejun Heo __kernfs_remove(kn); 1096988cd7afSTejun Heo mutex_unlock(&kernfs_mutex); 1097fd7b9f7bSTejun Heo } 1098fd7b9f7bSTejun Heo 1099fd7b9f7bSTejun Heo /** 11006b0afc2aSTejun Heo * kernfs_break_active_protection - break out of active protection 11016b0afc2aSTejun Heo * @kn: the self kernfs_node 11026b0afc2aSTejun Heo * 11036b0afc2aSTejun Heo * The caller must be running off of a kernfs operation which is invoked 11046b0afc2aSTejun Heo * with an active reference - e.g. one of kernfs_ops. Each invocation of 11056b0afc2aSTejun Heo * this function must also be matched with an invocation of 11066b0afc2aSTejun Heo * kernfs_unbreak_active_protection(). 11076b0afc2aSTejun Heo * 11086b0afc2aSTejun Heo * This function releases the active reference of @kn the caller is 11096b0afc2aSTejun Heo * holding. Once this function is called, @kn may be removed at any point 11106b0afc2aSTejun Heo * and the caller is solely responsible for ensuring that the objects it 11116b0afc2aSTejun Heo * dereferences are accessible. 11126b0afc2aSTejun Heo */ 11136b0afc2aSTejun Heo void kernfs_break_active_protection(struct kernfs_node *kn) 11146b0afc2aSTejun Heo { 11156b0afc2aSTejun Heo /* 11166b0afc2aSTejun Heo * Take out ourself out of the active ref dependency chain. If 11176b0afc2aSTejun Heo * we're called without an active ref, lockdep will complain. 11186b0afc2aSTejun Heo */ 11196b0afc2aSTejun Heo kernfs_put_active(kn); 11206b0afc2aSTejun Heo } 11216b0afc2aSTejun Heo 11226b0afc2aSTejun Heo /** 11236b0afc2aSTejun Heo * kernfs_unbreak_active_protection - undo kernfs_break_active_protection() 11246b0afc2aSTejun Heo * @kn: the self kernfs_node 11256b0afc2aSTejun Heo * 11266b0afc2aSTejun Heo * If kernfs_break_active_protection() was called, this function must be 11276b0afc2aSTejun Heo * invoked before finishing the kernfs operation. Note that while this 11286b0afc2aSTejun Heo * function restores the active reference, it doesn't and can't actually 11296b0afc2aSTejun Heo * restore the active protection - @kn may already or be in the process of 11306b0afc2aSTejun Heo * being removed. Once kernfs_break_active_protection() is invoked, that 11316b0afc2aSTejun Heo * protection is irreversibly gone for the kernfs operation instance. 11326b0afc2aSTejun Heo * 11336b0afc2aSTejun Heo * While this function may be called at any point after 11346b0afc2aSTejun Heo * kernfs_break_active_protection() is invoked, its most useful location 11356b0afc2aSTejun Heo * would be right before the enclosing kernfs operation returns. 11366b0afc2aSTejun Heo */ 11376b0afc2aSTejun Heo void kernfs_unbreak_active_protection(struct kernfs_node *kn) 11386b0afc2aSTejun Heo { 11396b0afc2aSTejun Heo /* 11406b0afc2aSTejun Heo * @kn->active could be in any state; however, the increment we do 11416b0afc2aSTejun Heo * here will be undone as soon as the enclosing kernfs operation 11426b0afc2aSTejun Heo * finishes and this temporary bump can't break anything. If @kn 11436b0afc2aSTejun Heo * is alive, nothing changes. If @kn is being deactivated, the 11446b0afc2aSTejun Heo * soon-to-follow put will either finish deactivation or restore 11456b0afc2aSTejun Heo * deactivated state. If @kn is already removed, the temporary 11466b0afc2aSTejun Heo * bump is guaranteed to be gone before @kn is released. 11476b0afc2aSTejun Heo */ 11486b0afc2aSTejun Heo atomic_inc(&kn->active); 11496b0afc2aSTejun Heo if (kernfs_lockdep(kn)) 11506b0afc2aSTejun Heo rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_); 11516b0afc2aSTejun Heo } 11526b0afc2aSTejun Heo 11536b0afc2aSTejun Heo /** 11546b0afc2aSTejun Heo * kernfs_remove_self - remove a kernfs_node from its own method 11556b0afc2aSTejun Heo * @kn: the self kernfs_node to remove 11566b0afc2aSTejun Heo * 11576b0afc2aSTejun Heo * The caller must be running off of a kernfs operation which is invoked 11586b0afc2aSTejun Heo * with an active reference - e.g. one of kernfs_ops. This can be used to 11596b0afc2aSTejun Heo * implement a file operation which deletes itself. 11606b0afc2aSTejun Heo * 11616b0afc2aSTejun Heo * For example, the "delete" file for a sysfs device directory can be 11626b0afc2aSTejun Heo * implemented by invoking kernfs_remove_self() on the "delete" file 11636b0afc2aSTejun Heo * itself. This function breaks the circular dependency of trying to 11646b0afc2aSTejun Heo * deactivate self while holding an active ref itself. It isn't necessary 11656b0afc2aSTejun Heo * to modify the usual removal path to use kernfs_remove_self(). The 11666b0afc2aSTejun Heo * "delete" implementation can simply invoke kernfs_remove_self() on self 11676b0afc2aSTejun Heo * before proceeding with the usual removal path. kernfs will ignore later 11686b0afc2aSTejun Heo * kernfs_remove() on self. 11696b0afc2aSTejun Heo * 11706b0afc2aSTejun Heo * kernfs_remove_self() can be called multiple times concurrently on the 11716b0afc2aSTejun Heo * same kernfs_node. Only the first one actually performs removal and 11726b0afc2aSTejun Heo * returns %true. All others will wait until the kernfs operation which 11736b0afc2aSTejun Heo * won self-removal finishes and return %false. Note that the losers wait 11746b0afc2aSTejun Heo * for the completion of not only the winning kernfs_remove_self() but also 11756b0afc2aSTejun Heo * the whole kernfs_ops which won the arbitration. This can be used to 11766b0afc2aSTejun Heo * guarantee, for example, all concurrent writes to a "delete" file to 11776b0afc2aSTejun Heo * finish only after the whole operation is complete. 11786b0afc2aSTejun Heo */ 11796b0afc2aSTejun Heo bool kernfs_remove_self(struct kernfs_node *kn) 11806b0afc2aSTejun Heo { 11816b0afc2aSTejun Heo bool ret; 11826b0afc2aSTejun Heo 11836b0afc2aSTejun Heo mutex_lock(&kernfs_mutex); 11846b0afc2aSTejun Heo kernfs_break_active_protection(kn); 11856b0afc2aSTejun Heo 11866b0afc2aSTejun Heo /* 11876b0afc2aSTejun Heo * SUICIDAL is used to arbitrate among competing invocations. Only 11886b0afc2aSTejun Heo * the first one will actually perform removal. When the removal 11896b0afc2aSTejun Heo * is complete, SUICIDED is set and the active ref is restored 11906b0afc2aSTejun Heo * while holding kernfs_mutex. The ones which lost arbitration 11916b0afc2aSTejun Heo * waits for SUICDED && drained which can happen only after the 11926b0afc2aSTejun Heo * enclosing kernfs operation which executed the winning instance 11936b0afc2aSTejun Heo * of kernfs_remove_self() finished. 11946b0afc2aSTejun Heo */ 11956b0afc2aSTejun Heo if (!(kn->flags & KERNFS_SUICIDAL)) { 11966b0afc2aSTejun Heo kn->flags |= KERNFS_SUICIDAL; 11976b0afc2aSTejun Heo __kernfs_remove(kn); 11986b0afc2aSTejun Heo kn->flags |= KERNFS_SUICIDED; 11996b0afc2aSTejun Heo ret = true; 12006b0afc2aSTejun Heo } else { 12016b0afc2aSTejun Heo wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq; 12026b0afc2aSTejun Heo DEFINE_WAIT(wait); 12036b0afc2aSTejun Heo 12046b0afc2aSTejun Heo while (true) { 12056b0afc2aSTejun Heo prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE); 12066b0afc2aSTejun Heo 12076b0afc2aSTejun Heo if ((kn->flags & KERNFS_SUICIDED) && 12086b0afc2aSTejun Heo atomic_read(&kn->active) == KN_DEACTIVATED_BIAS) 12096b0afc2aSTejun Heo break; 12106b0afc2aSTejun Heo 12116b0afc2aSTejun Heo mutex_unlock(&kernfs_mutex); 12126b0afc2aSTejun Heo schedule(); 12136b0afc2aSTejun Heo mutex_lock(&kernfs_mutex); 12146b0afc2aSTejun Heo } 12156b0afc2aSTejun Heo finish_wait(waitq, &wait); 12166b0afc2aSTejun Heo WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb)); 12176b0afc2aSTejun Heo ret = false; 12186b0afc2aSTejun Heo } 12196b0afc2aSTejun Heo 12206b0afc2aSTejun Heo /* 12216b0afc2aSTejun Heo * This must be done while holding kernfs_mutex; otherwise, waiting 12226b0afc2aSTejun Heo * for SUICIDED && deactivated could finish prematurely. 12236b0afc2aSTejun Heo */ 12246b0afc2aSTejun Heo kernfs_unbreak_active_protection(kn); 12256b0afc2aSTejun Heo 12266b0afc2aSTejun Heo mutex_unlock(&kernfs_mutex); 12276b0afc2aSTejun Heo return ret; 12286b0afc2aSTejun Heo } 12296b0afc2aSTejun Heo 12306b0afc2aSTejun Heo /** 1231324a56e1STejun Heo * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it 1232324a56e1STejun Heo * @parent: parent of the target 1233324a56e1STejun Heo * @name: name of the kernfs_node to remove 1234324a56e1STejun Heo * @ns: namespace tag of the kernfs_node to remove 1235fd7b9f7bSTejun Heo * 1236324a56e1STejun Heo * Look for the kernfs_node with @name and @ns under @parent and remove it. 1237324a56e1STejun Heo * Returns 0 on success, -ENOENT if such entry doesn't exist. 1238fd7b9f7bSTejun Heo */ 1239324a56e1STejun Heo int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 1240fd7b9f7bSTejun Heo const void *ns) 1241fd7b9f7bSTejun Heo { 1242324a56e1STejun Heo struct kernfs_node *kn; 1243fd7b9f7bSTejun Heo 1244324a56e1STejun Heo if (!parent) { 1245c637b8acSTejun Heo WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n", 1246fd7b9f7bSTejun Heo name); 1247fd7b9f7bSTejun Heo return -ENOENT; 1248fd7b9f7bSTejun Heo } 1249fd7b9f7bSTejun Heo 1250988cd7afSTejun Heo mutex_lock(&kernfs_mutex); 1251fd7b9f7bSTejun Heo 1252324a56e1STejun Heo kn = kernfs_find_ns(parent, name, ns); 1253324a56e1STejun Heo if (kn) 1254988cd7afSTejun Heo __kernfs_remove(kn); 1255fd7b9f7bSTejun Heo 1256988cd7afSTejun Heo mutex_unlock(&kernfs_mutex); 1257fd7b9f7bSTejun Heo 1258324a56e1STejun Heo if (kn) 1259fd7b9f7bSTejun Heo return 0; 1260fd7b9f7bSTejun Heo else 1261fd7b9f7bSTejun Heo return -ENOENT; 1262fd7b9f7bSTejun Heo } 1263fd7b9f7bSTejun Heo 1264fd7b9f7bSTejun Heo /** 1265fd7b9f7bSTejun Heo * kernfs_rename_ns - move and rename a kernfs_node 1266324a56e1STejun Heo * @kn: target node 1267fd7b9f7bSTejun Heo * @new_parent: new parent to put @sd under 1268fd7b9f7bSTejun Heo * @new_name: new name 1269fd7b9f7bSTejun Heo * @new_ns: new namespace tag 1270fd7b9f7bSTejun Heo */ 1271324a56e1STejun Heo int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 1272fd7b9f7bSTejun Heo const char *new_name, const void *new_ns) 1273fd7b9f7bSTejun Heo { 12743eef34adSTejun Heo struct kernfs_node *old_parent; 12753eef34adSTejun Heo const char *old_name = NULL; 1276fd7b9f7bSTejun Heo int error; 1277fd7b9f7bSTejun Heo 12783eef34adSTejun Heo /* can't move or rename root */ 12793eef34adSTejun Heo if (!kn->parent) 12803eef34adSTejun Heo return -EINVAL; 12813eef34adSTejun Heo 1282ae34372eSTejun Heo mutex_lock(&kernfs_mutex); 1283d0ae3d43STejun Heo 1284798c75a0SGreg Kroah-Hartman error = -ENOENT; 1285ea015218SEric W. Biederman if (!kernfs_active(kn) || !kernfs_active(new_parent) || 1286ea015218SEric W. Biederman (new_parent->flags & KERNFS_EMPTY_DIR)) 1287798c75a0SGreg Kroah-Hartman goto out; 1288798c75a0SGreg Kroah-Hartman 1289fd7b9f7bSTejun Heo error = 0; 1290adc5e8b5STejun Heo if ((kn->parent == new_parent) && (kn->ns == new_ns) && 1291adc5e8b5STejun Heo (strcmp(kn->name, new_name) == 0)) 1292798c75a0SGreg Kroah-Hartman goto out; /* nothing to rename */ 1293fd7b9f7bSTejun Heo 1294fd7b9f7bSTejun Heo error = -EEXIST; 1295fd7b9f7bSTejun Heo if (kernfs_find_ns(new_parent, new_name, new_ns)) 1296798c75a0SGreg Kroah-Hartman goto out; 1297fd7b9f7bSTejun Heo 1298324a56e1STejun Heo /* rename kernfs_node */ 1299adc5e8b5STejun Heo if (strcmp(kn->name, new_name) != 0) { 1300fd7b9f7bSTejun Heo error = -ENOMEM; 130175287a67SAndrzej Hajda new_name = kstrdup_const(new_name, GFP_KERNEL); 1302fd7b9f7bSTejun Heo if (!new_name) 1303798c75a0SGreg Kroah-Hartman goto out; 13043eef34adSTejun Heo } else { 13053eef34adSTejun Heo new_name = NULL; 1306fd7b9f7bSTejun Heo } 1307fd7b9f7bSTejun Heo 1308fd7b9f7bSTejun Heo /* 1309fd7b9f7bSTejun Heo * Move to the appropriate place in the appropriate directories rbtree. 1310fd7b9f7bSTejun Heo */ 1311c637b8acSTejun Heo kernfs_unlink_sibling(kn); 1312fd7b9f7bSTejun Heo kernfs_get(new_parent); 13133eef34adSTejun Heo 13143eef34adSTejun Heo /* rename_lock protects ->parent and ->name accessors */ 13153eef34adSTejun Heo spin_lock_irq(&kernfs_rename_lock); 13163eef34adSTejun Heo 13173eef34adSTejun Heo old_parent = kn->parent; 1318adc5e8b5STejun Heo kn->parent = new_parent; 13193eef34adSTejun Heo 13203eef34adSTejun Heo kn->ns = new_ns; 13213eef34adSTejun Heo if (new_name) { 13223eef34adSTejun Heo old_name = kn->name; 13233eef34adSTejun Heo kn->name = new_name; 13243eef34adSTejun Heo } 13253eef34adSTejun Heo 13263eef34adSTejun Heo spin_unlock_irq(&kernfs_rename_lock); 13273eef34adSTejun Heo 13289561a896STejun Heo kn->hash = kernfs_name_hash(kn->name, kn->ns); 1329c637b8acSTejun Heo kernfs_link_sibling(kn); 1330fd7b9f7bSTejun Heo 13313eef34adSTejun Heo kernfs_put(old_parent); 133275287a67SAndrzej Hajda kfree_const(old_name); 13333eef34adSTejun Heo 1334fd7b9f7bSTejun Heo error = 0; 1335ae34372eSTejun Heo out: 1336798c75a0SGreg Kroah-Hartman mutex_unlock(&kernfs_mutex); 1337fd7b9f7bSTejun Heo return error; 1338fd7b9f7bSTejun Heo } 1339fd7b9f7bSTejun Heo 1340fd7b9f7bSTejun Heo /* Relationship between s_mode and the DT_xxx types */ 1341324a56e1STejun Heo static inline unsigned char dt_type(struct kernfs_node *kn) 1342fd7b9f7bSTejun Heo { 1343adc5e8b5STejun Heo return (kn->mode >> 12) & 15; 1344fd7b9f7bSTejun Heo } 1345fd7b9f7bSTejun Heo 1346c637b8acSTejun Heo static int kernfs_dir_fop_release(struct inode *inode, struct file *filp) 1347fd7b9f7bSTejun Heo { 1348fd7b9f7bSTejun Heo kernfs_put(filp->private_data); 1349fd7b9f7bSTejun Heo return 0; 1350fd7b9f7bSTejun Heo } 1351fd7b9f7bSTejun Heo 1352c637b8acSTejun Heo static struct kernfs_node *kernfs_dir_pos(const void *ns, 1353324a56e1STejun Heo struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos) 1354fd7b9f7bSTejun Heo { 1355fd7b9f7bSTejun Heo if (pos) { 135681c173cbSTejun Heo int valid = kernfs_active(pos) && 1357798c75a0SGreg Kroah-Hartman pos->parent == parent && hash == pos->hash; 1358fd7b9f7bSTejun Heo kernfs_put(pos); 1359fd7b9f7bSTejun Heo if (!valid) 1360fd7b9f7bSTejun Heo pos = NULL; 1361fd7b9f7bSTejun Heo } 1362fd7b9f7bSTejun Heo if (!pos && (hash > 1) && (hash < INT_MAX)) { 1363adc5e8b5STejun Heo struct rb_node *node = parent->dir.children.rb_node; 1364fd7b9f7bSTejun Heo while (node) { 1365324a56e1STejun Heo pos = rb_to_kn(node); 1366fd7b9f7bSTejun Heo 1367adc5e8b5STejun Heo if (hash < pos->hash) 1368fd7b9f7bSTejun Heo node = node->rb_left; 1369adc5e8b5STejun Heo else if (hash > pos->hash) 1370fd7b9f7bSTejun Heo node = node->rb_right; 1371fd7b9f7bSTejun Heo else 1372fd7b9f7bSTejun Heo break; 1373fd7b9f7bSTejun Heo } 1374fd7b9f7bSTejun Heo } 1375b9c9dad0STejun Heo /* Skip over entries which are dying/dead or in the wrong namespace */ 1376b9c9dad0STejun Heo while (pos && (!kernfs_active(pos) || pos->ns != ns)) { 1377adc5e8b5STejun Heo struct rb_node *node = rb_next(&pos->rb); 1378fd7b9f7bSTejun Heo if (!node) 1379fd7b9f7bSTejun Heo pos = NULL; 1380fd7b9f7bSTejun Heo else 1381324a56e1STejun Heo pos = rb_to_kn(node); 1382fd7b9f7bSTejun Heo } 1383fd7b9f7bSTejun Heo return pos; 1384fd7b9f7bSTejun Heo } 1385fd7b9f7bSTejun Heo 1386c637b8acSTejun Heo static struct kernfs_node *kernfs_dir_next_pos(const void *ns, 1387324a56e1STejun Heo struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos) 1388fd7b9f7bSTejun Heo { 1389c637b8acSTejun Heo pos = kernfs_dir_pos(ns, parent, ino, pos); 1390b9c9dad0STejun Heo if (pos) { 1391fd7b9f7bSTejun Heo do { 1392adc5e8b5STejun Heo struct rb_node *node = rb_next(&pos->rb); 1393fd7b9f7bSTejun Heo if (!node) 1394fd7b9f7bSTejun Heo pos = NULL; 1395fd7b9f7bSTejun Heo else 1396324a56e1STejun Heo pos = rb_to_kn(node); 1397b9c9dad0STejun Heo } while (pos && (!kernfs_active(pos) || pos->ns != ns)); 1398b9c9dad0STejun Heo } 1399fd7b9f7bSTejun Heo return pos; 1400fd7b9f7bSTejun Heo } 1401fd7b9f7bSTejun Heo 1402c637b8acSTejun Heo static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx) 1403fd7b9f7bSTejun Heo { 1404fd7b9f7bSTejun Heo struct dentry *dentry = file->f_path.dentry; 1405324a56e1STejun Heo struct kernfs_node *parent = dentry->d_fsdata; 1406324a56e1STejun Heo struct kernfs_node *pos = file->private_data; 1407fd7b9f7bSTejun Heo const void *ns = NULL; 1408fd7b9f7bSTejun Heo 1409fd7b9f7bSTejun Heo if (!dir_emit_dots(file, ctx)) 1410fd7b9f7bSTejun Heo return 0; 1411a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 1412fd7b9f7bSTejun Heo 1413324a56e1STejun Heo if (kernfs_ns_enabled(parent)) 1414c525aaddSTejun Heo ns = kernfs_info(dentry->d_sb)->ns; 1415fd7b9f7bSTejun Heo 1416c637b8acSTejun Heo for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos); 1417fd7b9f7bSTejun Heo pos; 1418c637b8acSTejun Heo pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) { 1419adc5e8b5STejun Heo const char *name = pos->name; 1420fd7b9f7bSTejun Heo unsigned int type = dt_type(pos); 1421fd7b9f7bSTejun Heo int len = strlen(name); 1422adc5e8b5STejun Heo ino_t ino = pos->ino; 1423fd7b9f7bSTejun Heo 1424adc5e8b5STejun Heo ctx->pos = pos->hash; 1425fd7b9f7bSTejun Heo file->private_data = pos; 1426fd7b9f7bSTejun Heo kernfs_get(pos); 1427fd7b9f7bSTejun Heo 1428a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 1429fd7b9f7bSTejun Heo if (!dir_emit(ctx, name, len, ino, type)) 1430fd7b9f7bSTejun Heo return 0; 1431a797bfc3STejun Heo mutex_lock(&kernfs_mutex); 1432fd7b9f7bSTejun Heo } 1433a797bfc3STejun Heo mutex_unlock(&kernfs_mutex); 1434fd7b9f7bSTejun Heo file->private_data = NULL; 1435fd7b9f7bSTejun Heo ctx->pos = INT_MAX; 1436fd7b9f7bSTejun Heo return 0; 1437fd7b9f7bSTejun Heo } 1438fd7b9f7bSTejun Heo 1439c637b8acSTejun Heo static loff_t kernfs_dir_fop_llseek(struct file *file, loff_t offset, 1440c637b8acSTejun Heo int whence) 1441fd7b9f7bSTejun Heo { 1442fd7b9f7bSTejun Heo struct inode *inode = file_inode(file); 1443fd7b9f7bSTejun Heo loff_t ret; 1444fd7b9f7bSTejun Heo 1445fd7b9f7bSTejun Heo mutex_lock(&inode->i_mutex); 1446fd7b9f7bSTejun Heo ret = generic_file_llseek(file, offset, whence); 1447fd7b9f7bSTejun Heo mutex_unlock(&inode->i_mutex); 1448fd7b9f7bSTejun Heo 1449fd7b9f7bSTejun Heo return ret; 1450fd7b9f7bSTejun Heo } 1451fd7b9f7bSTejun Heo 1452a797bfc3STejun Heo const struct file_operations kernfs_dir_fops = { 1453fd7b9f7bSTejun Heo .read = generic_read_dir, 1454c637b8acSTejun Heo .iterate = kernfs_fop_readdir, 1455c637b8acSTejun Heo .release = kernfs_dir_fop_release, 1456c637b8acSTejun Heo .llseek = kernfs_dir_fop_llseek, 1457fd7b9f7bSTejun Heo }; 1458