LCOV - code coverage report
Current view: top level - fs/kernfs - dir.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 454 681 66.7 %
Date: 2022-04-01 14:58:12 Functions: 36 48 75.0 %
Branches: 217 438 49.5 %

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

Generated by: LCOV version 1.14