fs/kernfs/dir.c

   1 /*
   2  * fs/kernfs/dir.c - kernfs directory implementation
   3  *
   4  * Copyright (c) 2001-3 Patrick Mochel
   5  * Copyright (c) 2007 SUSE Linux Products GmbH
   6  * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
   7  *
   8  * This file is released under the GPLv2.
   9  */
  10
  11 #include <linux/sched.h>
  12 #include <linux/fs.h>
  13 #include <linux/namei.h>
  14 #include <linux/idr.h>
  15 #include <linux/slab.h>
  16 #include <linux/security.h>
  17 #include <linux/hash.h>
  18
  19 #include "kernfs-internal.h"
  20
  21 DEFINE_MUTEX(kernfs_mutex);
  22
  23 #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
  24
  25 static bool kernfs_active(struct kernfs_node *kn)
  26 {
  27         lockdep_assert_held(&kernfs_mutex);
  28         return atomic_read(&kn->active) >= 0;
  29 }
  30
  31 static bool kernfs_lockdep(struct kernfs_node *kn)
  32 {
  33 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  34         return kn->flags & KERNFS_LOCKDEP;
  35 #else
  36         return false;
  37 #endif
  38 }
  39
  40 /**
  41  *      kernfs_name_hash
  42  *      @name: Null terminated string to hash
  43  *      @ns:   Namespace tag to hash
  44  *
  45  *      Returns 31 bit hash of ns + name (so it fits in an off_t )
  46  */
  47 static unsigned int kernfs_name_hash(const char *name, const void *ns)
  48 {
  49         unsigned long hash = init_name_hash();
  50         unsigned int len = strlen(name);
  51         while (len--)
  52                 hash = partial_name_hash(*name++, hash);
  53         hash = (end_name_hash(hash) ^ hash_ptr((void *)ns, 31));
  54         hash &= 0x7fffffffU;
  55         /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
  56         if (hash < 1)
  57                 hash += 2;
  58         if (hash >= INT_MAX)
  59                 hash = INT_MAX - 1;
  60         return hash;
  61 }
  62
  63 static int kernfs_name_compare(unsigned int hash, const char *name,
  64                                const void *ns, const struct kernfs_node *kn)
  65 {
  66         if (hash != kn->hash)
  67                 return hash - kn->hash;
  68         if (ns != kn->ns)
  69                 return ns - kn->ns;
  70         return strcmp(name, kn->name);
  71 }
  72
  73 static int kernfs_sd_compare(const struct kernfs_node *left,
  74                              const struct kernfs_node *right)
  75 {
  76         return kernfs_name_compare(left->hash, left->name, left->ns, right);
  77 }
  78
  79 /**
  80  *      kernfs_link_sibling - link kernfs_node into sibling rbtree
  81  *      @kn: kernfs_node of interest
  82  *
  83  *      Link @kn into its sibling rbtree which starts from
  84  *      @kn->parent->dir.children.
  85  *
  86  *      Locking:
  87  *      mutex_lock(kernfs_mutex)
  88  *
  89  *      RETURNS:
  90  *      0 on susccess -EEXIST on failure.
  91  */
  92 static int kernfs_link_sibling(struct kernfs_node *kn)
  93 {
  94         struct rb_node **node = &kn->parent->dir.children.rb_node;
  95         struct rb_node *parent = NULL;
  96
  97         if (kernfs_type(kn) == KERNFS_DIR)
  98                 kn->parent->dir.subdirs++;
  99
 100         while (*node) {
 101                 struct kernfs_node *pos;
 102                 int result;
 103
 104                 pos = rb_to_kn(*node);
 105                 parent = *node;
 106                 result = kernfs_sd_compare(kn, pos);
 107                 if (result < 0)
 108                         node = &pos->rb.rb_left;
 109                 else if (result > 0)
 110                         node = &pos->rb.rb_right;
 111                 else
 112                         return -EEXIST;
 113         }
 114         /* add new node and rebalance the tree */
 115         rb_link_node(&kn->rb, parent, node);
 116         rb_insert_color(&kn->rb, &kn->parent->dir.children);
 117         return 0;
 118 }
 119
 120 /**
 121  *      kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree
 122  *      @kn: kernfs_node of interest
 123  *
 124  *      Try to unlink @kn from its sibling rbtree which starts from
 125  *      kn->parent->dir.children.  Returns %true if @kn was actually
 126  *      removed, %false if @kn wasn't on the rbtree.
 127  *
 128  *      Locking:
 129  *      mutex_lock(kernfs_mutex)
 130  */
 131 static bool kernfs_unlink_sibling(struct kernfs_node *kn)
 132 {
 133         if (RB_EMPTY_NODE(&kn->rb))
 134                 return false;
 135
 136         if (kernfs_type(kn) == KERNFS_DIR)
 137                 kn->parent->dir.subdirs--;
 138
 139         rb_erase(&kn->rb, &kn->parent->dir.children);
 140         RB_CLEAR_NODE(&kn->rb);
 141         return true;
 142 }
 143
 144 /**
 145  *      kernfs_get_active - get an active reference to kernfs_node
 146  *      @kn: kernfs_node to get an active reference to
 147  *
 148  *      Get an active reference of @kn.  This function is noop if @kn
 149  *      is NULL.
 150  *
 151  *      RETURNS:
 152  *      Pointer to @kn on success, NULL on failure.
 153  */
 154 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
 155 {
 156         if (unlikely(!kn))
 157                 return NULL;
 158
 159         if (!atomic_inc_unless_negative(&kn->active))
 160                 return NULL;
 161
 162         if (kernfs_lockdep(kn))
 163                 rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
 164         return kn;
 165 }
 166
 167 /**
 168  *      kernfs_put_active - put an active reference to kernfs_node
 169  *      @kn: kernfs_node to put an active reference to
 170  *
 171  *      Put an active reference to @kn.  This function is noop if @kn
 172  *      is NULL.
 173  */
 174 void kernfs_put_active(struct kernfs_node *kn)
 175 {
 176         struct kernfs_root *root = kernfs_root(kn);
 177         int v;
 178
 179         if (unlikely(!kn))
 180                 return;
 181
 182         if (kernfs_lockdep(kn))
 183                 rwsem_release(&kn->dep_map, 1, _RET_IP_);
 184         v = atomic_dec_return(&kn->active);
 185         if (likely(v != KN_DEACTIVATED_BIAS))
 186                 return;
 187
 188         wake_up_all(&root->deactivate_waitq);
 189 }
 190
 191 /**
 192  * kernfs_drain - drain kernfs_node
 193  * @kn: kernfs_node to drain
 194  *
 195  * Drain existing usages and nuke all existing mmaps of @kn.  Mutiple
 196  * removers may invoke this function concurrently on @kn and all will
 197  * return after draining is complete.
 198  */
 199 static void kernfs_drain(struct kernfs_node *kn)
 200         __releases(&kernfs_mutex) __acquires(&kernfs_mutex)
 201 {
 202         struct kernfs_root *root = kernfs_root(kn);
 203
 204         lockdep_assert_held(&kernfs_mutex);
 205         WARN_ON_ONCE(kernfs_active(kn));
 206
 207         mutex_unlock(&kernfs_mutex);
 208
 209         if (kernfs_lockdep(kn)) {
 210                 rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
 211                 if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
 212                         lock_contended(&kn->dep_map, _RET_IP_);
 213         }
 214
 215         /* but everyone should wait for draining */
 216         wait_event(root->deactivate_waitq,
 217                    atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
 218
 219         if (kernfs_lockdep(kn)) {
 220                 lock_acquired(&kn->dep_map, _RET_IP_);
 221                 rwsem_release(&kn->dep_map, 1, _RET_IP_);
 222         }
 223
 224         kernfs_unmap_bin_file(kn);
 225
 226         mutex_lock(&kernfs_mutex);
 227 }
 228
 229 /**
 230  * kernfs_get - get a reference count on a kernfs_node
 231  * @kn: the target kernfs_node
 232  */
 233 void kernfs_get(struct kernfs_node *kn)
 234 {
 235         if (kn) {
 236                 WARN_ON(!atomic_read(&kn->count));
 237                 atomic_inc(&kn->count);
 238         }
 239 }
 240 EXPORT_SYMBOL_GPL(kernfs_get);
 241
 242 /**
 243  * kernfs_put - put a reference count on a kernfs_node
 244  * @kn: the target kernfs_node
 245  *
 246  * Put a reference count of @kn and destroy it if it reached zero.
 247  */
 248 void kernfs_put(struct kernfs_node *kn)
 249 {
 250         struct kernfs_node *parent;
 251         struct kernfs_root *root;
 252
 253         if (!kn || !atomic_dec_and_test(&kn->count))
 254                 return;
 255         root = kernfs_root(kn);
 256  repeat:
 257         /*
 258          * Moving/renaming is always done while holding reference.
 259          * kn->parent won't change beneath us.
 260          */
 261         parent = kn->parent;
 262
 263         WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
 264                   "kernfs_put: %s/%s: released with incorrect active_ref %d\n",
 265                   parent ? parent->name : "", kn->name, atomic_read(&kn->active));
 266
 267         if (kernfs_type(kn) == KERNFS_LINK)
 268                 kernfs_put(kn->symlink.target_kn);
 269         if (!(kn->flags & KERNFS_STATIC_NAME))
 270                 kfree(kn->name);
 271         if (kn->iattr) {
 272                 if (kn->iattr->ia_secdata)
 273                         security_release_secctx(kn->iattr->ia_secdata,
 274                                                 kn->iattr->ia_secdata_len);
 275                 simple_xattrs_free(&kn->iattr->xattrs);
 276         }
 277         kfree(kn->iattr);
 278         ida_simple_remove(&root->ino_ida, kn->ino);
 279         kmem_cache_free(kernfs_node_cache, kn);
 280
 281         kn = parent;
 282         if (kn) {
 283                 if (atomic_dec_and_test(&kn->count))
 284                         goto repeat;
 285         } else {
 286                 /* just released the root kn, free @root too */
 287                 ida_destroy(&root->ino_ida);
 288                 kfree(root);
 289         }
 290 }
 291 EXPORT_SYMBOL_GPL(kernfs_put);
 292
 293 static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
 294 {
 295         struct kernfs_node *kn;
 296
 297         if (flags & LOOKUP_RCU)
 298                 return -ECHILD;
 299
 300         /* Always perform fresh lookup for negatives */
 301         if (!dentry->d_inode)
 302                 goto out_bad_unlocked;
 303
 304         kn = dentry->d_fsdata;
 305         mutex_lock(&kernfs_mutex);
 306
 307         /* The kernfs node has been deactivated */
 308         if (!kernfs_active(kn))
 309                 goto out_bad;
 310
 311         /* The kernfs node has been moved? */
 312         if (dentry->d_parent->d_fsdata != kn->parent)
 313                 goto out_bad;
 314
 315         /* The kernfs node has been renamed */
 316         if (strcmp(dentry->d_name.name, kn->name) != 0)
 317                 goto out_bad;
 318
 319         /* The kernfs node has been moved to a different namespace */
 320         if (kn->parent && kernfs_ns_enabled(kn->parent) &&
 321             kernfs_info(dentry->d_sb)->ns != kn->ns)
 322                 goto out_bad;
 323
 324         mutex_unlock(&kernfs_mutex);
 325 out_valid:
 326         return 1;
 327 out_bad:
 328         mutex_unlock(&kernfs_mutex);
 329 out_bad_unlocked:
 330         /*
 331          * @dentry doesn't match the underlying kernfs node, drop the
 332          * dentry and force lookup.  If we have submounts we must allow the
 333          * vfs caches to lie about the state of the filesystem to prevent
 334          * leaks and other nasty things, so use check_submounts_and_drop()
 335          * instead of d_drop().
 336          */
 337         if (check_submounts_and_drop(dentry) != 0)
 338                 goto out_valid;
 339
 340         return 0;
 341 }
 342
 343 static void kernfs_dop_release(struct dentry *dentry)
 344 {
 345         kernfs_put(dentry->d_fsdata);
 346 }
 347
 348 const struct dentry_operations kernfs_dops = {
 349         .d_revalidate   = kernfs_dop_revalidate,
 350         .d_release      = kernfs_dop_release,
 351 };
 352
 353 static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root,
 354                                              const char *name, umode_t mode,
 355                                              unsigned flags)
 356 {
 357         char *dup_name = NULL;
 358         struct kernfs_node *kn;
 359         int ret;
 360
 361         if (!(flags & KERNFS_STATIC_NAME)) {
 362                 name = dup_name = kstrdup(name, GFP_KERNEL);
 363                 if (!name)
 364                         return NULL;
 365         }
 366
 367         kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
 368         if (!kn)
 369                 goto err_out1;
 370
 371         ret = ida_simple_get(&root->ino_ida, 1, 0, GFP_KERNEL);
 372         if (ret < 0)
 373                 goto err_out2;
 374         kn->ino = ret;
 375
 376         atomic_set(&kn->count, 1);
 377         atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
 378         RB_CLEAR_NODE(&kn->rb);
 379
 380         kn->name = name;
 381         kn->mode = mode;
 382         kn->flags = flags;
 383
 384         return kn;
 385
 386  err_out2:
 387         kmem_cache_free(kernfs_node_cache, kn);
 388  err_out1:
 389         kfree(dup_name);
 390         return NULL;
 391 }
 392
 393 struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
 394                                     const char *name, umode_t mode,
 395                                     unsigned flags)
 396 {
 397         struct kernfs_node *kn;
 398
 399         kn = __kernfs_new_node(kernfs_root(parent), name, mode, flags);
 400         if (kn) {
 401                 kernfs_get(parent);
 402                 kn->parent = parent;
 403         }
 404         return kn;
 405 }
 406
 407 /**
 408  *      kernfs_add_one - add kernfs_node to parent without warning
 409  *      @kn: kernfs_node to be added
 410  *
 411  *      The caller must already have initialized @kn->parent.  This
 412  *      function increments nlink of the parent's inode if @kn is a
 413  *      directory and link into the children list of the parent.
 414  *
 415  *      RETURNS:
 416  *      0 on success, -EEXIST if entry with the given name already
 417  *      exists.
 418  */
 419 int kernfs_add_one(struct kernfs_node *kn)
 420 {
 421         struct kernfs_node *parent = kn->parent;
 422         struct kernfs_iattrs *ps_iattr;
 423         bool has_ns;
 424         int ret;
 425
 426         mutex_lock(&kernfs_mutex);
 427
 428         ret = -EINVAL;
 429         has_ns = kernfs_ns_enabled(parent);
 430         if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
 431                  has_ns ? "required" : "invalid", parent->name, kn->name))
 432                 goto out_unlock;
 433
 434         if (kernfs_type(parent) != KERNFS_DIR)
 435                 goto out_unlock;
 436
 437         ret = -ENOENT;
 438         if (!kernfs_active(parent))
 439                 goto out_unlock;
 440
 441         kn->hash = kernfs_name_hash(kn->name, kn->ns);
 442
 443         ret = kernfs_link_sibling(kn);
 444         if (ret)
 445                 goto out_unlock;
 446
 447         /* Update timestamps on the parent */
 448         ps_iattr = parent->iattr;
 449         if (ps_iattr) {
 450                 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
 451                 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
 452         }
 453
 454         /* Mark the entry added into directory tree */
 455         atomic_sub(KN_DEACTIVATED_BIAS, &kn->active);
 456         ret = 0;
 457 out_unlock:
 458         mutex_unlock(&kernfs_mutex);
 459         return ret;
 460 }
 461
 462 /**
 463  * kernfs_find_ns - find kernfs_node with the given name
 464  * @parent: kernfs_node to search under
 465  * @name: name to look for
 466  * @ns: the namespace tag to use
 467  *
 468  * Look for kernfs_node with name @name under @parent.  Returns pointer to
 469  * the found kernfs_node on success, %NULL on failure.
 470  */
 471 static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent,
 472                                           const unsigned char *name,
 473                                           const void *ns)
 474 {
 475         struct rb_node *node = parent->dir.children.rb_node;
 476         bool has_ns = kernfs_ns_enabled(parent);
 477         unsigned int hash;
 478
 479         lockdep_assert_held(&kernfs_mutex);
 480
 481         if (has_ns != (bool)ns) {
 482                 WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
 483                      has_ns ? "required" : "invalid", parent->name, name);
 484                 return NULL;
 485         }
 486
 487         hash = kernfs_name_hash(name, ns);
 488         while (node) {
 489                 struct kernfs_node *kn;
 490                 int result;
 491
 492                 kn = rb_to_kn(node);
 493                 result = kernfs_name_compare(hash, name, ns, kn);
 494                 if (result < 0)
 495                         node = node->rb_left;
 496                 else if (result > 0)
 497                         node = node->rb_right;
 498                 else
 499                         return kn;
 500         }
 501         return NULL;
 502 }
 503
 504 /**
 505  * kernfs_find_and_get_ns - find and get kernfs_node with the given name
 506  * @parent: kernfs_node to search under
 507  * @name: name to look for
 508  * @ns: the namespace tag to use
 509  *
 510  * Look for kernfs_node with name @name under @parent and get a reference
 511  * if found.  This function may sleep and returns pointer to the found
 512  * kernfs_node on success, %NULL on failure.
 513  */
 514 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
 515                                            const char *name, const void *ns)
 516 {
 517         struct kernfs_node *kn;
 518
 519         mutex_lock(&kernfs_mutex);
 520         kn = kernfs_find_ns(parent, name, ns);
 521         kernfs_get(kn);
 522         mutex_unlock(&kernfs_mutex);
 523
 524         return kn;
 525 }
 526 EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns);
 527
 528 /**
 529  * kernfs_create_root - create a new kernfs hierarchy
 530  * @kdops: optional directory syscall operations for the hierarchy
 531  * @priv: opaque data associated with the new directory
 532  *
 533  * Returns the root of the new hierarchy on success, ERR_PTR() value on
 534  * failure.
 535  */
 536 struct kernfs_root *kernfs_create_root(struct kernfs_dir_ops *kdops, void *priv)
 537 {
 538         struct kernfs_root *root;
 539         struct kernfs_node *kn;
 540
 541         root = kzalloc(sizeof(*root), GFP_KERNEL);
 542         if (!root)
 543                 return ERR_PTR(-ENOMEM);
 544
 545         ida_init(&root->ino_ida);
 546
 547         kn = __kernfs_new_node(root, "", S_IFDIR | S_IRUGO | S_IXUGO,
 548                                KERNFS_DIR);
 549         if (!kn) {
 550                 ida_destroy(&root->ino_ida);
 551                 kfree(root);
 552                 return ERR_PTR(-ENOMEM);
 553         }
 554
 555         atomic_sub(KN_DEACTIVATED_BIAS, &kn->active);
 556         kn->priv = priv;
 557         kn->dir.root = root;
 558
 559         root->dir_ops = kdops;
 560         root->kn = kn;
 561         init_waitqueue_head(&root->deactivate_waitq);
 562
 563         return root;
 564 }
 565
 566 /**
 567  * kernfs_destroy_root - destroy a kernfs hierarchy
 568  * @root: root of the hierarchy to destroy
 569  *
 570  * Destroy the hierarchy anchored at @root by removing all existing
 571  * directories and destroying @root.
 572  */
 573 void kernfs_destroy_root(struct kernfs_root *root)
 574 {
 575         kernfs_remove(root->kn);        /* will also free @root */
 576 }
 577
 578 /**
 579  * kernfs_create_dir_ns - create a directory
 580  * @parent: parent in which to create a new directory
 581  * @name: name of the new directory
 582  * @mode: mode of the new directory
 583  * @priv: opaque data associated with the new directory
 584  * @ns: optional namespace tag of the directory
 585  *
 586  * Returns the created node on success, ERR_PTR() value on failure.
 587  */
 588 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
 589                                          const char *name, umode_t mode,
 590                                          void *priv, const void *ns)
 591 {
 592         struct kernfs_node *kn;
 593         int rc;
 594
 595         /* allocate */
 596         kn = kernfs_new_node(parent, name, mode | S_IFDIR, KERNFS_DIR);
 597         if (!kn)
 598                 return ERR_PTR(-ENOMEM);
 599
 600         kn->dir.root = parent->dir.root;
 601         kn->ns = ns;
 602         kn->priv = priv;
 603
 604         /* link in */
 605         rc = kernfs_add_one(kn);
 606         if (!rc)
 607                 return kn;
 608
 609         kernfs_put(kn);
 610         return ERR_PTR(rc);
 611 }
 612
 613 static struct dentry *kernfs_iop_lookup(struct inode *dir,
 614                                         struct dentry *dentry,
 615                                         unsigned int flags)
 616 {
 617         struct dentry *ret;
 618         struct kernfs_node *parent = dentry->d_parent->d_fsdata;
 619         struct kernfs_node *kn;
 620         struct inode *inode;
 621         const void *ns = NULL;
 622
 623         mutex_lock(&kernfs_mutex);
 624
 625         if (kernfs_ns_enabled(parent))
 626                 ns = kernfs_info(dir->i_sb)->ns;
 627
 628         kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
 629
 630         /* no such entry */
 631         if (!kn) {
 632                 ret = NULL;
 633                 goto out_unlock;
 634         }
 635         kernfs_get(kn);
 636         dentry->d_fsdata = kn;
 637
 638         /* attach dentry and inode */
 639         inode = kernfs_get_inode(dir->i_sb, kn);
 640         if (!inode) {
 641                 ret = ERR_PTR(-ENOMEM);
 642                 goto out_unlock;
 643         }
 644
 645         /* instantiate and hash dentry */
 646         ret = d_materialise_unique(dentry, inode);
 647  out_unlock:
 648         mutex_unlock(&kernfs_mutex);
 649         return ret;
 650 }
 651
 652 static int kernfs_iop_mkdir(struct inode *dir, struct dentry *dentry,
 653                             umode_t mode)
 654 {
 655         struct kernfs_node *parent = dir->i_private;
 656         struct kernfs_dir_ops *kdops = kernfs_root(parent)->dir_ops;
 657
 658         if (!kdops || !kdops->mkdir)
 659                 return -EPERM;
 660
 661         return kdops->mkdir(parent, dentry->d_name.name, mode);
 662 }
 663
 664 static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry)
 665 {
 666         struct kernfs_node *kn  = dentry->d_fsdata;
 667         struct kernfs_dir_ops *kdops = kernfs_root(kn)->dir_ops;
 668
 669         if (!kdops || !kdops->rmdir)
 670                 return -EPERM;
 671
 672         return kdops->rmdir(kn);
 673 }
 674
 675 static int kernfs_iop_rename(struct inode *old_dir, struct dentry *old_dentry,
 676                              struct inode *new_dir, struct dentry *new_dentry)
 677 {
 678         struct kernfs_node *kn  = old_dentry->d_fsdata;
 679         struct kernfs_node *new_parent = new_dir->i_private;
 680         struct kernfs_dir_ops *kdops = kernfs_root(kn)->dir_ops;
 681
 682         if (!kdops || !kdops->rename)
 683                 return -EPERM;
 684
 685         return kdops->rename(kn, new_parent, new_dentry->d_name.name);
 686 }
 687
 688 const struct inode_operations kernfs_dir_iops = {
 689         .lookup         = kernfs_iop_lookup,
 690         .permission     = kernfs_iop_permission,
 691         .setattr        = kernfs_iop_setattr,
 692         .getattr        = kernfs_iop_getattr,
 693         .setxattr       = kernfs_iop_setxattr,
 694         .removexattr    = kernfs_iop_removexattr,
 695         .getxattr       = kernfs_iop_getxattr,
 696         .listxattr      = kernfs_iop_listxattr,
 697
 698         .mkdir          = kernfs_iop_mkdir,
 699         .rmdir          = kernfs_iop_rmdir,
 700         .rename         = kernfs_iop_rename,
 701 };
 702
 703 static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos)
 704 {
 705         struct kernfs_node *last;
 706
 707         while (true) {
 708                 struct rb_node *rbn;
 709
 710                 last = pos;
 711
 712                 if (kernfs_type(pos) != KERNFS_DIR)
 713                         break;
 714
 715                 rbn = rb_first(&pos->dir.children);
 716                 if (!rbn)
 717                         break;
 718
 719                 pos = rb_to_kn(rbn);
 720         }
 721
 722         return last;
 723 }
 724
 725 /**
 726  * kernfs_next_descendant_post - find the next descendant for post-order walk
 727  * @pos: the current position (%NULL to initiate traversal)
 728  * @root: kernfs_node whose descendants to walk
 729  *
 730  * Find the next descendant to visit for post-order traversal of @root's
 731  * descendants.  @root is included in the iteration and the last node to be
 732  * visited.
 733  */
 734 static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos,
 735                                                        struct kernfs_node *root)
 736 {
 737         struct rb_node *rbn;
 738
 739         lockdep_assert_held(&kernfs_mutex);
 740
 741         /* if first iteration, visit leftmost descendant which may be root */
 742         if (!pos)
 743                 return kernfs_leftmost_descendant(root);
 744
 745         /* if we visited @root, we're done */
 746         if (pos == root)
 747                 return NULL;
 748
 749         /* if there's an unvisited sibling, visit its leftmost descendant */
 750         rbn = rb_next(&pos->rb);
 751         if (rbn)
 752                 return kernfs_leftmost_descendant(rb_to_kn(rbn));
 753
 754         /* no sibling left, visit parent */
 755         return pos->parent;
 756 }
 757
 758 static void __kernfs_remove(struct kernfs_node *kn)
 759 {
 760         struct kernfs_node *pos;
 761
 762         lockdep_assert_held(&kernfs_mutex);
 763
 764         if (!kn)
 765                 return;
 766
 767         pr_debug("kernfs %s: removing\n", kn->name);
 768
 769         /* prevent any new usage under @kn by deactivating all nodes */
 770         pos = NULL;
 771         while ((pos = kernfs_next_descendant_post(pos, kn)))
 772                 if (kernfs_active(pos))
 773                         atomic_add(KN_DEACTIVATED_BIAS, &pos->active);
 774
 775         /* deactivate and unlink the subtree node-by-node */
 776         do {
 777                 pos = kernfs_leftmost_descendant(kn);
 778
 779                 /*
 780                  * kernfs_drain() drops kernfs_mutex temporarily and @pos's
 781                  * base ref could have been put by someone else by the time
 782                  * the function returns.  Make sure it doesn't go away
 783                  * underneath us.
 784                  */
 785                 kernfs_get(pos);
 786
 787                 kernfs_drain(pos);
 788
 789                 /*
 790                  * kernfs_unlink_sibling() succeeds once per node.  Use it
 791                  * to decide who's responsible for cleanups.
 792                  */
 793                 if (!pos->parent || kernfs_unlink_sibling(pos)) {
 794                         struct kernfs_iattrs *ps_iattr =
 795                                 pos->parent ? pos->parent->iattr : NULL;
 796
 797                         /* update timestamps on the parent */
 798                         if (ps_iattr) {
 799                                 ps_iattr->ia_iattr.ia_ctime = CURRENT_TIME;
 800                                 ps_iattr->ia_iattr.ia_mtime = CURRENT_TIME;
 801                         }
 802
 803                         kernfs_put(pos);
 804                 }
 805
 806                 kernfs_put(pos);
 807         } while (pos != kn);
 808 }
 809
 810 /**
 811  * kernfs_remove - remove a kernfs_node recursively
 812  * @kn: the kernfs_node to remove
 813  *
 814  * Remove @kn along with all its subdirectories and files.
 815  */
 816 void kernfs_remove(struct kernfs_node *kn)
 817 {
 818         mutex_lock(&kernfs_mutex);
 819         __kernfs_remove(kn);
 820         mutex_unlock(&kernfs_mutex);
 821 }
 822
 823 /**
 824  * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it
 825  * @parent: parent of the target
 826  * @name: name of the kernfs_node to remove
 827  * @ns: namespace tag of the kernfs_node to remove
 828  *
 829  * Look for the kernfs_node with @name and @ns under @parent and remove it.
 830  * Returns 0 on success, -ENOENT if such entry doesn't exist.
 831  */
 832 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
 833                              const void *ns)
 834 {
 835         struct kernfs_node *kn;
 836
 837         if (!parent) {
 838                 WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n",
 839                         name);
 840                 return -ENOENT;
 841         }
 842
 843         mutex_lock(&kernfs_mutex);
 844
 845         kn = kernfs_find_ns(parent, name, ns);
 846         if (kn)
 847                 __kernfs_remove(kn);
 848
 849         mutex_unlock(&kernfs_mutex);
 850
 851         if (kn)
 852                 return 0;
 853         else
 854                 return -ENOENT;
 855 }
 856
 857 /**
 858  * kernfs_rename_ns - move and rename a kernfs_node
 859  * @kn: target node
 860  * @new_parent: new parent to put @sd under
 861  * @new_name: new name
 862  * @new_ns: new namespace tag
 863  */
 864 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
 865                      const char *new_name, const void *new_ns)
 866 {
 867         int error;
 868
 869         mutex_lock(&kernfs_mutex);
 870
 871         error = -ENOENT;
 872         if (!kernfs_active(kn) || !kernfs_active(new_parent))
 873                 goto out;
 874
 875         error = 0;
 876         if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
 877             (strcmp(kn->name, new_name) == 0))
 878                 goto out;       /* nothing to rename */
 879
 880         error = -EEXIST;
 881         if (kernfs_find_ns(new_parent, new_name, new_ns))
 882                 goto out;
 883
 884         /* rename kernfs_node */
 885         if (strcmp(kn->name, new_name) != 0) {
 886                 error = -ENOMEM;
 887                 new_name = kstrdup(new_name, GFP_KERNEL);
 888                 if (!new_name)
 889                         goto out;
 890
 891                 if (kn->flags & KERNFS_STATIC_NAME)
 892                         kn->flags &= ~KERNFS_STATIC_NAME;
 893                 else
 894                         kfree(kn->name);
 895
 896                 kn->name = new_name;
 897         }
 898
 899         /*
 900          * Move to the appropriate place in the appropriate directories rbtree.
 901          */
 902         kernfs_unlink_sibling(kn);
 903         kernfs_get(new_parent);
 904         kernfs_put(kn->parent);
 905         kn->ns = new_ns;
 906         kn->hash = kernfs_name_hash(kn->name, kn->ns);
 907         kn->parent = new_parent;
 908         kernfs_link_sibling(kn);
 909
 910         error = 0;
 911  out:
 912         mutex_unlock(&kernfs_mutex);
 913         return error;
 914 }
 915
 916 /* Relationship between s_mode and the DT_xxx types */
 917 static inline unsigned char dt_type(struct kernfs_node *kn)
 918 {
 919         return (kn->mode >> 12) & 15;
 920 }
 921
 922 static int kernfs_dir_fop_release(struct inode *inode, struct file *filp)
 923 {
 924         kernfs_put(filp->private_data);
 925         return 0;
 926 }
 927
 928 static struct kernfs_node *kernfs_dir_pos(const void *ns,
 929         struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos)
 930 {
 931         if (pos) {
 932                 int valid = kernfs_active(pos) &&
 933                         pos->parent == parent && hash == pos->hash;
 934                 kernfs_put(pos);
 935                 if (!valid)
 936                         pos = NULL;
 937         }
 938         if (!pos && (hash > 1) && (hash < INT_MAX)) {
 939                 struct rb_node *node = parent->dir.children.rb_node;
 940                 while (node) {
 941                         pos = rb_to_kn(node);
 942
 943                         if (hash < pos->hash)
 944                                 node = node->rb_left;
 945                         else if (hash > pos->hash)
 946                                 node = node->rb_right;
 947                         else
 948                                 break;
 949                 }
 950         }
 951         /* Skip over entries in the wrong namespace */
 952         while (pos && pos->ns != ns) {
 953                 struct rb_node *node = rb_next(&pos->rb);
 954                 if (!node)
 955                         pos = NULL;
 956                 else
 957                         pos = rb_to_kn(node);
 958         }
 959         return pos;
 960 }
 961
 962 static struct kernfs_node *kernfs_dir_next_pos(const void *ns,
 963         struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos)
 964 {
 965         pos = kernfs_dir_pos(ns, parent, ino, pos);
 966         if (pos)
 967                 do {
 968                         struct rb_node *node = rb_next(&pos->rb);
 969                         if (!node)
 970                                 pos = NULL;
 971                         else
 972                                 pos = rb_to_kn(node);
 973                 } while (pos && pos->ns != ns);
 974         return pos;
 975 }
 976
 977 static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx)
 978 {
 979         struct dentry *dentry = file->f_path.dentry;
 980         struct kernfs_node *parent = dentry->d_fsdata;
 981         struct kernfs_node *pos = file->private_data;
 982         const void *ns = NULL;
 983
 984         if (!dir_emit_dots(file, ctx))
 985                 return 0;
 986         mutex_lock(&kernfs_mutex);
 987
 988         if (kernfs_ns_enabled(parent))
 989                 ns = kernfs_info(dentry->d_sb)->ns;
 990
 991         for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos);
 992              pos;
 993              pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) {
 994                 const char *name = pos->name;
 995                 unsigned int type = dt_type(pos);
 996                 int len = strlen(name);
 997                 ino_t ino = pos->ino;
 998
 999                 ctx->pos = pos->hash;
1000                 file->private_data = pos;
1001                 kernfs_get(pos);
1002
1003                 mutex_unlock(&kernfs_mutex);
1004                 if (!dir_emit(ctx, name, len, ino, type))
1005                         return 0;
1006                 mutex_lock(&kernfs_mutex);
1007         }
1008         mutex_unlock(&kernfs_mutex);
1009         file->private_data = NULL;
1010         ctx->pos = INT_MAX;
1011         return 0;
1012 }
1013
1014 static loff_t kernfs_dir_fop_llseek(struct file *file, loff_t offset,
1015                                     int whence)
1016 {
1017         struct inode *inode = file_inode(file);
1018         loff_t ret;
1019
1020         mutex_lock(&inode->i_mutex);
1021         ret = generic_file_llseek(file, offset, whence);
1022         mutex_unlock(&inode->i_mutex);
1023
1024         return ret;
1025 }
1026
1027 const struct file_operations kernfs_dir_fops = {
1028         .read           = generic_read_dir,
1029         .iterate        = kernfs_fop_readdir,
1030         .release        = kernfs_dir_fop_release,
1031         .llseek         = kernfs_dir_fop_llseek,
1032 };