1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * fs/kernfs/dir.c - kernfs directory implementation 4 * 5 * Copyright (c) 2001-3 Patrick Mochel 6 * Copyright (c) 2007 SUSE Linux Products GmbH 7 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> 8 */ 9 10 #include <linux/sched.h> 11 #include <linux/fs.h> 12 #include <linux/namei.h> 13 #include <linux/idr.h> 14 #include <linux/slab.h> 15 #include <linux/security.h> 16 #include <linux/hash.h> 17 18 #include "kernfs-internal.h" 19 20 static DEFINE_SPINLOCK(kernfs_rename_lock); /* kn->parent and ->name */ 21 /* 22 * Don't use rename_lock to piggy back on pr_cont_buf. We don't want to 23 * call pr_cont() while holding rename_lock. Because sometimes pr_cont() 24 * will perform wakeups when releasing console_sem. Holding rename_lock 25 * will introduce deadlock if the scheduler reads the kernfs_name in the 26 * wakeup path. 27 */ 28 static DEFINE_SPINLOCK(kernfs_pr_cont_lock); 29 static char kernfs_pr_cont_buf[PATH_MAX]; /* protected by pr_cont_lock */ 30 static DEFINE_SPINLOCK(kernfs_idr_lock); /* root->ino_idr */ 31 32 #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb) 33 34 static bool __kernfs_active(struct kernfs_node *kn) 35 { 36 return atomic_read(&kn->active) >= 0; 37 } 38 39 static bool kernfs_active(struct kernfs_node *kn) 40 { 41 lockdep_assert_held(&kernfs_root(kn)->kernfs_rwsem); 42 return __kernfs_active(kn); 43 } 44 45 static bool kernfs_lockdep(struct kernfs_node *kn) 46 { 47 #ifdef CONFIG_DEBUG_LOCK_ALLOC 48 return kn->flags & KERNFS_LOCKDEP; 49 #else 50 return false; 51 #endif 52 } 53 54 static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen) 55 { 56 if (!kn) 57 return strlcpy(buf, "(null)", buflen); 58 59 return strlcpy(buf, kn->parent ? kn->name : "/", buflen); 60 } 61 62 /* kernfs_node_depth - compute depth from @from to @to */ 63 static size_t kernfs_depth(struct kernfs_node *from, struct kernfs_node *to) 64 { 65 size_t depth = 0; 66 67 while (to->parent && to != from) { 68 depth++; 69 to = to->parent; 70 } 71 return depth; 72 } 73 74 static struct kernfs_node *kernfs_common_ancestor(struct kernfs_node *a, 75 struct kernfs_node *b) 76 { 77 size_t da, db; 78 struct kernfs_root *ra = kernfs_root(a), *rb = kernfs_root(b); 79 80 if (ra != rb) 81 return NULL; 82 83 da = kernfs_depth(ra->kn, a); 84 db = kernfs_depth(rb->kn, b); 85 86 while (da > db) { 87 a = a->parent; 88 da--; 89 } 90 while (db > da) { 91 b = b->parent; 92 db--; 93 } 94 95 /* worst case b and a will be the same at root */ 96 while (b != a) { 97 b = b->parent; 98 a = a->parent; 99 } 100 101 return a; 102 } 103 104 /** 105 * kernfs_path_from_node_locked - find a pseudo-absolute path to @kn_to, 106 * where kn_from is treated as root of the path. 107 * @kn_from: kernfs node which should be treated as root for the path 108 * @kn_to: kernfs node to which path is needed 109 * @buf: buffer to copy the path into 110 * @buflen: size of @buf 111 * 112 * We need to handle couple of scenarios here: 113 * [1] when @kn_from is an ancestor of @kn_to at some level 114 * kn_from: /n1/n2/n3 115 * kn_to: /n1/n2/n3/n4/n5 116 * result: /n4/n5 117 * 118 * [2] when @kn_from is on a different hierarchy and we need to find common 119 * ancestor between @kn_from and @kn_to. 120 * kn_from: /n1/n2/n3/n4 121 * kn_to: /n1/n2/n5 122 * result: /../../n5 123 * OR 124 * kn_from: /n1/n2/n3/n4/n5 [depth=5] 125 * kn_to: /n1/n2/n3 [depth=3] 126 * result: /../.. 127 * 128 * [3] when @kn_to is NULL result will be "(null)" 129 * 130 * Returns the length of the full path. If the full length is equal to or 131 * greater than @buflen, @buf contains the truncated path with the trailing 132 * '\0'. On error, -errno is returned. 133 */ 134 static int kernfs_path_from_node_locked(struct kernfs_node *kn_to, 135 struct kernfs_node *kn_from, 136 char *buf, size_t buflen) 137 { 138 struct kernfs_node *kn, *common; 139 const char parent_str[] = "/.."; 140 size_t depth_from, depth_to, len = 0; 141 int i, j; 142 143 if (!kn_to) 144 return strlcpy(buf, "(null)", buflen); 145 146 if (!kn_from) 147 kn_from = kernfs_root(kn_to)->kn; 148 149 if (kn_from == kn_to) 150 return strlcpy(buf, "/", buflen); 151 152 if (!buf) 153 return -EINVAL; 154 155 common = kernfs_common_ancestor(kn_from, kn_to); 156 if (WARN_ON(!common)) 157 return -EINVAL; 158 159 depth_to = kernfs_depth(common, kn_to); 160 depth_from = kernfs_depth(common, kn_from); 161 162 buf[0] = '\0'; 163 164 for (i = 0; i < depth_from; i++) 165 len += strlcpy(buf + len, parent_str, 166 len < buflen ? buflen - len : 0); 167 168 /* Calculate how many bytes we need for the rest */ 169 for (i = depth_to - 1; i >= 0; i--) { 170 for (kn = kn_to, j = 0; j < i; j++) 171 kn = kn->parent; 172 len += strlcpy(buf + len, "/", 173 len < buflen ? buflen - len : 0); 174 len += strlcpy(buf + len, kn->name, 175 len < buflen ? buflen - len : 0); 176 } 177 178 return len; 179 } 180 181 /** 182 * kernfs_name - obtain the name of a given node 183 * @kn: kernfs_node of interest 184 * @buf: buffer to copy @kn's name into 185 * @buflen: size of @buf 186 * 187 * Copies the name of @kn into @buf of @buflen bytes. The behavior is 188 * similar to strlcpy(). It returns the length of @kn's name and if @buf 189 * isn't long enough, it's filled upto @buflen-1 and nul terminated. 190 * 191 * Fills buffer with "(null)" if @kn is NULL. 192 * 193 * This function can be called from any context. 194 */ 195 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 196 { 197 unsigned long flags; 198 int ret; 199 200 spin_lock_irqsave(&kernfs_rename_lock, flags); 201 ret = kernfs_name_locked(kn, buf, buflen); 202 spin_unlock_irqrestore(&kernfs_rename_lock, flags); 203 return ret; 204 } 205 206 /** 207 * kernfs_path_from_node - build path of node @to relative to @from. 208 * @from: parent kernfs_node relative to which we need to build the path 209 * @to: kernfs_node of interest 210 * @buf: buffer to copy @to's path into 211 * @buflen: size of @buf 212 * 213 * Builds @to's path relative to @from in @buf. @from and @to must 214 * be on the same kernfs-root. If @from is not parent of @to, then a relative 215 * path (which includes '..'s) as needed to reach from @from to @to is 216 * returned. 217 * 218 * Returns the length of the full path. If the full length is equal to or 219 * greater than @buflen, @buf contains the truncated path with the trailing 220 * '\0'. On error, -errno is returned. 221 */ 222 int kernfs_path_from_node(struct kernfs_node *to, struct kernfs_node *from, 223 char *buf, size_t buflen) 224 { 225 unsigned long flags; 226 int ret; 227 228 spin_lock_irqsave(&kernfs_rename_lock, flags); 229 ret = kernfs_path_from_node_locked(to, from, buf, buflen); 230 spin_unlock_irqrestore(&kernfs_rename_lock, flags); 231 return ret; 232 } 233 EXPORT_SYMBOL_GPL(kernfs_path_from_node); 234 235 /** 236 * pr_cont_kernfs_name - pr_cont name of a kernfs_node 237 * @kn: kernfs_node of interest 238 * 239 * This function can be called from any context. 240 */ 241 void pr_cont_kernfs_name(struct kernfs_node *kn) 242 { 243 unsigned long flags; 244 245 spin_lock_irqsave(&kernfs_pr_cont_lock, flags); 246 247 kernfs_name(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf)); 248 pr_cont("%s", kernfs_pr_cont_buf); 249 250 spin_unlock_irqrestore(&kernfs_pr_cont_lock, flags); 251 } 252 253 /** 254 * pr_cont_kernfs_path - pr_cont path of a kernfs_node 255 * @kn: kernfs_node of interest 256 * 257 * This function can be called from any context. 258 */ 259 void pr_cont_kernfs_path(struct kernfs_node *kn) 260 { 261 unsigned long flags; 262 int sz; 263 264 spin_lock_irqsave(&kernfs_pr_cont_lock, flags); 265 266 sz = kernfs_path_from_node(kn, NULL, kernfs_pr_cont_buf, 267 sizeof(kernfs_pr_cont_buf)); 268 if (sz < 0) { 269 pr_cont("(error)"); 270 goto out; 271 } 272 273 if (sz >= sizeof(kernfs_pr_cont_buf)) { 274 pr_cont("(name too long)"); 275 goto out; 276 } 277 278 pr_cont("%s", kernfs_pr_cont_buf); 279 280 out: 281 spin_unlock_irqrestore(&kernfs_pr_cont_lock, flags); 282 } 283 284 /** 285 * kernfs_get_parent - determine the parent node and pin it 286 * @kn: kernfs_node of interest 287 * 288 * Determines @kn's parent, pins and returns it. This function can be 289 * called from any context. 290 */ 291 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 292 { 293 struct kernfs_node *parent; 294 unsigned long flags; 295 296 spin_lock_irqsave(&kernfs_rename_lock, flags); 297 parent = kn->parent; 298 kernfs_get(parent); 299 spin_unlock_irqrestore(&kernfs_rename_lock, flags); 300 301 return parent; 302 } 303 304 /** 305 * kernfs_name_hash 306 * @name: Null terminated string to hash 307 * @ns: Namespace tag to hash 308 * 309 * Returns 31 bit hash of ns + name (so it fits in an off_t ) 310 */ 311 static unsigned int kernfs_name_hash(const char *name, const void *ns) 312 { 313 unsigned long hash = init_name_hash(ns); 314 unsigned int len = strlen(name); 315 while (len--) 316 hash = partial_name_hash(*name++, hash); 317 hash = end_name_hash(hash); 318 hash &= 0x7fffffffU; 319 /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */ 320 if (hash < 2) 321 hash += 2; 322 if (hash >= INT_MAX) 323 hash = INT_MAX - 1; 324 return hash; 325 } 326 327 static int kernfs_name_compare(unsigned int hash, const char *name, 328 const void *ns, const struct kernfs_node *kn) 329 { 330 if (hash < kn->hash) 331 return -1; 332 if (hash > kn->hash) 333 return 1; 334 if (ns < kn->ns) 335 return -1; 336 if (ns > kn->ns) 337 return 1; 338 return strcmp(name, kn->name); 339 } 340 341 static int kernfs_sd_compare(const struct kernfs_node *left, 342 const struct kernfs_node *right) 343 { 344 return kernfs_name_compare(left->hash, left->name, left->ns, right); 345 } 346 347 /** 348 * kernfs_link_sibling - link kernfs_node into sibling rbtree 349 * @kn: kernfs_node of interest 350 * 351 * Link @kn into its sibling rbtree which starts from 352 * @kn->parent->dir.children. 353 * 354 * Locking: 355 * kernfs_rwsem held exclusive 356 * 357 * RETURNS: 358 * 0 on susccess -EEXIST on failure. 359 */ 360 static int kernfs_link_sibling(struct kernfs_node *kn) 361 { 362 struct rb_node **node = &kn->parent->dir.children.rb_node; 363 struct rb_node *parent = NULL; 364 365 while (*node) { 366 struct kernfs_node *pos; 367 int result; 368 369 pos = rb_to_kn(*node); 370 parent = *node; 371 result = kernfs_sd_compare(kn, pos); 372 if (result < 0) 373 node = &pos->rb.rb_left; 374 else if (result > 0) 375 node = &pos->rb.rb_right; 376 else 377 return -EEXIST; 378 } 379 380 /* add new node and rebalance the tree */ 381 rb_link_node(&kn->rb, parent, node); 382 rb_insert_color(&kn->rb, &kn->parent->dir.children); 383 384 /* successfully added, account subdir number */ 385 if (kernfs_type(kn) == KERNFS_DIR) 386 kn->parent->dir.subdirs++; 387 kernfs_inc_rev(kn->parent); 388 389 return 0; 390 } 391 392 /** 393 * kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree 394 * @kn: kernfs_node of interest 395 * 396 * Try to unlink @kn from its sibling rbtree which starts from 397 * kn->parent->dir.children. Returns %true if @kn was actually 398 * removed, %false if @kn wasn't on the rbtree. 399 * 400 * Locking: 401 * kernfs_rwsem held exclusive 402 */ 403 static bool kernfs_unlink_sibling(struct kernfs_node *kn) 404 { 405 if (RB_EMPTY_NODE(&kn->rb)) 406 return false; 407 408 if (kernfs_type(kn) == KERNFS_DIR) 409 kn->parent->dir.subdirs--; 410 kernfs_inc_rev(kn->parent); 411 412 rb_erase(&kn->rb, &kn->parent->dir.children); 413 RB_CLEAR_NODE(&kn->rb); 414 return true; 415 } 416 417 /** 418 * kernfs_get_active - get an active reference to kernfs_node 419 * @kn: kernfs_node to get an active reference to 420 * 421 * Get an active reference of @kn. This function is noop if @kn 422 * is NULL. 423 * 424 * RETURNS: 425 * Pointer to @kn on success, NULL on failure. 426 */ 427 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn) 428 { 429 if (unlikely(!kn)) 430 return NULL; 431 432 if (!atomic_inc_unless_negative(&kn->active)) 433 return NULL; 434 435 if (kernfs_lockdep(kn)) 436 rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_); 437 return kn; 438 } 439 440 /** 441 * kernfs_put_active - put an active reference to kernfs_node 442 * @kn: kernfs_node to put an active reference to 443 * 444 * Put an active reference to @kn. This function is noop if @kn 445 * is NULL. 446 */ 447 void kernfs_put_active(struct kernfs_node *kn) 448 { 449 int v; 450 451 if (unlikely(!kn)) 452 return; 453 454 if (kernfs_lockdep(kn)) 455 rwsem_release(&kn->dep_map, _RET_IP_); 456 v = atomic_dec_return(&kn->active); 457 if (likely(v != KN_DEACTIVATED_BIAS)) 458 return; 459 460 wake_up_all(&kernfs_root(kn)->deactivate_waitq); 461 } 462 463 /** 464 * kernfs_drain - drain kernfs_node 465 * @kn: kernfs_node to drain 466 * 467 * Drain existing usages and nuke all existing mmaps of @kn. Mutiple 468 * removers may invoke this function concurrently on @kn and all will 469 * return after draining is complete. 470 */ 471 static void kernfs_drain(struct kernfs_node *kn) 472 __releases(&kernfs_root(kn)->kernfs_rwsem) 473 __acquires(&kernfs_root(kn)->kernfs_rwsem) 474 { 475 struct kernfs_root *root = kernfs_root(kn); 476 477 lockdep_assert_held_write(&root->kernfs_rwsem); 478 WARN_ON_ONCE(kernfs_active(kn)); 479 480 /* 481 * Skip draining if already fully drained. This avoids draining and its 482 * lockdep annotations for nodes which have never been activated 483 * allowing embedding kernfs_remove() in create error paths without 484 * worrying about draining. 485 */ 486 if (atomic_read(&kn->active) == KN_DEACTIVATED_BIAS && 487 !kernfs_should_drain_open_files(kn)) 488 return; 489 490 up_write(&root->kernfs_rwsem); 491 492 if (kernfs_lockdep(kn)) { 493 rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_); 494 if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS) 495 lock_contended(&kn->dep_map, _RET_IP_); 496 } 497 498 wait_event(root->deactivate_waitq, 499 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS); 500 501 if (kernfs_lockdep(kn)) { 502 lock_acquired(&kn->dep_map, _RET_IP_); 503 rwsem_release(&kn->dep_map, _RET_IP_); 504 } 505 506 if (kernfs_should_drain_open_files(kn)) 507 kernfs_drain_open_files(kn); 508 509 down_write(&root->kernfs_rwsem); 510 } 511 512 /** 513 * kernfs_get - get a reference count on a kernfs_node 514 * @kn: the target kernfs_node 515 */ 516 void kernfs_get(struct kernfs_node *kn) 517 { 518 if (kn) { 519 WARN_ON(!atomic_read(&kn->count)); 520 atomic_inc(&kn->count); 521 } 522 } 523 EXPORT_SYMBOL_GPL(kernfs_get); 524 525 /** 526 * kernfs_put - put a reference count on a kernfs_node 527 * @kn: the target kernfs_node 528 * 529 * Put a reference count of @kn and destroy it if it reached zero. 530 */ 531 void kernfs_put(struct kernfs_node *kn) 532 { 533 struct kernfs_node *parent; 534 struct kernfs_root *root; 535 536 if (!kn || !atomic_dec_and_test(&kn->count)) 537 return; 538 root = kernfs_root(kn); 539 repeat: 540 /* 541 * Moving/renaming is always done while holding reference. 542 * kn->parent won't change beneath us. 543 */ 544 parent = kn->parent; 545 546 WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS, 547 "kernfs_put: %s/%s: released with incorrect active_ref %d\n", 548 parent ? parent->name : "", kn->name, atomic_read(&kn->active)); 549 550 if (kernfs_type(kn) == KERNFS_LINK) 551 kernfs_put(kn->symlink.target_kn); 552 553 kfree_const(kn->name); 554 555 if (kn->iattr) { 556 simple_xattrs_free(&kn->iattr->xattrs); 557 kmem_cache_free(kernfs_iattrs_cache, kn->iattr); 558 } 559 spin_lock(&kernfs_idr_lock); 560 idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); 561 spin_unlock(&kernfs_idr_lock); 562 kmem_cache_free(kernfs_node_cache, kn); 563 564 kn = parent; 565 if (kn) { 566 if (atomic_dec_and_test(&kn->count)) 567 goto repeat; 568 } else { 569 /* just released the root kn, free @root too */ 570 idr_destroy(&root->ino_idr); 571 kfree(root); 572 } 573 } 574 EXPORT_SYMBOL_GPL(kernfs_put); 575 576 /** 577 * kernfs_node_from_dentry - determine kernfs_node associated with a dentry 578 * @dentry: the dentry in question 579 * 580 * Return the kernfs_node associated with @dentry. If @dentry is not a 581 * kernfs one, %NULL is returned. 582 * 583 * While the returned kernfs_node will stay accessible as long as @dentry 584 * is accessible, the returned node can be in any state and the caller is 585 * fully responsible for determining what's accessible. 586 */ 587 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 588 { 589 if (dentry->d_sb->s_op == &kernfs_sops) 590 return kernfs_dentry_node(dentry); 591 return NULL; 592 } 593 594 static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root, 595 struct kernfs_node *parent, 596 const char *name, umode_t mode, 597 kuid_t uid, kgid_t gid, 598 unsigned flags) 599 { 600 struct kernfs_node *kn; 601 u32 id_highbits; 602 int ret; 603 604 name = kstrdup_const(name, GFP_KERNEL); 605 if (!name) 606 return NULL; 607 608 kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL); 609 if (!kn) 610 goto err_out1; 611 612 idr_preload(GFP_KERNEL); 613 spin_lock(&kernfs_idr_lock); 614 ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC); 615 if (ret >= 0 && ret < root->last_id_lowbits) 616 root->id_highbits++; 617 id_highbits = root->id_highbits; 618 root->last_id_lowbits = ret; 619 spin_unlock(&kernfs_idr_lock); 620 idr_preload_end(); 621 if (ret < 0) 622 goto err_out2; 623 624 kn->id = (u64)id_highbits << 32 | ret; 625 626 atomic_set(&kn->count, 1); 627 atomic_set(&kn->active, KN_DEACTIVATED_BIAS); 628 RB_CLEAR_NODE(&kn->rb); 629 630 kn->name = name; 631 kn->mode = mode; 632 kn->flags = flags; 633 634 if (!uid_eq(uid, GLOBAL_ROOT_UID) || !gid_eq(gid, GLOBAL_ROOT_GID)) { 635 struct iattr iattr = { 636 .ia_valid = ATTR_UID | ATTR_GID, 637 .ia_uid = uid, 638 .ia_gid = gid, 639 }; 640 641 ret = __kernfs_setattr(kn, &iattr); 642 if (ret < 0) 643 goto err_out3; 644 } 645 646 if (parent) { 647 ret = security_kernfs_init_security(parent, kn); 648 if (ret) 649 goto err_out3; 650 } 651 652 return kn; 653 654 err_out3: 655 idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); 656 err_out2: 657 kmem_cache_free(kernfs_node_cache, kn); 658 err_out1: 659 kfree_const(name); 660 return NULL; 661 } 662 663 struct kernfs_node *kernfs_new_node(struct kernfs_node *parent, 664 const char *name, umode_t mode, 665 kuid_t uid, kgid_t gid, 666 unsigned flags) 667 { 668 struct kernfs_node *kn; 669 670 kn = __kernfs_new_node(kernfs_root(parent), parent, 671 name, mode, uid, gid, flags); 672 if (kn) { 673 kernfs_get(parent); 674 kn->parent = parent; 675 } 676 return kn; 677 } 678 679 /* 680 * kernfs_find_and_get_node_by_id - get kernfs_node from node id 681 * @root: the kernfs root 682 * @id: the target node id 683 * 684 * @id's lower 32bits encode ino and upper gen. If the gen portion is 685 * zero, all generations are matched. 686 * 687 * RETURNS: 688 * NULL on failure. Return a kernfs node with reference counter incremented 689 */ 690 struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root, 691 u64 id) 692 { 693 struct kernfs_node *kn; 694 ino_t ino = kernfs_id_ino(id); 695 u32 gen = kernfs_id_gen(id); 696 697 spin_lock(&kernfs_idr_lock); 698 699 kn = idr_find(&root->ino_idr, (u32)ino); 700 if (!kn) 701 goto err_unlock; 702 703 if (sizeof(ino_t) >= sizeof(u64)) { 704 /* we looked up with the low 32bits, compare the whole */ 705 if (kernfs_ino(kn) != ino) 706 goto err_unlock; 707 } else { 708 /* 0 matches all generations */ 709 if (unlikely(gen && kernfs_gen(kn) != gen)) 710 goto err_unlock; 711 } 712 713 /* 714 * We should fail if @kn has never been activated and guarantee success 715 * if the caller knows that @kn is active. Both can be achieved by 716 * __kernfs_active() which tests @kn->active without kernfs_rwsem. 717 */ 718 if (unlikely(!__kernfs_active(kn) || !atomic_inc_not_zero(&kn->count))) 719 goto err_unlock; 720 721 spin_unlock(&kernfs_idr_lock); 722 return kn; 723 err_unlock: 724 spin_unlock(&kernfs_idr_lock); 725 return NULL; 726 } 727 728 /** 729 * kernfs_add_one - add kernfs_node to parent without warning 730 * @kn: kernfs_node to be added 731 * 732 * The caller must already have initialized @kn->parent. This 733 * function increments nlink of the parent's inode if @kn is a 734 * directory and link into the children list of the parent. 735 * 736 * RETURNS: 737 * 0 on success, -EEXIST if entry with the given name already 738 * exists. 739 */ 740 int kernfs_add_one(struct kernfs_node *kn) 741 { 742 struct kernfs_node *parent = kn->parent; 743 struct kernfs_root *root = kernfs_root(parent); 744 struct kernfs_iattrs *ps_iattr; 745 bool has_ns; 746 int ret; 747 748 down_write(&root->kernfs_rwsem); 749 750 ret = -EINVAL; 751 has_ns = kernfs_ns_enabled(parent); 752 if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 753 has_ns ? "required" : "invalid", parent->name, kn->name)) 754 goto out_unlock; 755 756 if (kernfs_type(parent) != KERNFS_DIR) 757 goto out_unlock; 758 759 ret = -ENOENT; 760 if (parent->flags & (KERNFS_REMOVING | KERNFS_EMPTY_DIR)) 761 goto out_unlock; 762 763 kn->hash = kernfs_name_hash(kn->name, kn->ns); 764 765 ret = kernfs_link_sibling(kn); 766 if (ret) 767 goto out_unlock; 768 769 /* Update timestamps on the parent */ 770 ps_iattr = parent->iattr; 771 if (ps_iattr) { 772 ktime_get_real_ts64(&ps_iattr->ia_ctime); 773 ps_iattr->ia_mtime = ps_iattr->ia_ctime; 774 } 775 776 up_write(&root->kernfs_rwsem); 777 778 /* 779 * Activate the new node unless CREATE_DEACTIVATED is requested. 780 * If not activated here, the kernfs user is responsible for 781 * activating the node with kernfs_activate(). A node which hasn't 782 * been activated is not visible to userland and its removal won't 783 * trigger deactivation. 784 */ 785 if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 786 kernfs_activate(kn); 787 return 0; 788 789 out_unlock: 790 up_write(&root->kernfs_rwsem); 791 return ret; 792 } 793 794 /** 795 * kernfs_find_ns - find kernfs_node with the given name 796 * @parent: kernfs_node to search under 797 * @name: name to look for 798 * @ns: the namespace tag to use 799 * 800 * Look for kernfs_node with name @name under @parent. Returns pointer to 801 * the found kernfs_node on success, %NULL on failure. 802 */ 803 static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent, 804 const unsigned char *name, 805 const void *ns) 806 { 807 struct rb_node *node = parent->dir.children.rb_node; 808 bool has_ns = kernfs_ns_enabled(parent); 809 unsigned int hash; 810 811 lockdep_assert_held(&kernfs_root(parent)->kernfs_rwsem); 812 813 if (has_ns != (bool)ns) { 814 WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n", 815 has_ns ? "required" : "invalid", parent->name, name); 816 return NULL; 817 } 818 819 hash = kernfs_name_hash(name, ns); 820 while (node) { 821 struct kernfs_node *kn; 822 int result; 823 824 kn = rb_to_kn(node); 825 result = kernfs_name_compare(hash, name, ns, kn); 826 if (result < 0) 827 node = node->rb_left; 828 else if (result > 0) 829 node = node->rb_right; 830 else 831 return kn; 832 } 833 return NULL; 834 } 835 836 static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent, 837 const unsigned char *path, 838 const void *ns) 839 { 840 size_t len; 841 char *p, *name; 842 843 lockdep_assert_held_read(&kernfs_root(parent)->kernfs_rwsem); 844 845 spin_lock_irq(&kernfs_pr_cont_lock); 846 847 len = strlcpy(kernfs_pr_cont_buf, path, sizeof(kernfs_pr_cont_buf)); 848 849 if (len >= sizeof(kernfs_pr_cont_buf)) { 850 spin_unlock_irq(&kernfs_pr_cont_lock); 851 return NULL; 852 } 853 854 p = kernfs_pr_cont_buf; 855 856 while ((name = strsep(&p, "/")) && parent) { 857 if (*name == '\0') 858 continue; 859 parent = kernfs_find_ns(parent, name, ns); 860 } 861 862 spin_unlock_irq(&kernfs_pr_cont_lock); 863 864 return parent; 865 } 866 867 /** 868 * kernfs_find_and_get_ns - find and get kernfs_node with the given name 869 * @parent: kernfs_node to search under 870 * @name: name to look for 871 * @ns: the namespace tag to use 872 * 873 * Look for kernfs_node with name @name under @parent and get a reference 874 * if found. This function may sleep and returns pointer to the found 875 * kernfs_node on success, %NULL on failure. 876 */ 877 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 878 const char *name, const void *ns) 879 { 880 struct kernfs_node *kn; 881 struct kernfs_root *root = kernfs_root(parent); 882 883 down_read(&root->kernfs_rwsem); 884 kn = kernfs_find_ns(parent, name, ns); 885 kernfs_get(kn); 886 up_read(&root->kernfs_rwsem); 887 888 return kn; 889 } 890 EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns); 891 892 /** 893 * kernfs_walk_and_get_ns - find and get kernfs_node with the given path 894 * @parent: kernfs_node to search under 895 * @path: path to look for 896 * @ns: the namespace tag to use 897 * 898 * Look for kernfs_node with path @path under @parent and get a reference 899 * if found. This function may sleep and returns pointer to the found 900 * kernfs_node on success, %NULL on failure. 901 */ 902 struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent, 903 const char *path, const void *ns) 904 { 905 struct kernfs_node *kn; 906 struct kernfs_root *root = kernfs_root(parent); 907 908 down_read(&root->kernfs_rwsem); 909 kn = kernfs_walk_ns(parent, path, ns); 910 kernfs_get(kn); 911 up_read(&root->kernfs_rwsem); 912 913 return kn; 914 } 915 916 /** 917 * kernfs_create_root - create a new kernfs hierarchy 918 * @scops: optional syscall operations for the hierarchy 919 * @flags: KERNFS_ROOT_* flags 920 * @priv: opaque data associated with the new directory 921 * 922 * Returns the root of the new hierarchy on success, ERR_PTR() value on 923 * failure. 924 */ 925 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 926 unsigned int flags, void *priv) 927 { 928 struct kernfs_root *root; 929 struct kernfs_node *kn; 930 931 root = kzalloc(sizeof(*root), GFP_KERNEL); 932 if (!root) 933 return ERR_PTR(-ENOMEM); 934 935 idr_init(&root->ino_idr); 936 init_rwsem(&root->kernfs_rwsem); 937 INIT_LIST_HEAD(&root->supers); 938 939 /* 940 * On 64bit ino setups, id is ino. On 32bit, low 32bits are ino. 941 * High bits generation. The starting value for both ino and 942 * genenration is 1. Initialize upper 32bit allocation 943 * accordingly. 944 */ 945 if (sizeof(ino_t) >= sizeof(u64)) 946 root->id_highbits = 0; 947 else 948 root->id_highbits = 1; 949 950 kn = __kernfs_new_node(root, NULL, "", S_IFDIR | S_IRUGO | S_IXUGO, 951 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 952 KERNFS_DIR); 953 if (!kn) { 954 idr_destroy(&root->ino_idr); 955 kfree(root); 956 return ERR_PTR(-ENOMEM); 957 } 958 959 kn->priv = priv; 960 kn->dir.root = root; 961 962 root->syscall_ops = scops; 963 root->flags = flags; 964 root->kn = kn; 965 init_waitqueue_head(&root->deactivate_waitq); 966 967 if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) 968 kernfs_activate(kn); 969 970 return root; 971 } 972 973 /** 974 * kernfs_destroy_root - destroy a kernfs hierarchy 975 * @root: root of the hierarchy to destroy 976 * 977 * Destroy the hierarchy anchored at @root by removing all existing 978 * directories and destroying @root. 979 */ 980 void kernfs_destroy_root(struct kernfs_root *root) 981 { 982 /* 983 * kernfs_remove holds kernfs_rwsem from the root so the root 984 * shouldn't be freed during the operation. 985 */ 986 kernfs_get(root->kn); 987 kernfs_remove(root->kn); 988 kernfs_put(root->kn); /* will also free @root */ 989 } 990 991 /** 992 * kernfs_root_to_node - return the kernfs_node associated with a kernfs_root 993 * @root: root to use to lookup 994 */ 995 struct kernfs_node *kernfs_root_to_node(struct kernfs_root *root) 996 { 997 return root->kn; 998 } 999 1000 /** 1001 * kernfs_create_dir_ns - create a directory 1002 * @parent: parent in which to create a new directory 1003 * @name: name of the new directory 1004 * @mode: mode of the new directory 1005 * @uid: uid of the new directory 1006 * @gid: gid of the new directory 1007 * @priv: opaque data associated with the new directory 1008 * @ns: optional namespace tag of the directory 1009 * 1010 * Returns the created node on success, ERR_PTR() value on failure. 1011 */ 1012 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 1013 const char *name, umode_t mode, 1014 kuid_t uid, kgid_t gid, 1015 void *priv, const void *ns) 1016 { 1017 struct kernfs_node *kn; 1018 int rc; 1019 1020 /* allocate */ 1021 kn = kernfs_new_node(parent, name, mode | S_IFDIR, 1022 uid, gid, KERNFS_DIR); 1023 if (!kn) 1024 return ERR_PTR(-ENOMEM); 1025 1026 kn->dir.root = parent->dir.root; 1027 kn->ns = ns; 1028 kn->priv = priv; 1029 1030 /* link in */ 1031 rc = kernfs_add_one(kn); 1032 if (!rc) 1033 return kn; 1034 1035 kernfs_put(kn); 1036 return ERR_PTR(rc); 1037 } 1038 1039 /** 1040 * kernfs_create_empty_dir - create an always empty directory 1041 * @parent: parent in which to create a new directory 1042 * @name: name of the new directory 1043 * 1044 * Returns the created node on success, ERR_PTR() value on failure. 1045 */ 1046 struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent, 1047 const char *name) 1048 { 1049 struct kernfs_node *kn; 1050 int rc; 1051 1052 /* allocate */ 1053 kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR, 1054 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, KERNFS_DIR); 1055 if (!kn) 1056 return ERR_PTR(-ENOMEM); 1057 1058 kn->flags |= KERNFS_EMPTY_DIR; 1059 kn->dir.root = parent->dir.root; 1060 kn->ns = NULL; 1061 kn->priv = NULL; 1062 1063 /* link in */ 1064 rc = kernfs_add_one(kn); 1065 if (!rc) 1066 return kn; 1067 1068 kernfs_put(kn); 1069 return ERR_PTR(rc); 1070 } 1071 1072 static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags) 1073 { 1074 struct kernfs_node *kn; 1075 struct kernfs_root *root; 1076 1077 if (flags & LOOKUP_RCU) 1078 return -ECHILD; 1079 1080 /* Negative hashed dentry? */ 1081 if (d_really_is_negative(dentry)) { 1082 struct kernfs_node *parent; 1083 1084 /* If the kernfs parent node has changed discard and 1085 * proceed to ->lookup. 1086 */ 1087 spin_lock(&dentry->d_lock); 1088 parent = kernfs_dentry_node(dentry->d_parent); 1089 if (parent) { 1090 spin_unlock(&dentry->d_lock); 1091 root = kernfs_root(parent); 1092 down_read(&root->kernfs_rwsem); 1093 if (kernfs_dir_changed(parent, dentry)) { 1094 up_read(&root->kernfs_rwsem); 1095 return 0; 1096 } 1097 up_read(&root->kernfs_rwsem); 1098 } else 1099 spin_unlock(&dentry->d_lock); 1100 1101 /* The kernfs parent node hasn't changed, leave the 1102 * dentry negative and return success. 1103 */ 1104 return 1; 1105 } 1106 1107 kn = kernfs_dentry_node(dentry); 1108 root = kernfs_root(kn); 1109 down_read(&root->kernfs_rwsem); 1110 1111 /* The kernfs node has been deactivated */ 1112 if (!kernfs_active(kn)) 1113 goto out_bad; 1114 1115 /* The kernfs node has been moved? */ 1116 if (kernfs_dentry_node(dentry->d_parent) != kn->parent) 1117 goto out_bad; 1118 1119 /* The kernfs node has been renamed */ 1120 if (strcmp(dentry->d_name.name, kn->name) != 0) 1121 goto out_bad; 1122 1123 /* The kernfs node has been moved to a different namespace */ 1124 if (kn->parent && kernfs_ns_enabled(kn->parent) && 1125 kernfs_info(dentry->d_sb)->ns != kn->ns) 1126 goto out_bad; 1127 1128 up_read(&root->kernfs_rwsem); 1129 return 1; 1130 out_bad: 1131 up_read(&root->kernfs_rwsem); 1132 return 0; 1133 } 1134 1135 const struct dentry_operations kernfs_dops = { 1136 .d_revalidate = kernfs_dop_revalidate, 1137 }; 1138 1139 static struct dentry *kernfs_iop_lookup(struct inode *dir, 1140 struct dentry *dentry, 1141 unsigned int flags) 1142 { 1143 struct kernfs_node *parent = dir->i_private; 1144 struct kernfs_node *kn; 1145 struct kernfs_root *root; 1146 struct inode *inode = NULL; 1147 const void *ns = NULL; 1148 1149 root = kernfs_root(parent); 1150 down_read(&root->kernfs_rwsem); 1151 if (kernfs_ns_enabled(parent)) 1152 ns = kernfs_info(dir->i_sb)->ns; 1153 1154 kn = kernfs_find_ns(parent, dentry->d_name.name, ns); 1155 /* attach dentry and inode */ 1156 if (kn) { 1157 /* Inactive nodes are invisible to the VFS so don't 1158 * create a negative. 1159 */ 1160 if (!kernfs_active(kn)) { 1161 up_read(&root->kernfs_rwsem); 1162 return NULL; 1163 } 1164 inode = kernfs_get_inode(dir->i_sb, kn); 1165 if (!inode) 1166 inode = ERR_PTR(-ENOMEM); 1167 } 1168 /* 1169 * Needed for negative dentry validation. 1170 * The negative dentry can be created in kernfs_iop_lookup() 1171 * or transforms from positive dentry in dentry_unlink_inode() 1172 * called from vfs_rmdir(). 1173 */ 1174 if (!IS_ERR(inode)) 1175 kernfs_set_rev(parent, dentry); 1176 up_read(&root->kernfs_rwsem); 1177 1178 /* instantiate and hash (possibly negative) dentry */ 1179 return d_splice_alias(inode, dentry); 1180 } 1181 1182 static int kernfs_iop_mkdir(struct user_namespace *mnt_userns, 1183 struct inode *dir, struct dentry *dentry, 1184 umode_t mode) 1185 { 1186 struct kernfs_node *parent = dir->i_private; 1187 struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops; 1188 int ret; 1189 1190 if (!scops || !scops->mkdir) 1191 return -EPERM; 1192 1193 if (!kernfs_get_active(parent)) 1194 return -ENODEV; 1195 1196 ret = scops->mkdir(parent, dentry->d_name.name, mode); 1197 1198 kernfs_put_active(parent); 1199 return ret; 1200 } 1201 1202 static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry) 1203 { 1204 struct kernfs_node *kn = kernfs_dentry_node(dentry); 1205 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 1206 int ret; 1207 1208 if (!scops || !scops->rmdir) 1209 return -EPERM; 1210 1211 if (!kernfs_get_active(kn)) 1212 return -ENODEV; 1213 1214 ret = scops->rmdir(kn); 1215 1216 kernfs_put_active(kn); 1217 return ret; 1218 } 1219 1220 static int kernfs_iop_rename(struct user_namespace *mnt_userns, 1221 struct inode *old_dir, struct dentry *old_dentry, 1222 struct inode *new_dir, struct dentry *new_dentry, 1223 unsigned int flags) 1224 { 1225 struct kernfs_node *kn = kernfs_dentry_node(old_dentry); 1226 struct kernfs_node *new_parent = new_dir->i_private; 1227 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops; 1228 int ret; 1229 1230 if (flags) 1231 return -EINVAL; 1232 1233 if (!scops || !scops->rename) 1234 return -EPERM; 1235 1236 if (!kernfs_get_active(kn)) 1237 return -ENODEV; 1238 1239 if (!kernfs_get_active(new_parent)) { 1240 kernfs_put_active(kn); 1241 return -ENODEV; 1242 } 1243 1244 ret = scops->rename(kn, new_parent, new_dentry->d_name.name); 1245 1246 kernfs_put_active(new_parent); 1247 kernfs_put_active(kn); 1248 return ret; 1249 } 1250 1251 const struct inode_operations kernfs_dir_iops = { 1252 .lookup = kernfs_iop_lookup, 1253 .permission = kernfs_iop_permission, 1254 .setattr = kernfs_iop_setattr, 1255 .getattr = kernfs_iop_getattr, 1256 .listxattr = kernfs_iop_listxattr, 1257 1258 .mkdir = kernfs_iop_mkdir, 1259 .rmdir = kernfs_iop_rmdir, 1260 .rename = kernfs_iop_rename, 1261 }; 1262 1263 static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos) 1264 { 1265 struct kernfs_node *last; 1266 1267 while (true) { 1268 struct rb_node *rbn; 1269 1270 last = pos; 1271 1272 if (kernfs_type(pos) != KERNFS_DIR) 1273 break; 1274 1275 rbn = rb_first(&pos->dir.children); 1276 if (!rbn) 1277 break; 1278 1279 pos = rb_to_kn(rbn); 1280 } 1281 1282 return last; 1283 } 1284 1285 /** 1286 * kernfs_next_descendant_post - find the next descendant for post-order walk 1287 * @pos: the current position (%NULL to initiate traversal) 1288 * @root: kernfs_node whose descendants to walk 1289 * 1290 * Find the next descendant to visit for post-order traversal of @root's 1291 * descendants. @root is included in the iteration and the last node to be 1292 * visited. 1293 */ 1294 static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos, 1295 struct kernfs_node *root) 1296 { 1297 struct rb_node *rbn; 1298 1299 lockdep_assert_held_write(&kernfs_root(root)->kernfs_rwsem); 1300 1301 /* if first iteration, visit leftmost descendant which may be root */ 1302 if (!pos) 1303 return kernfs_leftmost_descendant(root); 1304 1305 /* if we visited @root, we're done */ 1306 if (pos == root) 1307 return NULL; 1308 1309 /* if there's an unvisited sibling, visit its leftmost descendant */ 1310 rbn = rb_next(&pos->rb); 1311 if (rbn) 1312 return kernfs_leftmost_descendant(rb_to_kn(rbn)); 1313 1314 /* no sibling left, visit parent */ 1315 return pos->parent; 1316 } 1317 1318 static void kernfs_activate_one(struct kernfs_node *kn) 1319 { 1320 lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem); 1321 1322 kn->flags |= KERNFS_ACTIVATED; 1323 1324 if (kernfs_active(kn) || (kn->flags & (KERNFS_HIDDEN | KERNFS_REMOVING))) 1325 return; 1326 1327 WARN_ON_ONCE(kn->parent && RB_EMPTY_NODE(&kn->rb)); 1328 WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS); 1329 1330 atomic_sub(KN_DEACTIVATED_BIAS, &kn->active); 1331 } 1332 1333 /** 1334 * kernfs_activate - activate a node which started deactivated 1335 * @kn: kernfs_node whose subtree is to be activated 1336 * 1337 * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node 1338 * needs to be explicitly activated. A node which hasn't been activated 1339 * isn't visible to userland and deactivation is skipped during its 1340 * removal. This is useful to construct atomic init sequences where 1341 * creation of multiple nodes should either succeed or fail atomically. 1342 * 1343 * The caller is responsible for ensuring that this function is not called 1344 * after kernfs_remove*() is invoked on @kn. 1345 */ 1346 void kernfs_activate(struct kernfs_node *kn) 1347 { 1348 struct kernfs_node *pos; 1349 struct kernfs_root *root = kernfs_root(kn); 1350 1351 down_write(&root->kernfs_rwsem); 1352 1353 pos = NULL; 1354 while ((pos = kernfs_next_descendant_post(pos, kn))) 1355 kernfs_activate_one(pos); 1356 1357 up_write(&root->kernfs_rwsem); 1358 } 1359 1360 /** 1361 * kernfs_show - show or hide a node 1362 * @kn: kernfs_node to show or hide 1363 * @show: whether to show or hide 1364 * 1365 * If @show is %false, @kn is marked hidden and deactivated. A hidden node is 1366 * ignored in future activaitons. If %true, the mark is removed and activation 1367 * state is restored. This function won't implicitly activate a new node in a 1368 * %KERNFS_ROOT_CREATE_DEACTIVATED root which hasn't been activated yet. 1369 * 1370 * To avoid recursion complexities, directories aren't supported for now. 1371 */ 1372 void kernfs_show(struct kernfs_node *kn, bool show) 1373 { 1374 struct kernfs_root *root = kernfs_root(kn); 1375 1376 if (WARN_ON_ONCE(kernfs_type(kn) == KERNFS_DIR)) 1377 return; 1378 1379 down_write(&root->kernfs_rwsem); 1380 1381 if (show) { 1382 kn->flags &= ~KERNFS_HIDDEN; 1383 if (kn->flags & KERNFS_ACTIVATED) 1384 kernfs_activate_one(kn); 1385 } else { 1386 kn->flags |= KERNFS_HIDDEN; 1387 if (kernfs_active(kn)) 1388 atomic_add(KN_DEACTIVATED_BIAS, &kn->active); 1389 kernfs_drain(kn); 1390 } 1391 1392 up_write(&root->kernfs_rwsem); 1393 } 1394 1395 static void __kernfs_remove(struct kernfs_node *kn) 1396 { 1397 struct kernfs_node *pos; 1398 1399 /* Short-circuit if non-root @kn has already finished removal. */ 1400 if (!kn) 1401 return; 1402 1403 lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem); 1404 1405 /* 1406 * This is for kernfs_remove_self() which plays with active ref 1407 * after removal. 1408 */ 1409 if (kn->parent && RB_EMPTY_NODE(&kn->rb)) 1410 return; 1411 1412 pr_debug("kernfs %s: removing\n", kn->name); 1413 1414 /* prevent new usage by marking all nodes removing and deactivating */ 1415 pos = NULL; 1416 while ((pos = kernfs_next_descendant_post(pos, kn))) { 1417 pos->flags |= KERNFS_REMOVING; 1418 if (kernfs_active(pos)) 1419 atomic_add(KN_DEACTIVATED_BIAS, &pos->active); 1420 } 1421 1422 /* deactivate and unlink the subtree node-by-node */ 1423 do { 1424 pos = kernfs_leftmost_descendant(kn); 1425 1426 /* 1427 * kernfs_drain() may drop kernfs_rwsem temporarily and @pos's 1428 * base ref could have been put by someone else by the time 1429 * the function returns. Make sure it doesn't go away 1430 * underneath us. 1431 */ 1432 kernfs_get(pos); 1433 1434 kernfs_drain(pos); 1435 1436 /* 1437 * kernfs_unlink_sibling() succeeds once per node. Use it 1438 * to decide who's responsible for cleanups. 1439 */ 1440 if (!pos->parent || kernfs_unlink_sibling(pos)) { 1441 struct kernfs_iattrs *ps_iattr = 1442 pos->parent ? pos->parent->iattr : NULL; 1443 1444 /* update timestamps on the parent */ 1445 if (ps_iattr) { 1446 ktime_get_real_ts64(&ps_iattr->ia_ctime); 1447 ps_iattr->ia_mtime = ps_iattr->ia_ctime; 1448 } 1449 1450 kernfs_put(pos); 1451 } 1452 1453 kernfs_put(pos); 1454 } while (pos != kn); 1455 } 1456 1457 /** 1458 * kernfs_remove - remove a kernfs_node recursively 1459 * @kn: the kernfs_node to remove 1460 * 1461 * Remove @kn along with all its subdirectories and files. 1462 */ 1463 void kernfs_remove(struct kernfs_node *kn) 1464 { 1465 struct kernfs_root *root; 1466 1467 if (!kn) 1468 return; 1469 1470 root = kernfs_root(kn); 1471 1472 down_write(&root->kernfs_rwsem); 1473 __kernfs_remove(kn); 1474 up_write(&root->kernfs_rwsem); 1475 } 1476 1477 /** 1478 * kernfs_break_active_protection - break out of active protection 1479 * @kn: the self kernfs_node 1480 * 1481 * The caller must be running off of a kernfs operation which is invoked 1482 * with an active reference - e.g. one of kernfs_ops. Each invocation of 1483 * this function must also be matched with an invocation of 1484 * kernfs_unbreak_active_protection(). 1485 * 1486 * This function releases the active reference of @kn the caller is 1487 * holding. Once this function is called, @kn may be removed at any point 1488 * and the caller is solely responsible for ensuring that the objects it 1489 * dereferences are accessible. 1490 */ 1491 void kernfs_break_active_protection(struct kernfs_node *kn) 1492 { 1493 /* 1494 * Take out ourself out of the active ref dependency chain. If 1495 * we're called without an active ref, lockdep will complain. 1496 */ 1497 kernfs_put_active(kn); 1498 } 1499 1500 /** 1501 * kernfs_unbreak_active_protection - undo kernfs_break_active_protection() 1502 * @kn: the self kernfs_node 1503 * 1504 * If kernfs_break_active_protection() was called, this function must be 1505 * invoked before finishing the kernfs operation. Note that while this 1506 * function restores the active reference, it doesn't and can't actually 1507 * restore the active protection - @kn may already or be in the process of 1508 * being removed. Once kernfs_break_active_protection() is invoked, that 1509 * protection is irreversibly gone for the kernfs operation instance. 1510 * 1511 * While this function may be called at any point after 1512 * kernfs_break_active_protection() is invoked, its most useful location 1513 * would be right before the enclosing kernfs operation returns. 1514 */ 1515 void kernfs_unbreak_active_protection(struct kernfs_node *kn) 1516 { 1517 /* 1518 * @kn->active could be in any state; however, the increment we do 1519 * here will be undone as soon as the enclosing kernfs operation 1520 * finishes and this temporary bump can't break anything. If @kn 1521 * is alive, nothing changes. If @kn is being deactivated, the 1522 * soon-to-follow put will either finish deactivation or restore 1523 * deactivated state. If @kn is already removed, the temporary 1524 * bump is guaranteed to be gone before @kn is released. 1525 */ 1526 atomic_inc(&kn->active); 1527 if (kernfs_lockdep(kn)) 1528 rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_); 1529 } 1530 1531 /** 1532 * kernfs_remove_self - remove a kernfs_node from its own method 1533 * @kn: the self kernfs_node to remove 1534 * 1535 * The caller must be running off of a kernfs operation which is invoked 1536 * with an active reference - e.g. one of kernfs_ops. This can be used to 1537 * implement a file operation which deletes itself. 1538 * 1539 * For example, the "delete" file for a sysfs device directory can be 1540 * implemented by invoking kernfs_remove_self() on the "delete" file 1541 * itself. This function breaks the circular dependency of trying to 1542 * deactivate self while holding an active ref itself. It isn't necessary 1543 * to modify the usual removal path to use kernfs_remove_self(). The 1544 * "delete" implementation can simply invoke kernfs_remove_self() on self 1545 * before proceeding with the usual removal path. kernfs will ignore later 1546 * kernfs_remove() on self. 1547 * 1548 * kernfs_remove_self() can be called multiple times concurrently on the 1549 * same kernfs_node. Only the first one actually performs removal and 1550 * returns %true. All others will wait until the kernfs operation which 1551 * won self-removal finishes and return %false. Note that the losers wait 1552 * for the completion of not only the winning kernfs_remove_self() but also 1553 * the whole kernfs_ops which won the arbitration. This can be used to 1554 * guarantee, for example, all concurrent writes to a "delete" file to 1555 * finish only after the whole operation is complete. 1556 */ 1557 bool kernfs_remove_self(struct kernfs_node *kn) 1558 { 1559 bool ret; 1560 struct kernfs_root *root = kernfs_root(kn); 1561 1562 down_write(&root->kernfs_rwsem); 1563 kernfs_break_active_protection(kn); 1564 1565 /* 1566 * SUICIDAL is used to arbitrate among competing invocations. Only 1567 * the first one will actually perform removal. When the removal 1568 * is complete, SUICIDED is set and the active ref is restored 1569 * while kernfs_rwsem for held exclusive. The ones which lost 1570 * arbitration waits for SUICIDED && drained which can happen only 1571 * after the enclosing kernfs operation which executed the winning 1572 * instance of kernfs_remove_self() finished. 1573 */ 1574 if (!(kn->flags & KERNFS_SUICIDAL)) { 1575 kn->flags |= KERNFS_SUICIDAL; 1576 __kernfs_remove(kn); 1577 kn->flags |= KERNFS_SUICIDED; 1578 ret = true; 1579 } else { 1580 wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq; 1581 DEFINE_WAIT(wait); 1582 1583 while (true) { 1584 prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE); 1585 1586 if ((kn->flags & KERNFS_SUICIDED) && 1587 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS) 1588 break; 1589 1590 up_write(&root->kernfs_rwsem); 1591 schedule(); 1592 down_write(&root->kernfs_rwsem); 1593 } 1594 finish_wait(waitq, &wait); 1595 WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb)); 1596 ret = false; 1597 } 1598 1599 /* 1600 * This must be done while kernfs_rwsem held exclusive; otherwise, 1601 * waiting for SUICIDED && deactivated could finish prematurely. 1602 */ 1603 kernfs_unbreak_active_protection(kn); 1604 1605 up_write(&root->kernfs_rwsem); 1606 return ret; 1607 } 1608 1609 /** 1610 * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it 1611 * @parent: parent of the target 1612 * @name: name of the kernfs_node to remove 1613 * @ns: namespace tag of the kernfs_node to remove 1614 * 1615 * Look for the kernfs_node with @name and @ns under @parent and remove it. 1616 * Returns 0 on success, -ENOENT if such entry doesn't exist. 1617 */ 1618 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 1619 const void *ns) 1620 { 1621 struct kernfs_node *kn; 1622 struct kernfs_root *root; 1623 1624 if (!parent) { 1625 WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n", 1626 name); 1627 return -ENOENT; 1628 } 1629 1630 root = kernfs_root(parent); 1631 down_write(&root->kernfs_rwsem); 1632 1633 kn = kernfs_find_ns(parent, name, ns); 1634 if (kn) { 1635 kernfs_get(kn); 1636 __kernfs_remove(kn); 1637 kernfs_put(kn); 1638 } 1639 1640 up_write(&root->kernfs_rwsem); 1641 1642 if (kn) 1643 return 0; 1644 else 1645 return -ENOENT; 1646 } 1647 1648 /** 1649 * kernfs_rename_ns - move and rename a kernfs_node 1650 * @kn: target node 1651 * @new_parent: new parent to put @sd under 1652 * @new_name: new name 1653 * @new_ns: new namespace tag 1654 */ 1655 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 1656 const char *new_name, const void *new_ns) 1657 { 1658 struct kernfs_node *old_parent; 1659 struct kernfs_root *root; 1660 const char *old_name = NULL; 1661 int error; 1662 1663 /* can't move or rename root */ 1664 if (!kn->parent) 1665 return -EINVAL; 1666 1667 root = kernfs_root(kn); 1668 down_write(&root->kernfs_rwsem); 1669 1670 error = -ENOENT; 1671 if (!kernfs_active(kn) || !kernfs_active(new_parent) || 1672 (new_parent->flags & KERNFS_EMPTY_DIR)) 1673 goto out; 1674 1675 error = 0; 1676 if ((kn->parent == new_parent) && (kn->ns == new_ns) && 1677 (strcmp(kn->name, new_name) == 0)) 1678 goto out; /* nothing to rename */ 1679 1680 error = -EEXIST; 1681 if (kernfs_find_ns(new_parent, new_name, new_ns)) 1682 goto out; 1683 1684 /* rename kernfs_node */ 1685 if (strcmp(kn->name, new_name) != 0) { 1686 error = -ENOMEM; 1687 new_name = kstrdup_const(new_name, GFP_KERNEL); 1688 if (!new_name) 1689 goto out; 1690 } else { 1691 new_name = NULL; 1692 } 1693 1694 /* 1695 * Move to the appropriate place in the appropriate directories rbtree. 1696 */ 1697 kernfs_unlink_sibling(kn); 1698 kernfs_get(new_parent); 1699 1700 /* rename_lock protects ->parent and ->name accessors */ 1701 spin_lock_irq(&kernfs_rename_lock); 1702 1703 old_parent = kn->parent; 1704 kn->parent = new_parent; 1705 1706 kn->ns = new_ns; 1707 if (new_name) { 1708 old_name = kn->name; 1709 kn->name = new_name; 1710 } 1711 1712 spin_unlock_irq(&kernfs_rename_lock); 1713 1714 kn->hash = kernfs_name_hash(kn->name, kn->ns); 1715 kernfs_link_sibling(kn); 1716 1717 kernfs_put(old_parent); 1718 kfree_const(old_name); 1719 1720 error = 0; 1721 out: 1722 up_write(&root->kernfs_rwsem); 1723 return error; 1724 } 1725 1726 /* Relationship between mode and the DT_xxx types */ 1727 static inline unsigned char dt_type(struct kernfs_node *kn) 1728 { 1729 return (kn->mode >> 12) & 15; 1730 } 1731 1732 static int kernfs_dir_fop_release(struct inode *inode, struct file *filp) 1733 { 1734 kernfs_put(filp->private_data); 1735 return 0; 1736 } 1737 1738 static struct kernfs_node *kernfs_dir_pos(const void *ns, 1739 struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos) 1740 { 1741 if (pos) { 1742 int valid = kernfs_active(pos) && 1743 pos->parent == parent && hash == pos->hash; 1744 kernfs_put(pos); 1745 if (!valid) 1746 pos = NULL; 1747 } 1748 if (!pos && (hash > 1) && (hash < INT_MAX)) { 1749 struct rb_node *node = parent->dir.children.rb_node; 1750 while (node) { 1751 pos = rb_to_kn(node); 1752 1753 if (hash < pos->hash) 1754 node = node->rb_left; 1755 else if (hash > pos->hash) 1756 node = node->rb_right; 1757 else 1758 break; 1759 } 1760 } 1761 /* Skip over entries which are dying/dead or in the wrong namespace */ 1762 while (pos && (!kernfs_active(pos) || pos->ns != ns)) { 1763 struct rb_node *node = rb_next(&pos->rb); 1764 if (!node) 1765 pos = NULL; 1766 else 1767 pos = rb_to_kn(node); 1768 } 1769 return pos; 1770 } 1771 1772 static struct kernfs_node *kernfs_dir_next_pos(const void *ns, 1773 struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos) 1774 { 1775 pos = kernfs_dir_pos(ns, parent, ino, pos); 1776 if (pos) { 1777 do { 1778 struct rb_node *node = rb_next(&pos->rb); 1779 if (!node) 1780 pos = NULL; 1781 else 1782 pos = rb_to_kn(node); 1783 } while (pos && (!kernfs_active(pos) || pos->ns != ns)); 1784 } 1785 return pos; 1786 } 1787 1788 static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx) 1789 { 1790 struct dentry *dentry = file->f_path.dentry; 1791 struct kernfs_node *parent = kernfs_dentry_node(dentry); 1792 struct kernfs_node *pos = file->private_data; 1793 struct kernfs_root *root; 1794 const void *ns = NULL; 1795 1796 if (!dir_emit_dots(file, ctx)) 1797 return 0; 1798 1799 root = kernfs_root(parent); 1800 down_read(&root->kernfs_rwsem); 1801 1802 if (kernfs_ns_enabled(parent)) 1803 ns = kernfs_info(dentry->d_sb)->ns; 1804 1805 for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos); 1806 pos; 1807 pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) { 1808 const char *name = pos->name; 1809 unsigned int type = dt_type(pos); 1810 int len = strlen(name); 1811 ino_t ino = kernfs_ino(pos); 1812 1813 ctx->pos = pos->hash; 1814 file->private_data = pos; 1815 kernfs_get(pos); 1816 1817 up_read(&root->kernfs_rwsem); 1818 if (!dir_emit(ctx, name, len, ino, type)) 1819 return 0; 1820 down_read(&root->kernfs_rwsem); 1821 } 1822 up_read(&root->kernfs_rwsem); 1823 file->private_data = NULL; 1824 ctx->pos = INT_MAX; 1825 return 0; 1826 } 1827 1828 const struct file_operations kernfs_dir_fops = { 1829 .read = generic_read_dir, 1830 .iterate_shared = kernfs_fop_readdir, 1831 .release = kernfs_dir_fop_release, 1832 .llseek = generic_file_llseek, 1833 }; 1834