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