LCOV - code coverage report
Current view: top level - fs/kernfs - dir.c (source / functions) Hit Total Coverage
Test: Real Lines: 364 509 71.5 %
Date: 2020-10-17 15:46:16 Functions: 0 49 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14