LCOV - code coverage report
Current view: top level - lib - radix-tree.c (source / functions) Hit Total Coverage
Test: Real Lines: 305 426 71.6 %
Date: 2020-10-17 15:46:16 Functions: 0 41 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * Copyright (C) 2001 Momchil Velikov
       4                 :            :  * Portions Copyright (C) 2001 Christoph Hellwig
       5                 :            :  * Copyright (C) 2005 SGI, Christoph Lameter
       6                 :            :  * Copyright (C) 2006 Nick Piggin
       7                 :            :  * Copyright (C) 2012 Konstantin Khlebnikov
       8                 :            :  * Copyright (C) 2016 Intel, Matthew Wilcox
       9                 :            :  * Copyright (C) 2016 Intel, Ross Zwisler
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/bitmap.h>
      13                 :            : #include <linux/bitops.h>
      14                 :            : #include <linux/bug.h>
      15                 :            : #include <linux/cpu.h>
      16                 :            : #include <linux/errno.h>
      17                 :            : #include <linux/export.h>
      18                 :            : #include <linux/idr.h>
      19                 :            : #include <linux/init.h>
      20                 :            : #include <linux/kernel.h>
      21                 :            : #include <linux/kmemleak.h>
      22                 :            : #include <linux/percpu.h>
      23                 :            : #include <linux/preempt.h>                /* in_interrupt() */
      24                 :            : #include <linux/radix-tree.h>
      25                 :            : #include <linux/rcupdate.h>
      26                 :            : #include <linux/slab.h>
      27                 :            : #include <linux/string.h>
      28                 :            : #include <linux/xarray.h>
      29                 :            : 
      30                 :            : 
      31                 :            : /*
      32                 :            :  * Radix tree node cache.
      33                 :            :  */
      34                 :            : struct kmem_cache *radix_tree_node_cachep;
      35                 :            : 
      36                 :            : /*
      37                 :            :  * The radix tree is variable-height, so an insert operation not only has
      38                 :            :  * to build the branch to its corresponding item, it also has to build the
      39                 :            :  * branch to existing items if the size has to be increased (by
      40                 :            :  * radix_tree_extend).
      41                 :            :  *
      42                 :            :  * The worst case is a zero height tree with just a single item at index 0,
      43                 :            :  * and then inserting an item at index ULONG_MAX. This requires 2 new branches
      44                 :            :  * of RADIX_TREE_MAX_PATH size to be created, with only the root node shared.
      45                 :            :  * Hence:
      46                 :            :  */
      47                 :            : #define RADIX_TREE_PRELOAD_SIZE (RADIX_TREE_MAX_PATH * 2 - 1)
      48                 :            : 
      49                 :            : /*
      50                 :            :  * The IDR does not have to be as high as the radix tree since it uses
      51                 :            :  * signed integers, not unsigned longs.
      52                 :            :  */
      53                 :            : #define IDR_INDEX_BITS          (8 /* CHAR_BIT */ * sizeof(int) - 1)
      54                 :            : #define IDR_MAX_PATH            (DIV_ROUND_UP(IDR_INDEX_BITS, \
      55                 :            :                                                 RADIX_TREE_MAP_SHIFT))
      56                 :            : #define IDR_PRELOAD_SIZE        (IDR_MAX_PATH * 2 - 1)
      57                 :            : 
      58                 :            : /*
      59                 :            :  * The IDA is even shorter since it uses a bitmap at the last level.
      60                 :            :  */
      61                 :            : #define IDA_INDEX_BITS          (8 * sizeof(int) - 1 - ilog2(IDA_BITMAP_BITS))
      62                 :            : #define IDA_MAX_PATH            (DIV_ROUND_UP(IDA_INDEX_BITS, \
      63                 :            :                                                 RADIX_TREE_MAP_SHIFT))
      64                 :            : #define IDA_PRELOAD_SIZE        (IDA_MAX_PATH * 2 - 1)
      65                 :            : 
      66                 :            : /*
      67                 :            :  * Per-cpu pool of preloaded nodes
      68                 :            :  */
      69                 :            : struct radix_tree_preload {
      70                 :            :         unsigned nr;
      71                 :            :         /* nodes->parent points to next preallocated node */
      72                 :            :         struct radix_tree_node *nodes;
      73                 :            : };
      74                 :            : static DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, };
      75                 :            : 
      76                 :            : static inline struct radix_tree_node *entry_to_node(void *ptr)
      77                 :            : {
      78                 :          3 :         return (void *)((unsigned long)ptr & ~RADIX_TREE_INTERNAL_NODE);
      79                 :            : }
      80                 :            : 
      81                 :            : static inline void *node_to_entry(void *ptr)
      82                 :            : {
      83                 :          3 :         return (void *)((unsigned long)ptr | RADIX_TREE_INTERNAL_NODE);
      84                 :            : }
      85                 :            : 
      86                 :            : #define RADIX_TREE_RETRY        XA_RETRY_ENTRY
      87                 :            : 
      88                 :            : static inline unsigned long
      89                 :            : get_slot_offset(const struct radix_tree_node *parent, void __rcu **slot)
      90                 :            : {
      91                 :          3 :         return parent ? slot - parent->slots : 0;
      92                 :            : }
      93                 :            : 
      94                 :            : static unsigned int radix_tree_descend(const struct radix_tree_node *parent,
      95                 :            :                         struct radix_tree_node **nodep, unsigned long index)
      96                 :            : {
      97                 :          3 :         unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK;
      98                 :          3 :         void __rcu **entry = rcu_dereference_raw(parent->slots[offset]);
      99                 :            : 
     100                 :            :         *nodep = (void *)entry;
     101                 :            :         return offset;
     102                 :            : }
     103                 :            : 
     104                 :            : static inline gfp_t root_gfp_mask(const struct radix_tree_root *root)
     105                 :            : {
     106                 :          3 :         return root->xa_flags & (__GFP_BITS_MASK & ~GFP_ZONEMASK);
     107                 :            : }
     108                 :            : 
     109                 :            : static inline void tag_set(struct radix_tree_node *node, unsigned int tag,
     110                 :            :                 int offset)
     111                 :            : {
     112                 :          0 :         __set_bit(offset, node->tags[tag]);
     113                 :            : }
     114                 :            : 
     115                 :            : static inline void tag_clear(struct radix_tree_node *node, unsigned int tag,
     116                 :            :                 int offset)
     117                 :            : {
     118                 :            :         __clear_bit(offset, node->tags[tag]);
     119                 :            : }
     120                 :            : 
     121                 :            : static inline int tag_get(const struct radix_tree_node *node, unsigned int tag,
     122                 :            :                 int offset)
     123                 :            : {
     124                 :          3 :         return test_bit(offset, node->tags[tag]);
     125                 :            : }
     126                 :            : 
     127                 :            : static inline void root_tag_set(struct radix_tree_root *root, unsigned tag)
     128                 :            : {
     129                 :          3 :         root->xa_flags |= (__force gfp_t)(1 << (tag + ROOT_TAG_SHIFT));
     130                 :            : }
     131                 :            : 
     132                 :            : static inline void root_tag_clear(struct radix_tree_root *root, unsigned tag)
     133                 :            : {
     134                 :          0 :         root->xa_flags &= (__force gfp_t)~(1 << (tag + ROOT_TAG_SHIFT));
     135                 :            : }
     136                 :            : 
     137                 :            : static inline void root_tag_clear_all(struct radix_tree_root *root)
     138                 :            : {
     139                 :          0 :         root->xa_flags &= (__force gfp_t)((1 << ROOT_TAG_SHIFT) - 1);
     140                 :            : }
     141                 :            : 
     142                 :            : static inline int root_tag_get(const struct radix_tree_root *root, unsigned tag)
     143                 :            : {
     144                 :          3 :         return (__force int)root->xa_flags & (1 << (tag + ROOT_TAG_SHIFT));
     145                 :            : }
     146                 :            : 
     147                 :            : static inline unsigned root_tags_get(const struct radix_tree_root *root)
     148                 :            : {
     149                 :          3 :         return (__force unsigned)root->xa_flags >> ROOT_TAG_SHIFT;
     150                 :            : }
     151                 :            : 
     152                 :            : static inline bool is_idr(const struct radix_tree_root *root)
     153                 :            : {
     154                 :          3 :         return !!(root->xa_flags & ROOT_IS_IDR);
     155                 :            : }
     156                 :            : 
     157                 :            : /*
     158                 :            :  * Returns 1 if any slot in the node has this tag set.
     159                 :            :  * Otherwise returns 0.
     160                 :            :  */
     161                 :            : static inline int any_tag_set(const struct radix_tree_node *node,
     162                 :            :                                                         unsigned int tag)
     163                 :            : {
     164                 :            :         unsigned idx;
     165                 :          3 :         for (idx = 0; idx < RADIX_TREE_TAG_LONGS; idx++) {
     166                 :          3 :                 if (node->tags[tag][idx])
     167                 :            :                         return 1;
     168                 :            :         }
     169                 :            :         return 0;
     170                 :            : }
     171                 :            : 
     172                 :            : static inline void all_tag_set(struct radix_tree_node *node, unsigned int tag)
     173                 :            : {
     174                 :          3 :         bitmap_fill(node->tags[tag], RADIX_TREE_MAP_SIZE);
     175                 :            : }
     176                 :            : 
     177                 :            : /**
     178                 :            :  * radix_tree_find_next_bit - find the next set bit in a memory region
     179                 :            :  *
     180                 :            :  * @addr: The address to base the search on
     181                 :            :  * @size: The bitmap size in bits
     182                 :            :  * @offset: The bitnumber to start searching at
     183                 :            :  *
     184                 :            :  * Unrollable variant of find_next_bit() for constant size arrays.
     185                 :            :  * Tail bits starting from size to roundup(size, BITS_PER_LONG) must be zero.
     186                 :            :  * Returns next bit offset, or size if nothing found.
     187                 :            :  */
     188                 :            : static __always_inline unsigned long
     189                 :            : radix_tree_find_next_bit(struct radix_tree_node *node, unsigned int tag,
     190                 :            :                          unsigned long offset)
     191                 :            : {
     192                 :          0 :         const unsigned long *addr = node->tags[tag];
     193                 :            : 
     194                 :          3 :         if (offset < RADIX_TREE_MAP_SIZE) {
     195                 :            :                 unsigned long tmp;
     196                 :            : 
     197                 :          3 :                 addr += offset / BITS_PER_LONG;
     198                 :          3 :                 tmp = *addr >> (offset % BITS_PER_LONG);
     199                 :          3 :                 if (tmp)
     200                 :          3 :                         return __ffs(tmp) + offset;
     201                 :          3 :                 offset = (offset + BITS_PER_LONG) & ~(BITS_PER_LONG - 1);
     202                 :          3 :                 while (offset < RADIX_TREE_MAP_SIZE) {
     203                 :          3 :                         tmp = *++addr;
     204                 :          3 :                         if (tmp)
     205                 :          3 :                                 return __ffs(tmp) + offset;
     206                 :          0 :                         offset += BITS_PER_LONG;
     207                 :            :                 }
     208                 :            :         }
     209                 :            :         return RADIX_TREE_MAP_SIZE;
     210                 :            : }
     211                 :            : 
     212                 :            : static unsigned int iter_offset(const struct radix_tree_iter *iter)
     213                 :            : {
     214                 :          3 :         return iter->index & RADIX_TREE_MAP_MASK;
     215                 :            : }
     216                 :            : 
     217                 :            : /*
     218                 :            :  * The maximum index which can be stored in a radix tree
     219                 :            :  */
     220                 :            : static inline unsigned long shift_maxindex(unsigned int shift)
     221                 :            : {
     222                 :          3 :         return (RADIX_TREE_MAP_SIZE << shift) - 1;
     223                 :            : }
     224                 :            : 
     225                 :            : static inline unsigned long node_maxindex(const struct radix_tree_node *node)
     226                 :            : {
     227                 :          3 :         return shift_maxindex(node->shift);
     228                 :            : }
     229                 :            : 
     230                 :            : static unsigned long next_index(unsigned long index,
     231                 :            :                                 const struct radix_tree_node *node,
     232                 :            :                                 unsigned long offset)
     233                 :            : {
     234                 :          3 :         return (index & ~node_maxindex(node)) + (offset << node->shift);
     235                 :            : }
     236                 :            : 
     237                 :            : /*
     238                 :            :  * This assumes that the caller has performed appropriate preallocation, and
     239                 :            :  * that the caller has pinned this thread of control to the current CPU.
     240                 :            :  */
     241                 :            : static struct radix_tree_node *
     242                 :          3 : radix_tree_node_alloc(gfp_t gfp_mask, struct radix_tree_node *parent,
     243                 :            :                         struct radix_tree_root *root,
     244                 :            :                         unsigned int shift, unsigned int offset,
     245                 :            :                         unsigned int count, unsigned int nr_values)
     246                 :            : {
     247                 :            :         struct radix_tree_node *ret = NULL;
     248                 :            : 
     249                 :            :         /*
     250                 :            :          * Preload code isn't irq safe and it doesn't make sense to use
     251                 :            :          * preloading during an interrupt anyway as all the allocations have
     252                 :            :          * to be atomic. So just do normal allocation when in interrupt.
     253                 :            :          */
     254                 :          3 :         if (!gfpflags_allow_blocking(gfp_mask) && !in_interrupt()) {
     255                 :            :                 struct radix_tree_preload *rtp;
     256                 :            : 
     257                 :            :                 /*
     258                 :            :                  * Even if the caller has preloaded, try to allocate from the
     259                 :            :                  * cache first for the new node to get accounted to the memory
     260                 :            :                  * cgroup.
     261                 :            :                  */
     262                 :          3 :                 ret = kmem_cache_alloc(radix_tree_node_cachep,
     263                 :            :                                        gfp_mask | __GFP_NOWARN);
     264                 :          3 :                 if (ret)
     265                 :            :                         goto out;
     266                 :            : 
     267                 :            :                 /*
     268                 :            :                  * Provided the caller has preloaded here, we will always
     269                 :            :                  * succeed in getting a node here (and never reach
     270                 :            :                  * kmem_cache_alloc)
     271                 :            :                  */
     272                 :          0 :                 rtp = this_cpu_ptr(&radix_tree_preloads);
     273                 :          0 :                 if (rtp->nr) {
     274                 :          0 :                         ret = rtp->nodes;
     275                 :          0 :                         rtp->nodes = ret->parent;
     276                 :          0 :                         rtp->nr--;
     277                 :            :                 }
     278                 :            :                 /*
     279                 :            :                  * Update the allocation stack trace as this is more useful
     280                 :            :                  * for debugging.
     281                 :            :                  */
     282                 :            :                 kmemleak_update_trace(ret);
     283                 :            :                 goto out;
     284                 :            :         }
     285                 :          3 :         ret = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask);
     286                 :            : out:
     287                 :          3 :         BUG_ON(radix_tree_is_internal_node(ret));
     288                 :          3 :         if (ret) {
     289                 :          3 :                 ret->shift = shift;
     290                 :          3 :                 ret->offset = offset;
     291                 :          3 :                 ret->count = count;
     292                 :          3 :                 ret->nr_values = nr_values;
     293                 :          3 :                 ret->parent = parent;
     294                 :          3 :                 ret->array = root;
     295                 :            :         }
     296                 :          3 :         return ret;
     297                 :            : }
     298                 :            : 
     299                 :          3 : void radix_tree_node_rcu_free(struct rcu_head *head)
     300                 :            : {
     301                 :            :         struct radix_tree_node *node =
     302                 :          3 :                         container_of(head, struct radix_tree_node, rcu_head);
     303                 :            : 
     304                 :            :         /*
     305                 :            :          * Must only free zeroed nodes into the slab.  We can be left with
     306                 :            :          * non-NULL entries by radix_tree_free_nodes, so clear the entries
     307                 :            :          * and tags here.
     308                 :            :          */
     309                 :          3 :         memset(node->slots, 0, sizeof(node->slots));
     310                 :          3 :         memset(node->tags, 0, sizeof(node->tags));
     311                 :          3 :         INIT_LIST_HEAD(&node->private_list);
     312                 :            : 
     313                 :          3 :         kmem_cache_free(radix_tree_node_cachep, node);
     314                 :          3 : }
     315                 :            : 
     316                 :            : static inline void
     317                 :            : radix_tree_node_free(struct radix_tree_node *node)
     318                 :            : {
     319                 :          3 :         call_rcu(&node->rcu_head, radix_tree_node_rcu_free);
     320                 :            : }
     321                 :            : 
     322                 :            : /*
     323                 :            :  * Load up this CPU's radix_tree_node buffer with sufficient objects to
     324                 :            :  * ensure that the addition of a single element in the tree cannot fail.  On
     325                 :            :  * success, return zero, with preemption disabled.  On error, return -ENOMEM
     326                 :            :  * with preemption not disabled.
     327                 :            :  *
     328                 :            :  * To make use of this facility, the radix tree must be initialised without
     329                 :            :  * __GFP_DIRECT_RECLAIM being passed to INIT_RADIX_TREE().
     330                 :            :  */
     331                 :          3 : static __must_check int __radix_tree_preload(gfp_t gfp_mask, unsigned nr)
     332                 :            : {
     333                 :            :         struct radix_tree_preload *rtp;
     334                 :            :         struct radix_tree_node *node;
     335                 :            :         int ret = -ENOMEM;
     336                 :            : 
     337                 :            :         /*
     338                 :            :          * Nodes preloaded by one cgroup can be be used by another cgroup, so
     339                 :            :          * they should never be accounted to any particular memory cgroup.
     340                 :            :          */
     341                 :          3 :         gfp_mask &= ~__GFP_ACCOUNT;
     342                 :            : 
     343                 :          3 :         preempt_disable();
     344                 :          3 :         rtp = this_cpu_ptr(&radix_tree_preloads);
     345                 :          3 :         while (rtp->nr < nr) {
     346                 :          3 :                 preempt_enable();
     347                 :          3 :                 node = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask);
     348                 :          3 :                 if (node == NULL)
     349                 :            :                         goto out;
     350                 :          3 :                 preempt_disable();
     351                 :          3 :                 rtp = this_cpu_ptr(&radix_tree_preloads);
     352                 :          3 :                 if (rtp->nr < nr) {
     353                 :          3 :                         node->parent = rtp->nodes;
     354                 :          3 :                         rtp->nodes = node;
     355                 :          3 :                         rtp->nr++;
     356                 :            :                 } else {
     357                 :          0 :                         kmem_cache_free(radix_tree_node_cachep, node);
     358                 :            :                 }
     359                 :            :         }
     360                 :            :         ret = 0;
     361                 :            : out:
     362                 :          3 :         return ret;
     363                 :            : }
     364                 :            : 
     365                 :            : /*
     366                 :            :  * Load up this CPU's radix_tree_node buffer with sufficient objects to
     367                 :            :  * ensure that the addition of a single element in the tree cannot fail.  On
     368                 :            :  * success, return zero, with preemption disabled.  On error, return -ENOMEM
     369                 :            :  * with preemption not disabled.
     370                 :            :  *
     371                 :            :  * To make use of this facility, the radix tree must be initialised without
     372                 :            :  * __GFP_DIRECT_RECLAIM being passed to INIT_RADIX_TREE().
     373                 :            :  */
     374                 :          3 : int radix_tree_preload(gfp_t gfp_mask)
     375                 :            : {
     376                 :            :         /* Warn on non-sensical use... */
     377                 :          3 :         WARN_ON_ONCE(!gfpflags_allow_blocking(gfp_mask));
     378                 :          3 :         return __radix_tree_preload(gfp_mask, RADIX_TREE_PRELOAD_SIZE);
     379                 :            : }
     380                 :            : EXPORT_SYMBOL(radix_tree_preload);
     381                 :            : 
     382                 :            : /*
     383                 :            :  * The same as above function, except we don't guarantee preloading happens.
     384                 :            :  * We do it, if we decide it helps. On success, return zero with preemption
     385                 :            :  * disabled. On error, return -ENOMEM with preemption not disabled.
     386                 :            :  */
     387                 :          0 : int radix_tree_maybe_preload(gfp_t gfp_mask)
     388                 :            : {
     389                 :          0 :         if (gfpflags_allow_blocking(gfp_mask))
     390                 :          0 :                 return __radix_tree_preload(gfp_mask, RADIX_TREE_PRELOAD_SIZE);
     391                 :            :         /* Preloading doesn't help anything with this gfp mask, skip it */
     392                 :          0 :         preempt_disable();
     393                 :          0 :         return 0;
     394                 :            : }
     395                 :            : EXPORT_SYMBOL(radix_tree_maybe_preload);
     396                 :            : 
     397                 :            : static unsigned radix_tree_load_root(const struct radix_tree_root *root,
     398                 :            :                 struct radix_tree_node **nodep, unsigned long *maxindex)
     399                 :            : {
     400                 :          3 :         struct radix_tree_node *node = rcu_dereference_raw(root->xa_head);
     401                 :            : 
     402                 :            :         *nodep = node;
     403                 :            : 
     404                 :          3 :         if (likely(radix_tree_is_internal_node(node))) {
     405                 :            :                 node = entry_to_node(node);
     406                 :            :                 *maxindex = node_maxindex(node);
     407                 :          3 :                 return node->shift + RADIX_TREE_MAP_SHIFT;
     408                 :            :         }
     409                 :            : 
     410                 :            :         *maxindex = 0;
     411                 :            :         return 0;
     412                 :            : }
     413                 :            : 
     414                 :            : /*
     415                 :            :  *      Extend a radix tree so it can store key @index.
     416                 :            :  */
     417                 :          3 : static int radix_tree_extend(struct radix_tree_root *root, gfp_t gfp,
     418                 :            :                                 unsigned long index, unsigned int shift)
     419                 :            : {
     420                 :            :         void *entry;
     421                 :            :         unsigned int maxshift;
     422                 :            :         int tag;
     423                 :            : 
     424                 :            :         /* Figure out what the shift should be.  */
     425                 :            :         maxshift = shift;
     426                 :          3 :         while (index > shift_maxindex(maxshift))
     427                 :          0 :                 maxshift += RADIX_TREE_MAP_SHIFT;
     428                 :            : 
     429                 :            :         entry = rcu_dereference_raw(root->xa_head);
     430                 :          3 :         if (!entry && (!is_idr(root) || root_tag_get(root, IDR_FREE)))
     431                 :            :                 goto out;
     432                 :            : 
     433                 :            :         do {
     434                 :          3 :                 struct radix_tree_node *node = radix_tree_node_alloc(gfp, NULL,
     435                 :            :                                                         root, shift, 0, 1, 0);
     436                 :          3 :                 if (!node)
     437                 :            :                         return -ENOMEM;
     438                 :            : 
     439                 :          3 :                 if (is_idr(root)) {
     440                 :            :                         all_tag_set(node, IDR_FREE);
     441                 :          3 :                         if (!root_tag_get(root, IDR_FREE)) {
     442                 :            :                                 tag_clear(node, IDR_FREE, 0);
     443                 :            :                                 root_tag_set(root, IDR_FREE);
     444                 :            :                         }
     445                 :            :                 } else {
     446                 :            :                         /* Propagate the aggregated tag info to the new child */
     447                 :          3 :                         for (tag = 0; tag < RADIX_TREE_MAX_TAGS; tag++) {
     448                 :          3 :                                 if (root_tag_get(root, tag))
     449                 :            :                                         tag_set(node, tag, 0);
     450                 :            :                         }
     451                 :            :                 }
     452                 :            : 
     453                 :          3 :                 BUG_ON(shift > BITS_PER_LONG);
     454                 :          3 :                 if (radix_tree_is_internal_node(entry)) {
     455                 :          3 :                         entry_to_node(entry)->parent = node;
     456                 :          3 :                 } else if (xa_is_value(entry)) {
     457                 :            :                         /* Moving a value entry root->xa_head to a node */
     458                 :          0 :                         node->nr_values = 1;
     459                 :            :                 }
     460                 :            :                 /*
     461                 :            :                  * entry was already in the radix tree, so we do not need
     462                 :            :                  * rcu_assign_pointer here
     463                 :            :                  */
     464                 :          3 :                 node->slots[0] = (void __rcu *)entry;
     465                 :            :                 entry = node_to_entry(node);
     466                 :          3 :                 rcu_assign_pointer(root->xa_head, entry);
     467                 :          3 :                 shift += RADIX_TREE_MAP_SHIFT;
     468                 :          3 :         } while (shift <= maxshift);
     469                 :            : out:
     470                 :          3 :         return maxshift + RADIX_TREE_MAP_SHIFT;
     471                 :            : }
     472                 :            : 
     473                 :            : /**
     474                 :            :  *      radix_tree_shrink    -    shrink radix tree to minimum height
     475                 :            :  *      @root           radix tree root
     476                 :            :  */
     477                 :          3 : static inline bool radix_tree_shrink(struct radix_tree_root *root)
     478                 :            : {
     479                 :            :         bool shrunk = false;
     480                 :            : 
     481                 :            :         for (;;) {
     482                 :            :                 struct radix_tree_node *node = rcu_dereference_raw(root->xa_head);
     483                 :            :                 struct radix_tree_node *child;
     484                 :            : 
     485                 :          3 :                 if (!radix_tree_is_internal_node(node))
     486                 :            :                         break;
     487                 :            :                 node = entry_to_node(node);
     488                 :            : 
     489                 :            :                 /*
     490                 :            :                  * The candidate node has more than one child, or its child
     491                 :            :                  * is not at the leftmost slot, we cannot shrink.
     492                 :            :                  */
     493                 :          3 :                 if (node->count != 1)
     494                 :            :                         break;
     495                 :            :                 child = rcu_dereference_raw(node->slots[0]);
     496                 :          3 :                 if (!child)
     497                 :            :                         break;
     498                 :            : 
     499                 :            :                 /*
     500                 :            :                  * For an IDR, we must not shrink entry 0 into the root in
     501                 :            :                  * case somebody calls idr_replace() with a pointer that
     502                 :            :                  * appears to be an internal entry
     503                 :            :                  */
     504                 :          3 :                 if (!node->shift && is_idr(root))
     505                 :            :                         break;
     506                 :            : 
     507                 :          3 :                 if (radix_tree_is_internal_node(child))
     508                 :          3 :                         entry_to_node(child)->parent = NULL;
     509                 :            : 
     510                 :            :                 /*
     511                 :            :                  * We don't need rcu_assign_pointer(), since we are simply
     512                 :            :                  * moving the node from one part of the tree to another: if it
     513                 :            :                  * was safe to dereference the old pointer to it
     514                 :            :                  * (node->slots[0]), it will be safe to dereference the new
     515                 :            :                  * one (root->xa_head) as far as dependent read barriers go.
     516                 :            :                  */
     517                 :          3 :                 root->xa_head = (void __rcu *)child;
     518                 :          3 :                 if (is_idr(root) && !tag_get(node, IDR_FREE, 0))
     519                 :            :                         root_tag_clear(root, IDR_FREE);
     520                 :            : 
     521                 :            :                 /*
     522                 :            :                  * We have a dilemma here. The node's slot[0] must not be
     523                 :            :                  * NULLed in case there are concurrent lookups expecting to
     524                 :            :                  * find the item. However if this was a bottom-level node,
     525                 :            :                  * then it may be subject to the slot pointer being visible
     526                 :            :                  * to callers dereferencing it. If item corresponding to
     527                 :            :                  * slot[0] is subsequently deleted, these callers would expect
     528                 :            :                  * their slot to become empty sooner or later.
     529                 :            :                  *
     530                 :            :                  * For example, lockless pagecache will look up a slot, deref
     531                 :            :                  * the page pointer, and if the page has 0 refcount it means it
     532                 :            :                  * was concurrently deleted from pagecache so try the deref
     533                 :            :                  * again. Fortunately there is already a requirement for logic
     534                 :            :                  * to retry the entire slot lookup -- the indirect pointer
     535                 :            :                  * problem (replacing direct root node with an indirect pointer
     536                 :            :                  * also results in a stale slot). So tag the slot as indirect
     537                 :            :                  * to force callers to retry.
     538                 :            :                  */
     539                 :          3 :                 node->count = 0;
     540                 :          3 :                 if (!radix_tree_is_internal_node(child)) {
     541                 :          0 :                         node->slots[0] = (void __rcu *)RADIX_TREE_RETRY;
     542                 :            :                 }
     543                 :            : 
     544                 :          3 :                 WARN_ON_ONCE(!list_empty(&node->private_list));
     545                 :            :                 radix_tree_node_free(node);
     546                 :            :                 shrunk = true;
     547                 :            :         }
     548                 :            : 
     549                 :          3 :         return shrunk;
     550                 :            : }
     551                 :            : 
     552                 :          3 : static bool delete_node(struct radix_tree_root *root,
     553                 :            :                         struct radix_tree_node *node)
     554                 :            : {
     555                 :            :         bool deleted = false;
     556                 :            : 
     557                 :            :         do {
     558                 :            :                 struct radix_tree_node *parent;
     559                 :            : 
     560                 :          3 :                 if (node->count) {
     561                 :          3 :                         if (node_to_entry(node) ==
     562                 :            :                                         rcu_dereference_raw(root->xa_head))
     563                 :          3 :                                 deleted |= radix_tree_shrink(root);
     564                 :          3 :                         return deleted;
     565                 :            :                 }
     566                 :            : 
     567                 :          3 :                 parent = node->parent;
     568                 :          3 :                 if (parent) {
     569                 :          3 :                         parent->slots[node->offset] = NULL;
     570                 :          3 :                         parent->count--;
     571                 :            :                 } else {
     572                 :            :                         /*
     573                 :            :                          * Shouldn't the tags already have all been cleared
     574                 :            :                          * by the caller?
     575                 :            :                          */
     576                 :          3 :                         if (!is_idr(root))
     577                 :            :                                 root_tag_clear_all(root);
     578                 :          3 :                         root->xa_head = NULL;
     579                 :            :                 }
     580                 :            : 
     581                 :          3 :                 WARN_ON_ONCE(!list_empty(&node->private_list));
     582                 :            :                 radix_tree_node_free(node);
     583                 :            :                 deleted = true;
     584                 :            : 
     585                 :            :                 node = parent;
     586                 :          3 :         } while (node);
     587                 :            : 
     588                 :            :         return deleted;
     589                 :            : }
     590                 :            : 
     591                 :            : /**
     592                 :            :  *      __radix_tree_create     -       create a slot in a radix tree
     593                 :            :  *      @root:          radix tree root
     594                 :            :  *      @index:         index key
     595                 :            :  *      @nodep:         returns node
     596                 :            :  *      @slotp:         returns slot
     597                 :            :  *
     598                 :            :  *      Create, if necessary, and return the node and slot for an item
     599                 :            :  *      at position @index in the radix tree @root.
     600                 :            :  *
     601                 :            :  *      Until there is more than one item in the tree, no nodes are
     602                 :            :  *      allocated and @root->xa_head is used as a direct slot instead of
     603                 :            :  *      pointing to a node, in which case *@nodep will be NULL.
     604                 :            :  *
     605                 :            :  *      Returns -ENOMEM, or 0 for success.
     606                 :            :  */
     607                 :          3 : static int __radix_tree_create(struct radix_tree_root *root,
     608                 :            :                 unsigned long index, struct radix_tree_node **nodep,
     609                 :            :                 void __rcu ***slotp)
     610                 :            : {
     611                 :            :         struct radix_tree_node *node = NULL, *child;
     612                 :          3 :         void __rcu **slot = (void __rcu **)&root->xa_head;
     613                 :            :         unsigned long maxindex;
     614                 :            :         unsigned int shift, offset = 0;
     615                 :            :         unsigned long max = index;
     616                 :            :         gfp_t gfp = root_gfp_mask(root);
     617                 :            : 
     618                 :            :         shift = radix_tree_load_root(root, &child, &maxindex);
     619                 :            : 
     620                 :            :         /* Make sure the tree is high enough.  */
     621                 :          3 :         if (max > maxindex) {
     622                 :          3 :                 int error = radix_tree_extend(root, gfp, max, shift);
     623                 :          3 :                 if (error < 0)
     624                 :            :                         return error;
     625                 :          3 :                 shift = error;
     626                 :            :                 child = rcu_dereference_raw(root->xa_head);
     627                 :            :         }
     628                 :            : 
     629                 :          3 :         while (shift > 0) {
     630                 :          3 :                 shift -= RADIX_TREE_MAP_SHIFT;
     631                 :          3 :                 if (child == NULL) {
     632                 :            :                         /* Have to add a child node.  */
     633                 :          3 :                         child = radix_tree_node_alloc(gfp, node, root, shift,
     634                 :            :                                                         offset, 0, 0);
     635                 :          3 :                         if (!child)
     636                 :            :                                 return -ENOMEM;
     637                 :          3 :                         rcu_assign_pointer(*slot, node_to_entry(child));
     638                 :          3 :                         if (node)
     639                 :          3 :                                 node->count++;
     640                 :          3 :                 } else if (!radix_tree_is_internal_node(child))
     641                 :            :                         break;
     642                 :            : 
     643                 :            :                 /* Go a level down */
     644                 :            :                 node = entry_to_node(child);
     645                 :            :                 offset = radix_tree_descend(node, &child, index);
     646                 :            :                 slot = &node->slots[offset];
     647                 :            :         }
     648                 :            : 
     649                 :          3 :         if (nodep)
     650                 :          3 :                 *nodep = node;
     651                 :          3 :         if (slotp)
     652                 :          3 :                 *slotp = slot;
     653                 :            :         return 0;
     654                 :            : }
     655                 :            : 
     656                 :            : /*
     657                 :            :  * Free any nodes below this node.  The tree is presumed to not need
     658                 :            :  * shrinking, and any user data in the tree is presumed to not need a
     659                 :            :  * destructor called on it.  If we need to add a destructor, we can
     660                 :            :  * add that functionality later.  Note that we may not clear tags or
     661                 :            :  * slots from the tree as an RCU walker may still have a pointer into
     662                 :            :  * this subtree.  We could replace the entries with RADIX_TREE_RETRY,
     663                 :            :  * but we'll still have to clear those in rcu_free.
     664                 :            :  */
     665                 :          0 : static void radix_tree_free_nodes(struct radix_tree_node *node)
     666                 :            : {
     667                 :            :         unsigned offset = 0;
     668                 :            :         struct radix_tree_node *child = entry_to_node(node);
     669                 :            : 
     670                 :            :         for (;;) {
     671                 :          0 :                 void *entry = rcu_dereference_raw(child->slots[offset]);
     672                 :          0 :                 if (xa_is_node(entry) && child->shift) {
     673                 :            :                         child = entry_to_node(entry);
     674                 :            :                         offset = 0;
     675                 :          0 :                         continue;
     676                 :            :                 }
     677                 :          0 :                 offset++;
     678                 :          0 :                 while (offset == RADIX_TREE_MAP_SIZE) {
     679                 :            :                         struct radix_tree_node *old = child;
     680                 :          0 :                         offset = child->offset + 1;
     681                 :          0 :                         child = child->parent;
     682                 :          0 :                         WARN_ON_ONCE(!list_empty(&old->private_list));
     683                 :            :                         radix_tree_node_free(old);
     684                 :          0 :                         if (old == entry_to_node(node))
     685                 :          0 :                                 return;
     686                 :            :                 }
     687                 :            :         }
     688                 :            : }
     689                 :            : 
     690                 :            : static inline int insert_entries(struct radix_tree_node *node,
     691                 :            :                 void __rcu **slot, void *item, bool replace)
     692                 :            : {
     693                 :          3 :         if (*slot)
     694                 :            :                 return -EEXIST;
     695                 :          3 :         rcu_assign_pointer(*slot, item);
     696                 :          3 :         if (node) {
     697                 :          3 :                 node->count++;
     698                 :          3 :                 if (xa_is_value(item))
     699                 :          0 :                         node->nr_values++;
     700                 :            :         }
     701                 :            :         return 1;
     702                 :            : }
     703                 :            : 
     704                 :            : /**
     705                 :            :  *      __radix_tree_insert    -    insert into a radix tree
     706                 :            :  *      @root:          radix tree root
     707                 :            :  *      @index:         index key
     708                 :            :  *      @item:          item to insert
     709                 :            :  *
     710                 :            :  *      Insert an item into the radix tree at position @index.
     711                 :            :  */
     712                 :          3 : int radix_tree_insert(struct radix_tree_root *root, unsigned long index,
     713                 :            :                         void *item)
     714                 :            : {
     715                 :            :         struct radix_tree_node *node;
     716                 :            :         void __rcu **slot;
     717                 :            :         int error;
     718                 :            : 
     719                 :          3 :         BUG_ON(radix_tree_is_internal_node(item));
     720                 :            : 
     721                 :          3 :         error = __radix_tree_create(root, index, &node, &slot);
     722                 :          3 :         if (error)
     723                 :            :                 return error;
     724                 :            : 
     725                 :          3 :         error = insert_entries(node, slot, item, false);
     726                 :          3 :         if (error < 0)
     727                 :            :                 return error;
     728                 :            : 
     729                 :          3 :         if (node) {
     730                 :          3 :                 unsigned offset = get_slot_offset(node, slot);
     731                 :          3 :                 BUG_ON(tag_get(node, 0, offset));
     732                 :          3 :                 BUG_ON(tag_get(node, 1, offset));
     733                 :          3 :                 BUG_ON(tag_get(node, 2, offset));
     734                 :            :         } else {
     735                 :          3 :                 BUG_ON(root_tags_get(root));
     736                 :            :         }
     737                 :            : 
     738                 :            :         return 0;
     739                 :            : }
     740                 :            : EXPORT_SYMBOL(radix_tree_insert);
     741                 :            : 
     742                 :            : /**
     743                 :            :  *      __radix_tree_lookup     -       lookup an item in a radix tree
     744                 :            :  *      @root:          radix tree root
     745                 :            :  *      @index:         index key
     746                 :            :  *      @nodep:         returns node
     747                 :            :  *      @slotp:         returns slot
     748                 :            :  *
     749                 :            :  *      Lookup and return the item at position @index in the radix
     750                 :            :  *      tree @root.
     751                 :            :  *
     752                 :            :  *      Until there is more than one item in the tree, no nodes are
     753                 :            :  *      allocated and @root->xa_head is used as a direct slot instead of
     754                 :            :  *      pointing to a node, in which case *@nodep will be NULL.
     755                 :            :  */
     756                 :          3 : void *__radix_tree_lookup(const struct radix_tree_root *root,
     757                 :            :                           unsigned long index, struct radix_tree_node **nodep,
     758                 :            :                           void __rcu ***slotp)
     759                 :            : {
     760                 :            :         struct radix_tree_node *node, *parent;
     761                 :            :         unsigned long maxindex;
     762                 :            :         void __rcu **slot;
     763                 :            : 
     764                 :            :  restart:
     765                 :            :         parent = NULL;
     766                 :          3 :         slot = (void __rcu **)&root->xa_head;
     767                 :            :         radix_tree_load_root(root, &node, &maxindex);
     768                 :          3 :         if (index > maxindex)
     769                 :            :                 return NULL;
     770                 :            : 
     771                 :          3 :         while (radix_tree_is_internal_node(node)) {
     772                 :            :                 unsigned offset;
     773                 :            : 
     774                 :            :                 parent = entry_to_node(node);
     775                 :            :                 offset = radix_tree_descend(parent, &node, index);
     776                 :            :                 slot = parent->slots + offset;
     777                 :          3 :                 if (node == RADIX_TREE_RETRY)
     778                 :            :                         goto restart;
     779                 :          3 :                 if (parent->shift == 0)
     780                 :            :                         break;
     781                 :            :         }
     782                 :            : 
     783                 :          3 :         if (nodep)
     784                 :          3 :                 *nodep = parent;
     785                 :          3 :         if (slotp)
     786                 :          3 :                 *slotp = slot;
     787                 :          3 :         return node;
     788                 :            : }
     789                 :            : 
     790                 :            : /**
     791                 :            :  *      radix_tree_lookup_slot    -    lookup a slot in a radix tree
     792                 :            :  *      @root:          radix tree root
     793                 :            :  *      @index:         index key
     794                 :            :  *
     795                 :            :  *      Returns:  the slot corresponding to the position @index in the
     796                 :            :  *      radix tree @root. This is useful for update-if-exists operations.
     797                 :            :  *
     798                 :            :  *      This function can be called under rcu_read_lock iff the slot is not
     799                 :            :  *      modified by radix_tree_replace_slot, otherwise it must be called
     800                 :            :  *      exclusive from other writers. Any dereference of the slot must be done
     801                 :            :  *      using radix_tree_deref_slot.
     802                 :            :  */
     803                 :          0 : void __rcu **radix_tree_lookup_slot(const struct radix_tree_root *root,
     804                 :            :                                 unsigned long index)
     805                 :            : {
     806                 :            :         void __rcu **slot;
     807                 :            : 
     808                 :          0 :         if (!__radix_tree_lookup(root, index, NULL, &slot))
     809                 :            :                 return NULL;
     810                 :          0 :         return slot;
     811                 :            : }
     812                 :            : EXPORT_SYMBOL(radix_tree_lookup_slot);
     813                 :            : 
     814                 :            : /**
     815                 :            :  *      radix_tree_lookup    -    perform lookup operation on a radix tree
     816                 :            :  *      @root:          radix tree root
     817                 :            :  *      @index:         index key
     818                 :            :  *
     819                 :            :  *      Lookup the item at the position @index in the radix tree @root.
     820                 :            :  *
     821                 :            :  *      This function can be called under rcu_read_lock, however the caller
     822                 :            :  *      must manage lifetimes of leaf nodes (eg. RCU may also be used to free
     823                 :            :  *      them safely). No RCU barriers are required to access or modify the
     824                 :            :  *      returned item, however.
     825                 :            :  */
     826                 :          3 : void *radix_tree_lookup(const struct radix_tree_root *root, unsigned long index)
     827                 :            : {
     828                 :          3 :         return __radix_tree_lookup(root, index, NULL, NULL);
     829                 :            : }
     830                 :            : EXPORT_SYMBOL(radix_tree_lookup);
     831                 :            : 
     832                 :            : static void replace_slot(void __rcu **slot, void *item,
     833                 :            :                 struct radix_tree_node *node, int count, int values)
     834                 :            : {
     835                 :          3 :         if (node && (count || values)) {
     836                 :          3 :                 node->count += count;
     837                 :          3 :                 node->nr_values += values;
     838                 :            :         }
     839                 :            : 
     840                 :          3 :         rcu_assign_pointer(*slot, item);
     841                 :            : }
     842                 :            : 
     843                 :            : static bool node_tag_get(const struct radix_tree_root *root,
     844                 :            :                                 const struct radix_tree_node *node,
     845                 :            :                                 unsigned int tag, unsigned int offset)
     846                 :            : {
     847                 :          3 :         if (node)
     848                 :          3 :                 return tag_get(node, tag, offset);
     849                 :          0 :         return root_tag_get(root, tag);
     850                 :            : }
     851                 :            : 
     852                 :            : /*
     853                 :            :  * IDR users want to be able to store NULL in the tree, so if the slot isn't
     854                 :            :  * free, don't adjust the count, even if it's transitioning between NULL and
     855                 :            :  * non-NULL.  For the IDA, we mark slots as being IDR_FREE while they still
     856                 :            :  * have empty bits, but it only stores NULL in slots when they're being
     857                 :            :  * deleted.
     858                 :            :  */
     859                 :          3 : static int calculate_count(struct radix_tree_root *root,
     860                 :            :                                 struct radix_tree_node *node, void __rcu **slot,
     861                 :            :                                 void *item, void *old)
     862                 :            : {
     863                 :          3 :         if (is_idr(root)) {
     864                 :            :                 unsigned offset = get_slot_offset(node, slot);
     865                 :            :                 bool free = node_tag_get(root, node, IDR_FREE, offset);
     866                 :          3 :                 if (!free)
     867                 :            :                         return 0;
     868                 :          3 :                 if (!old)
     869                 :            :                         return 1;
     870                 :            :         }
     871                 :          0 :         return !!item - !!old;
     872                 :            : }
     873                 :            : 
     874                 :            : /**
     875                 :            :  * __radix_tree_replace         - replace item in a slot
     876                 :            :  * @root:               radix tree root
     877                 :            :  * @node:               pointer to tree node
     878                 :            :  * @slot:               pointer to slot in @node
     879                 :            :  * @item:               new item to store in the slot.
     880                 :            :  *
     881                 :            :  * For use with __radix_tree_lookup().  Caller must hold tree write locked
     882                 :            :  * across slot lookup and replacement.
     883                 :            :  */
     884                 :          3 : void __radix_tree_replace(struct radix_tree_root *root,
     885                 :            :                           struct radix_tree_node *node,
     886                 :            :                           void __rcu **slot, void *item)
     887                 :            : {
     888                 :            :         void *old = rcu_dereference_raw(*slot);
     889                 :          3 :         int values = !!xa_is_value(item) - !!xa_is_value(old);
     890                 :          3 :         int count = calculate_count(root, node, slot, item, old);
     891                 :            : 
     892                 :            :         /*
     893                 :            :          * This function supports replacing value entries and
     894                 :            :          * deleting entries, but that needs accounting against the
     895                 :            :          * node unless the slot is root->xa_head.
     896                 :            :          */
     897                 :          3 :         WARN_ON_ONCE(!node && (slot != (void __rcu **)&root->xa_head) &&
     898                 :            :                         (count || values));
     899                 :            :         replace_slot(slot, item, node, count, values);
     900                 :            : 
     901                 :          3 :         if (!node)
     902                 :          3 :                 return;
     903                 :            : 
     904                 :          3 :         delete_node(root, node);
     905                 :            : }
     906                 :            : 
     907                 :            : /**
     908                 :            :  * radix_tree_replace_slot      - replace item in a slot
     909                 :            :  * @root:       radix tree root
     910                 :            :  * @slot:       pointer to slot
     911                 :            :  * @item:       new item to store in the slot.
     912                 :            :  *
     913                 :            :  * For use with radix_tree_lookup_slot() and
     914                 :            :  * radix_tree_gang_lookup_tag_slot().  Caller must hold tree write locked
     915                 :            :  * across slot lookup and replacement.
     916                 :            :  *
     917                 :            :  * NOTE: This cannot be used to switch between non-entries (empty slots),
     918                 :            :  * regular entries, and value entries, as that requires accounting
     919                 :            :  * inside the radix tree node. When switching from one type of entry or
     920                 :            :  * deleting, use __radix_tree_lookup() and __radix_tree_replace() or
     921                 :            :  * radix_tree_iter_replace().
     922                 :            :  */
     923                 :          0 : void radix_tree_replace_slot(struct radix_tree_root *root,
     924                 :            :                              void __rcu **slot, void *item)
     925                 :            : {
     926                 :          0 :         __radix_tree_replace(root, NULL, slot, item);
     927                 :          0 : }
     928                 :            : EXPORT_SYMBOL(radix_tree_replace_slot);
     929                 :            : 
     930                 :            : /**
     931                 :            :  * radix_tree_iter_replace - replace item in a slot
     932                 :            :  * @root:       radix tree root
     933                 :            :  * @slot:       pointer to slot
     934                 :            :  * @item:       new item to store in the slot.
     935                 :            :  *
     936                 :            :  * For use with radix_tree_for_each_slot().
     937                 :            :  * Caller must hold tree write locked.
     938                 :            :  */
     939                 :          3 : void radix_tree_iter_replace(struct radix_tree_root *root,
     940                 :            :                                 const struct radix_tree_iter *iter,
     941                 :            :                                 void __rcu **slot, void *item)
     942                 :            : {
     943                 :          3 :         __radix_tree_replace(root, iter->node, slot, item);
     944                 :          3 : }
     945                 :            : 
     946                 :          3 : static void node_tag_set(struct radix_tree_root *root,
     947                 :            :                                 struct radix_tree_node *node,
     948                 :            :                                 unsigned int tag, unsigned int offset)
     949                 :            : {
     950                 :          3 :         while (node) {
     951                 :          3 :                 if (tag_get(node, tag, offset))
     952                 :          3 :                         return;
     953                 :            :                 tag_set(node, tag, offset);
     954                 :          3 :                 offset = node->offset;
     955                 :          3 :                 node = node->parent;
     956                 :            :         }
     957                 :            : 
     958                 :          3 :         if (!root_tag_get(root, tag))
     959                 :            :                 root_tag_set(root, tag);
     960                 :            : }
     961                 :            : 
     962                 :            : /**
     963                 :            :  *      radix_tree_tag_set - set a tag on a radix tree node
     964                 :            :  *      @root:          radix tree root
     965                 :            :  *      @index:         index key
     966                 :            :  *      @tag:           tag index
     967                 :            :  *
     968                 :            :  *      Set the search tag (which must be < RADIX_TREE_MAX_TAGS)
     969                 :            :  *      corresponding to @index in the radix tree.  From
     970                 :            :  *      the root all the way down to the leaf node.
     971                 :            :  *
     972                 :            :  *      Returns the address of the tagged item.  Setting a tag on a not-present
     973                 :            :  *      item is a bug.
     974                 :            :  */
     975                 :          0 : void *radix_tree_tag_set(struct radix_tree_root *root,
     976                 :            :                         unsigned long index, unsigned int tag)
     977                 :            : {
     978                 :            :         struct radix_tree_node *node, *parent;
     979                 :            :         unsigned long maxindex;
     980                 :            : 
     981                 :            :         radix_tree_load_root(root, &node, &maxindex);
     982                 :          0 :         BUG_ON(index > maxindex);
     983                 :            : 
     984                 :          0 :         while (radix_tree_is_internal_node(node)) {
     985                 :            :                 unsigned offset;
     986                 :            : 
     987                 :            :                 parent = entry_to_node(node);
     988                 :            :                 offset = radix_tree_descend(parent, &node, index);
     989                 :          0 :                 BUG_ON(!node);
     990                 :            : 
     991                 :          0 :                 if (!tag_get(parent, tag, offset))
     992                 :            :                         tag_set(parent, tag, offset);
     993                 :            :         }
     994                 :            : 
     995                 :            :         /* set the root's tag bit */
     996                 :          0 :         if (!root_tag_get(root, tag))
     997                 :            :                 root_tag_set(root, tag);
     998                 :            : 
     999                 :          0 :         return node;
    1000                 :            : }
    1001                 :            : EXPORT_SYMBOL(radix_tree_tag_set);
    1002                 :            : 
    1003                 :          3 : static void node_tag_clear(struct radix_tree_root *root,
    1004                 :            :                                 struct radix_tree_node *node,
    1005                 :            :                                 unsigned int tag, unsigned int offset)
    1006                 :            : {
    1007                 :          3 :         while (node) {
    1008                 :          3 :                 if (!tag_get(node, tag, offset))
    1009                 :            :                         return;
    1010                 :            :                 tag_clear(node, tag, offset);
    1011                 :          3 :                 if (any_tag_set(node, tag))
    1012                 :            :                         return;
    1013                 :            : 
    1014                 :          3 :                 offset = node->offset;
    1015                 :          3 :                 node = node->parent;
    1016                 :            :         }
    1017                 :            : 
    1018                 :            :         /* clear the root's tag bit */
    1019                 :          0 :         if (root_tag_get(root, tag))
    1020                 :            :                 root_tag_clear(root, tag);
    1021                 :            : }
    1022                 :            : 
    1023                 :            : /**
    1024                 :            :  *      radix_tree_tag_clear - clear a tag on a radix tree node
    1025                 :            :  *      @root:          radix tree root
    1026                 :            :  *      @index:         index key
    1027                 :            :  *      @tag:           tag index
    1028                 :            :  *
    1029                 :            :  *      Clear the search tag (which must be < RADIX_TREE_MAX_TAGS)
    1030                 :            :  *      corresponding to @index in the radix tree.  If this causes
    1031                 :            :  *      the leaf node to have no tags set then clear the tag in the
    1032                 :            :  *      next-to-leaf node, etc.
    1033                 :            :  *
    1034                 :            :  *      Returns the address of the tagged item on success, else NULL.  ie:
    1035                 :            :  *      has the same return value and semantics as radix_tree_lookup().
    1036                 :            :  */
    1037                 :          0 : void *radix_tree_tag_clear(struct radix_tree_root *root,
    1038                 :            :                         unsigned long index, unsigned int tag)
    1039                 :            : {
    1040                 :            :         struct radix_tree_node *node, *parent;
    1041                 :            :         unsigned long maxindex;
    1042                 :            :         int uninitialized_var(offset);
    1043                 :            : 
    1044                 :            :         radix_tree_load_root(root, &node, &maxindex);
    1045                 :          0 :         if (index > maxindex)
    1046                 :            :                 return NULL;
    1047                 :            : 
    1048                 :            :         parent = NULL;
    1049                 :            : 
    1050                 :          0 :         while (radix_tree_is_internal_node(node)) {
    1051                 :            :                 parent = entry_to_node(node);
    1052                 :          0 :                 offset = radix_tree_descend(parent, &node, index);
    1053                 :            :         }
    1054                 :            : 
    1055                 :          0 :         if (node)
    1056                 :          0 :                 node_tag_clear(root, parent, tag, offset);
    1057                 :            : 
    1058                 :          0 :         return node;
    1059                 :            : }
    1060                 :            : EXPORT_SYMBOL(radix_tree_tag_clear);
    1061                 :            : 
    1062                 :            : /**
    1063                 :            :   * radix_tree_iter_tag_clear - clear a tag on the current iterator entry
    1064                 :            :   * @root: radix tree root
    1065                 :            :   * @iter: iterator state
    1066                 :            :   * @tag: tag to clear
    1067                 :            :   */
    1068                 :          3 : void radix_tree_iter_tag_clear(struct radix_tree_root *root,
    1069                 :            :                         const struct radix_tree_iter *iter, unsigned int tag)
    1070                 :            : {
    1071                 :          3 :         node_tag_clear(root, iter->node, tag, iter_offset(iter));
    1072                 :          3 : }
    1073                 :            : 
    1074                 :            : /**
    1075                 :            :  * radix_tree_tag_get - get a tag on a radix tree node
    1076                 :            :  * @root:               radix tree root
    1077                 :            :  * @index:              index key
    1078                 :            :  * @tag:                tag index (< RADIX_TREE_MAX_TAGS)
    1079                 :            :  *
    1080                 :            :  * Return values:
    1081                 :            :  *
    1082                 :            :  *  0: tag not present or not set
    1083                 :            :  *  1: tag set
    1084                 :            :  *
    1085                 :            :  * Note that the return value of this function may not be relied on, even if
    1086                 :            :  * the RCU lock is held, unless tag modification and node deletion are excluded
    1087                 :            :  * from concurrency.
    1088                 :            :  */
    1089                 :          3 : int radix_tree_tag_get(const struct radix_tree_root *root,
    1090                 :            :                         unsigned long index, unsigned int tag)
    1091                 :            : {
    1092                 :            :         struct radix_tree_node *node, *parent;
    1093                 :            :         unsigned long maxindex;
    1094                 :            : 
    1095                 :          3 :         if (!root_tag_get(root, tag))
    1096                 :            :                 return 0;
    1097                 :            : 
    1098                 :            :         radix_tree_load_root(root, &node, &maxindex);
    1099                 :          3 :         if (index > maxindex)
    1100                 :            :                 return 0;
    1101                 :            : 
    1102                 :          3 :         while (radix_tree_is_internal_node(node)) {
    1103                 :            :                 unsigned offset;
    1104                 :            : 
    1105                 :            :                 parent = entry_to_node(node);
    1106                 :            :                 offset = radix_tree_descend(parent, &node, index);
    1107                 :            : 
    1108                 :          3 :                 if (!tag_get(parent, tag, offset))
    1109                 :            :                         return 0;
    1110                 :          3 :                 if (node == RADIX_TREE_RETRY)
    1111                 :            :                         break;
    1112                 :            :         }
    1113                 :            : 
    1114                 :            :         return 1;
    1115                 :            : }
    1116                 :            : EXPORT_SYMBOL(radix_tree_tag_get);
    1117                 :            : 
    1118                 :            : /* Construct iter->tags bit-mask from node->tags[tag] array */
    1119                 :          3 : static void set_iter_tags(struct radix_tree_iter *iter,
    1120                 :            :                                 struct radix_tree_node *node, unsigned offset,
    1121                 :            :                                 unsigned tag)
    1122                 :            : {
    1123                 :          3 :         unsigned tag_long = offset / BITS_PER_LONG;
    1124                 :          3 :         unsigned tag_bit  = offset % BITS_PER_LONG;
    1125                 :            : 
    1126                 :          3 :         if (!node) {
    1127                 :          0 :                 iter->tags = 1;
    1128                 :          3 :                 return;
    1129                 :            :         }
    1130                 :            : 
    1131                 :          3 :         iter->tags = node->tags[tag][tag_long] >> tag_bit;
    1132                 :            : 
    1133                 :            :         /* This never happens if RADIX_TREE_TAG_LONGS == 1 */
    1134                 :          3 :         if (tag_long < RADIX_TREE_TAG_LONGS - 1) {
    1135                 :            :                 /* Pick tags from next element */
    1136                 :          3 :                 if (tag_bit)
    1137                 :          3 :                         iter->tags |= node->tags[tag][tag_long + 1] <<
    1138                 :          3 :                                                 (BITS_PER_LONG - tag_bit);
    1139                 :            :                 /* Clip chunk size, here only BITS_PER_LONG tags */
    1140                 :          3 :                 iter->next_index = __radix_tree_iter_add(iter, BITS_PER_LONG);
    1141                 :            :         }
    1142                 :            : }
    1143                 :            : 
    1144                 :          0 : void __rcu **radix_tree_iter_resume(void __rcu **slot,
    1145                 :            :                                         struct radix_tree_iter *iter)
    1146                 :            : {
    1147                 :            :         slot++;
    1148                 :          0 :         iter->index = __radix_tree_iter_add(iter, 1);
    1149                 :          0 :         iter->next_index = iter->index;
    1150                 :          0 :         iter->tags = 0;
    1151                 :          0 :         return NULL;
    1152                 :            : }
    1153                 :            : EXPORT_SYMBOL(radix_tree_iter_resume);
    1154                 :            : 
    1155                 :            : /**
    1156                 :            :  * radix_tree_next_chunk - find next chunk of slots for iteration
    1157                 :            :  *
    1158                 :            :  * @root:       radix tree root
    1159                 :            :  * @iter:       iterator state
    1160                 :            :  * @flags:      RADIX_TREE_ITER_* flags and tag index
    1161                 :            :  * Returns:     pointer to chunk first slot, or NULL if iteration is over
    1162                 :            :  */
    1163                 :          3 : void __rcu **radix_tree_next_chunk(const struct radix_tree_root *root,
    1164                 :            :                              struct radix_tree_iter *iter, unsigned flags)
    1165                 :            : {
    1166                 :          3 :         unsigned tag = flags & RADIX_TREE_ITER_TAG_MASK;
    1167                 :            :         struct radix_tree_node *node, *child;
    1168                 :            :         unsigned long index, offset, maxindex;
    1169                 :            : 
    1170                 :          3 :         if ((flags & RADIX_TREE_ITER_TAGGED) && !root_tag_get(root, tag))
    1171                 :            :                 return NULL;
    1172                 :            : 
    1173                 :            :         /*
    1174                 :            :          * Catch next_index overflow after ~0UL. iter->index never overflows
    1175                 :            :          * during iterating; it can be zero only at the beginning.
    1176                 :            :          * And we cannot overflow iter->next_index in a single step,
    1177                 :            :          * because RADIX_TREE_MAP_SHIFT < BITS_PER_LONG.
    1178                 :            :          *
    1179                 :            :          * This condition also used by radix_tree_next_slot() to stop
    1180                 :            :          * contiguous iterating, and forbid switching to the next chunk.
    1181                 :            :          */
    1182                 :          3 :         index = iter->next_index;
    1183                 :          3 :         if (!index && iter->index)
    1184                 :            :                 return NULL;
    1185                 :            : 
    1186                 :            :  restart:
    1187                 :            :         radix_tree_load_root(root, &child, &maxindex);
    1188                 :          3 :         if (index > maxindex)
    1189                 :            :                 return NULL;
    1190                 :          3 :         if (!child)
    1191                 :            :                 return NULL;
    1192                 :            : 
    1193                 :          3 :         if (!radix_tree_is_internal_node(child)) {
    1194                 :            :                 /* Single-slot tree */
    1195                 :          0 :                 iter->index = index;
    1196                 :          0 :                 iter->next_index = maxindex + 1;
    1197                 :          0 :                 iter->tags = 1;
    1198                 :          0 :                 iter->node = NULL;
    1199                 :          0 :                 return (void __rcu **)&root->xa_head;
    1200                 :            :         }
    1201                 :            : 
    1202                 :            :         do {
    1203                 :            :                 node = entry_to_node(child);
    1204                 :            :                 offset = radix_tree_descend(node, &child, index);
    1205                 :            : 
    1206                 :          3 :                 if ((flags & RADIX_TREE_ITER_TAGGED) ?
    1207                 :          0 :                                 !tag_get(node, tag, offset) : !child) {
    1208                 :            :                         /* Hole detected */
    1209                 :          3 :                         if (flags & RADIX_TREE_ITER_CONTIG)
    1210                 :            :                                 return NULL;
    1211                 :            : 
    1212                 :          3 :                         if (flags & RADIX_TREE_ITER_TAGGED)
    1213                 :          0 :                                 offset = radix_tree_find_next_bit(node, tag,
    1214                 :            :                                                 offset + 1);
    1215                 :            :                         else
    1216                 :          3 :                                 while (++offset < RADIX_TREE_MAP_SIZE) {
    1217                 :          3 :                                         void *slot = rcu_dereference_raw(
    1218                 :            :                                                         node->slots[offset]);
    1219                 :          3 :                                         if (slot)
    1220                 :            :                                                 break;
    1221                 :            :                                 }
    1222                 :          3 :                         index &= ~node_maxindex(node);
    1223                 :          3 :                         index += offset << node->shift;
    1224                 :            :                         /* Overflow after ~0UL */
    1225                 :          3 :                         if (!index)
    1226                 :            :                                 return NULL;
    1227                 :          3 :                         if (offset == RADIX_TREE_MAP_SIZE)
    1228                 :            :                                 goto restart;
    1229                 :          3 :                         child = rcu_dereference_raw(node->slots[offset]);
    1230                 :            :                 }
    1231                 :            : 
    1232                 :          3 :                 if (!child)
    1233                 :            :                         goto restart;
    1234                 :          3 :                 if (child == RADIX_TREE_RETRY)
    1235                 :            :                         break;
    1236                 :          3 :         } while (node->shift && radix_tree_is_internal_node(child));
    1237                 :            : 
    1238                 :            :         /* Update the iterator state */
    1239                 :          3 :         iter->index = (index &~ node_maxindex(node)) | offset;
    1240                 :          3 :         iter->next_index = (index | node_maxindex(node)) + 1;
    1241                 :          3 :         iter->node = node;
    1242                 :            : 
    1243                 :          3 :         if (flags & RADIX_TREE_ITER_TAGGED)
    1244                 :          0 :                 set_iter_tags(iter, node, offset, tag);
    1245                 :            : 
    1246                 :          3 :         return node->slots + offset;
    1247                 :            : }
    1248                 :            : EXPORT_SYMBOL(radix_tree_next_chunk);
    1249                 :            : 
    1250                 :            : /**
    1251                 :            :  *      radix_tree_gang_lookup - perform multiple lookup on a radix tree
    1252                 :            :  *      @root:          radix tree root
    1253                 :            :  *      @results:       where the results of the lookup are placed
    1254                 :            :  *      @first_index:   start the lookup from this key
    1255                 :            :  *      @max_items:     place up to this many items at *results
    1256                 :            :  *
    1257                 :            :  *      Performs an index-ascending scan of the tree for present items.  Places
    1258                 :            :  *      them at *@results and returns the number of items which were placed at
    1259                 :            :  *      *@results.
    1260                 :            :  *
    1261                 :            :  *      The implementation is naive.
    1262                 :            :  *
    1263                 :            :  *      Like radix_tree_lookup, radix_tree_gang_lookup may be called under
    1264                 :            :  *      rcu_read_lock. In this case, rather than the returned results being
    1265                 :            :  *      an atomic snapshot of the tree at a single point in time, the
    1266                 :            :  *      semantics of an RCU protected gang lookup are as though multiple
    1267                 :            :  *      radix_tree_lookups have been issued in individual locks, and results
    1268                 :            :  *      stored in 'results'.
    1269                 :            :  */
    1270                 :            : unsigned int
    1271                 :          0 : radix_tree_gang_lookup(const struct radix_tree_root *root, void **results,
    1272                 :            :                         unsigned long first_index, unsigned int max_items)
    1273                 :            : {
    1274                 :            :         struct radix_tree_iter iter;
    1275                 :            :         void __rcu **slot;
    1276                 :            :         unsigned int ret = 0;
    1277                 :            : 
    1278                 :          0 :         if (unlikely(!max_items))
    1279                 :            :                 return 0;
    1280                 :            : 
    1281                 :          0 :         radix_tree_for_each_slot(slot, root, &iter, first_index) {
    1282                 :          0 :                 results[ret] = rcu_dereference_raw(*slot);
    1283                 :          0 :                 if (!results[ret])
    1284                 :          0 :                         continue;
    1285                 :          0 :                 if (radix_tree_is_internal_node(results[ret])) {
    1286                 :            :                         slot = radix_tree_iter_retry(&iter);
    1287                 :          0 :                         continue;
    1288                 :            :                 }
    1289                 :          0 :                 if (++ret == max_items)
    1290                 :            :                         break;
    1291                 :            :         }
    1292                 :            : 
    1293                 :          0 :         return ret;
    1294                 :            : }
    1295                 :            : EXPORT_SYMBOL(radix_tree_gang_lookup);
    1296                 :            : 
    1297                 :            : /**
    1298                 :            :  *      radix_tree_gang_lookup_tag - perform multiple lookup on a radix tree
    1299                 :            :  *                                   based on a tag
    1300                 :            :  *      @root:          radix tree root
    1301                 :            :  *      @results:       where the results of the lookup are placed
    1302                 :            :  *      @first_index:   start the lookup from this key
    1303                 :            :  *      @max_items:     place up to this many items at *results
    1304                 :            :  *      @tag:           the tag index (< RADIX_TREE_MAX_TAGS)
    1305                 :            :  *
    1306                 :            :  *      Performs an index-ascending scan of the tree for present items which
    1307                 :            :  *      have the tag indexed by @tag set.  Places the items at *@results and
    1308                 :            :  *      returns the number of items which were placed at *@results.
    1309                 :            :  */
    1310                 :            : unsigned int
    1311                 :          0 : radix_tree_gang_lookup_tag(const struct radix_tree_root *root, void **results,
    1312                 :            :                 unsigned long first_index, unsigned int max_items,
    1313                 :            :                 unsigned int tag)
    1314                 :            : {
    1315                 :            :         struct radix_tree_iter iter;
    1316                 :            :         void __rcu **slot;
    1317                 :            :         unsigned int ret = 0;
    1318                 :            : 
    1319                 :          0 :         if (unlikely(!max_items))
    1320                 :            :                 return 0;
    1321                 :            : 
    1322                 :          0 :         radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) {
    1323                 :          0 :                 results[ret] = rcu_dereference_raw(*slot);
    1324                 :          0 :                 if (!results[ret])
    1325                 :          0 :                         continue;
    1326                 :          0 :                 if (radix_tree_is_internal_node(results[ret])) {
    1327                 :            :                         slot = radix_tree_iter_retry(&iter);
    1328                 :          0 :                         continue;
    1329                 :            :                 }
    1330                 :          0 :                 if (++ret == max_items)
    1331                 :            :                         break;
    1332                 :            :         }
    1333                 :            : 
    1334                 :          0 :         return ret;
    1335                 :            : }
    1336                 :            : EXPORT_SYMBOL(radix_tree_gang_lookup_tag);
    1337                 :            : 
    1338                 :            : /**
    1339                 :            :  *      radix_tree_gang_lookup_tag_slot - perform multiple slot lookup on a
    1340                 :            :  *                                        radix tree based on a tag
    1341                 :            :  *      @root:          radix tree root
    1342                 :            :  *      @results:       where the results of the lookup are placed
    1343                 :            :  *      @first_index:   start the lookup from this key
    1344                 :            :  *      @max_items:     place up to this many items at *results
    1345                 :            :  *      @tag:           the tag index (< RADIX_TREE_MAX_TAGS)
    1346                 :            :  *
    1347                 :            :  *      Performs an index-ascending scan of the tree for present items which
    1348                 :            :  *      have the tag indexed by @tag set.  Places the slots at *@results and
    1349                 :            :  *      returns the number of slots which were placed at *@results.
    1350                 :            :  */
    1351                 :            : unsigned int
    1352                 :          0 : radix_tree_gang_lookup_tag_slot(const struct radix_tree_root *root,
    1353                 :            :                 void __rcu ***results, unsigned long first_index,
    1354                 :            :                 unsigned int max_items, unsigned int tag)
    1355                 :            : {
    1356                 :            :         struct radix_tree_iter iter;
    1357                 :            :         void __rcu **slot;
    1358                 :            :         unsigned int ret = 0;
    1359                 :            : 
    1360                 :          0 :         if (unlikely(!max_items))
    1361                 :            :                 return 0;
    1362                 :            : 
    1363                 :          0 :         radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) {
    1364                 :          0 :                 results[ret] = slot;
    1365                 :          0 :                 if (++ret == max_items)
    1366                 :            :                         break;
    1367                 :            :         }
    1368                 :            : 
    1369                 :          0 :         return ret;
    1370                 :            : }
    1371                 :            : EXPORT_SYMBOL(radix_tree_gang_lookup_tag_slot);
    1372                 :            : 
    1373                 :          3 : static bool __radix_tree_delete(struct radix_tree_root *root,
    1374                 :            :                                 struct radix_tree_node *node, void __rcu **slot)
    1375                 :            : {
    1376                 :            :         void *old = rcu_dereference_raw(*slot);
    1377                 :          3 :         int values = xa_is_value(old) ? -1 : 0;
    1378                 :            :         unsigned offset = get_slot_offset(node, slot);
    1379                 :            :         int tag;
    1380                 :            : 
    1381                 :          3 :         if (is_idr(root))
    1382                 :          3 :                 node_tag_set(root, node, IDR_FREE, offset);
    1383                 :            :         else
    1384                 :          0 :                 for (tag = 0; tag < RADIX_TREE_MAX_TAGS; tag++)
    1385                 :          0 :                         node_tag_clear(root, node, tag, offset);
    1386                 :            : 
    1387                 :            :         replace_slot(slot, NULL, node, -1, values);
    1388                 :          3 :         return node && delete_node(root, node);
    1389                 :            : }
    1390                 :            : 
    1391                 :            : /**
    1392                 :            :  * radix_tree_iter_delete - delete the entry at this iterator position
    1393                 :            :  * @root: radix tree root
    1394                 :            :  * @iter: iterator state
    1395                 :            :  * @slot: pointer to slot
    1396                 :            :  *
    1397                 :            :  * Delete the entry at the position currently pointed to by the iterator.
    1398                 :            :  * This may result in the current node being freed; if it is, the iterator
    1399                 :            :  * is advanced so that it will not reference the freed memory.  This
    1400                 :            :  * function may be called without any locking if there are no other threads
    1401                 :            :  * which can access this tree.
    1402                 :            :  */
    1403                 :          0 : void radix_tree_iter_delete(struct radix_tree_root *root,
    1404                 :            :                                 struct radix_tree_iter *iter, void __rcu **slot)
    1405                 :            : {
    1406                 :          0 :         if (__radix_tree_delete(root, iter->node, slot))
    1407                 :          0 :                 iter->index = iter->next_index;
    1408                 :          0 : }
    1409                 :            : EXPORT_SYMBOL(radix_tree_iter_delete);
    1410                 :            : 
    1411                 :            : /**
    1412                 :            :  * radix_tree_delete_item - delete an item from a radix tree
    1413                 :            :  * @root: radix tree root
    1414                 :            :  * @index: index key
    1415                 :            :  * @item: expected item
    1416                 :            :  *
    1417                 :            :  * Remove @item at @index from the radix tree rooted at @root.
    1418                 :            :  *
    1419                 :            :  * Return: the deleted entry, or %NULL if it was not present
    1420                 :            :  * or the entry at the given @index was not @item.
    1421                 :            :  */
    1422                 :          3 : void *radix_tree_delete_item(struct radix_tree_root *root,
    1423                 :            :                              unsigned long index, void *item)
    1424                 :            : {
    1425                 :          3 :         struct radix_tree_node *node = NULL;
    1426                 :          3 :         void __rcu **slot = NULL;
    1427                 :            :         void *entry;
    1428                 :            : 
    1429                 :          3 :         entry = __radix_tree_lookup(root, index, &node, &slot);
    1430                 :          3 :         if (!slot)
    1431                 :            :                 return NULL;
    1432                 :          3 :         if (!entry && (!is_idr(root) || node_tag_get(root, node, IDR_FREE,
    1433                 :          3 :                                                 get_slot_offset(node, slot))))
    1434                 :            :                 return NULL;
    1435                 :            : 
    1436                 :          3 :         if (item && entry != item)
    1437                 :            :                 return NULL;
    1438                 :            : 
    1439                 :          3 :         __radix_tree_delete(root, node, slot);
    1440                 :            : 
    1441                 :          3 :         return entry;
    1442                 :            : }
    1443                 :            : EXPORT_SYMBOL(radix_tree_delete_item);
    1444                 :            : 
    1445                 :            : /**
    1446                 :            :  * radix_tree_delete - delete an entry from a radix tree
    1447                 :            :  * @root: radix tree root
    1448                 :            :  * @index: index key
    1449                 :            :  *
    1450                 :            :  * Remove the entry at @index from the radix tree rooted at @root.
    1451                 :            :  *
    1452                 :            :  * Return: The deleted entry, or %NULL if it was not present.
    1453                 :            :  */
    1454                 :          0 : void *radix_tree_delete(struct radix_tree_root *root, unsigned long index)
    1455                 :            : {
    1456                 :          0 :         return radix_tree_delete_item(root, index, NULL);
    1457                 :            : }
    1458                 :            : EXPORT_SYMBOL(radix_tree_delete);
    1459                 :            : 
    1460                 :            : /**
    1461                 :            :  *      radix_tree_tagged - test whether any items in the tree are tagged
    1462                 :            :  *      @root:          radix tree root
    1463                 :            :  *      @tag:           tag to test
    1464                 :            :  */
    1465                 :          0 : int radix_tree_tagged(const struct radix_tree_root *root, unsigned int tag)
    1466                 :            : {
    1467                 :          0 :         return root_tag_get(root, tag);
    1468                 :            : }
    1469                 :            : EXPORT_SYMBOL(radix_tree_tagged);
    1470                 :            : 
    1471                 :            : /**
    1472                 :            :  * idr_preload - preload for idr_alloc()
    1473                 :            :  * @gfp_mask: allocation mask to use for preloading
    1474                 :            :  *
    1475                 :            :  * Preallocate memory to use for the next call to idr_alloc().  This function
    1476                 :            :  * returns with preemption disabled.  It will be enabled by idr_preload_end().
    1477                 :            :  */
    1478                 :          3 : void idr_preload(gfp_t gfp_mask)
    1479                 :            : {
    1480                 :          3 :         if (__radix_tree_preload(gfp_mask, IDR_PRELOAD_SIZE))
    1481                 :          0 :                 preempt_disable();
    1482                 :          3 : }
    1483                 :            : EXPORT_SYMBOL(idr_preload);
    1484                 :            : 
    1485                 :          3 : void __rcu **idr_get_free(struct radix_tree_root *root,
    1486                 :            :                               struct radix_tree_iter *iter, gfp_t gfp,
    1487                 :            :                               unsigned long max)
    1488                 :            : {
    1489                 :            :         struct radix_tree_node *node = NULL, *child;
    1490                 :          3 :         void __rcu **slot = (void __rcu **)&root->xa_head;
    1491                 :          3 :         unsigned long maxindex, start = iter->next_index;
    1492                 :            :         unsigned int shift, offset = 0;
    1493                 :            : 
    1494                 :            :  grow:
    1495                 :            :         shift = radix_tree_load_root(root, &child, &maxindex);
    1496                 :          3 :         if (!radix_tree_tagged(root, IDR_FREE))
    1497                 :          0 :                 start = max(start, maxindex + 1);
    1498                 :          3 :         if (start > max)
    1499                 :            :                 return ERR_PTR(-ENOSPC);
    1500                 :            : 
    1501                 :          3 :         if (start > maxindex) {
    1502                 :          3 :                 int error = radix_tree_extend(root, gfp, start, shift);
    1503                 :          3 :                 if (error < 0)
    1504                 :          0 :                         return ERR_PTR(error);
    1505                 :          3 :                 shift = error;
    1506                 :            :                 child = rcu_dereference_raw(root->xa_head);
    1507                 :            :         }
    1508                 :          3 :         if (start == 0 && shift == 0)
    1509                 :            :                 shift = RADIX_TREE_MAP_SHIFT;
    1510                 :            : 
    1511                 :          3 :         while (shift) {
    1512                 :          3 :                 shift -= RADIX_TREE_MAP_SHIFT;
    1513                 :          3 :                 if (child == NULL) {
    1514                 :            :                         /* Have to add a child node.  */
    1515                 :          3 :                         child = radix_tree_node_alloc(gfp, node, root, shift,
    1516                 :            :                                                         offset, 0, 0);
    1517                 :          3 :                         if (!child)
    1518                 :            :                                 return ERR_PTR(-ENOMEM);
    1519                 :            :                         all_tag_set(child, IDR_FREE);
    1520                 :          3 :                         rcu_assign_pointer(*slot, node_to_entry(child));
    1521                 :          3 :                         if (node)
    1522                 :          3 :                                 node->count++;
    1523                 :          3 :                 } else if (!radix_tree_is_internal_node(child))
    1524                 :            :                         break;
    1525                 :            : 
    1526                 :            :                 node = entry_to_node(child);
    1527                 :            :                 offset = radix_tree_descend(node, &child, start);
    1528                 :          3 :                 if (!tag_get(node, IDR_FREE, offset)) {
    1529                 :            :                         offset = radix_tree_find_next_bit(node, IDR_FREE,
    1530                 :          3 :                                                         offset + 1);
    1531                 :            :                         start = next_index(start, node, offset);
    1532                 :          3 :                         if (start > max || start == 0)
    1533                 :            :                                 return ERR_PTR(-ENOSPC);
    1534                 :          3 :                         while (offset == RADIX_TREE_MAP_SIZE) {
    1535                 :          0 :                                 offset = node->offset + 1;
    1536                 :          0 :                                 node = node->parent;
    1537                 :          0 :                                 if (!node)
    1538                 :            :                                         goto grow;
    1539                 :          0 :                                 shift = node->shift;
    1540                 :            :                         }
    1541                 :          3 :                         child = rcu_dereference_raw(node->slots[offset]);
    1542                 :            :                 }
    1543                 :          3 :                 slot = &node->slots[offset];
    1544                 :            :         }
    1545                 :            : 
    1546                 :          3 :         iter->index = start;
    1547                 :          3 :         if (node)
    1548                 :          3 :                 iter->next_index = 1 + min(max, (start | node_maxindex(node)));
    1549                 :            :         else
    1550                 :          0 :                 iter->next_index = 1;
    1551                 :          3 :         iter->node = node;
    1552                 :          3 :         set_iter_tags(iter, node, offset, IDR_FREE);
    1553                 :            : 
    1554                 :          3 :         return slot;
    1555                 :            : }
    1556                 :            : 
    1557                 :            : /**
    1558                 :            :  * idr_destroy - release all internal memory from an IDR
    1559                 :            :  * @idr: idr handle
    1560                 :            :  *
    1561                 :            :  * After this function is called, the IDR is empty, and may be reused or
    1562                 :            :  * the data structure containing it may be freed.
    1563                 :            :  *
    1564                 :            :  * A typical clean-up sequence for objects stored in an idr tree will use
    1565                 :            :  * idr_for_each() to free all objects, if necessary, then idr_destroy() to
    1566                 :            :  * free the memory used to keep track of those objects.
    1567                 :            :  */
    1568                 :          3 : void idr_destroy(struct idr *idr)
    1569                 :            : {
    1570                 :            :         struct radix_tree_node *node = rcu_dereference_raw(idr->idr_rt.xa_head);
    1571                 :          3 :         if (radix_tree_is_internal_node(node))
    1572                 :          0 :                 radix_tree_free_nodes(node);
    1573                 :          3 :         idr->idr_rt.xa_head = NULL;
    1574                 :            :         root_tag_set(&idr->idr_rt, IDR_FREE);
    1575                 :          3 : }
    1576                 :            : EXPORT_SYMBOL(idr_destroy);
    1577                 :            : 
    1578                 :            : static void
    1579                 :          3 : radix_tree_node_ctor(void *arg)
    1580                 :            : {
    1581                 :            :         struct radix_tree_node *node = arg;
    1582                 :            : 
    1583                 :          3 :         memset(node, 0, sizeof(*node));
    1584                 :          3 :         INIT_LIST_HEAD(&node->private_list);
    1585                 :          3 : }
    1586                 :            : 
    1587                 :          0 : static int radix_tree_cpu_dead(unsigned int cpu)
    1588                 :            : {
    1589                 :            :         struct radix_tree_preload *rtp;
    1590                 :            :         struct radix_tree_node *node;
    1591                 :            : 
    1592                 :            :         /* Free per-cpu pool of preloaded nodes */
    1593                 :          0 :         rtp = &per_cpu(radix_tree_preloads, cpu);
    1594                 :          0 :         while (rtp->nr) {
    1595                 :          0 :                 node = rtp->nodes;
    1596                 :          0 :                 rtp->nodes = node->parent;
    1597                 :          0 :                 kmem_cache_free(radix_tree_node_cachep, node);
    1598                 :          0 :                 rtp->nr--;
    1599                 :            :         }
    1600                 :          0 :         return 0;
    1601                 :            : }
    1602                 :            : 
    1603                 :          3 : void __init radix_tree_init(void)
    1604                 :            : {
    1605                 :            :         int ret;
    1606                 :            : 
    1607                 :            :         BUILD_BUG_ON(RADIX_TREE_MAX_TAGS + __GFP_BITS_SHIFT > 32);
    1608                 :            :         BUILD_BUG_ON(ROOT_IS_IDR & ~GFP_ZONEMASK);
    1609                 :            :         BUILD_BUG_ON(XA_CHUNK_SIZE > 255);
    1610                 :          3 :         radix_tree_node_cachep = kmem_cache_create("radix_tree_node",
    1611                 :            :                         sizeof(struct radix_tree_node), 0,
    1612                 :            :                         SLAB_PANIC | SLAB_RECLAIM_ACCOUNT,
    1613                 :            :                         radix_tree_node_ctor);
    1614                 :            :         ret = cpuhp_setup_state_nocalls(CPUHP_RADIX_DEAD, "lib/radix:dead",
    1615                 :            :                                         NULL, radix_tree_cpu_dead);
    1616                 :          3 :         WARN_ON(ret < 0);
    1617                 :          3 : }
    

Generated by: LCOV version 1.14