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