Linux内核源码分析-基树处理- radix_tree

Linux内核源码分析-基树处理- radix_tree

本文主要参考《深入理解Linux内核》，结合2.6.11版的内核代码，分析内核文件子系统中的radix_tree处理函数。
注意：
1、 不描述内核同步、错误处理、参数合法性验证相关的内容
2、 源码摘自Linux内核2.6.11 stable版，获取命令:
git clone
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git
cd ./linux-stable/
git checkout linux-2.6.11.y
3、 阅读本文请结合《深入理解Linux内核》第三版相关章节
4、 本文会不定时更新

函数调用结构

公共函数

1、radix_tree_init
源码：
在init/main.c:start_kernel函数中调用该函数

void __init radix_tree_init(void)
{
    radix_tree_node_cachep = kmem_cache_create("radix_tree_node",
            sizeof(struct radix_tree_node), 0,
            SLAB_PANIC, radix_tree_node_ctor, NULL);
    radix_tree_init_maxindex();
    hotcpu_notifier(radix_tree_callback, 0);
}

处理流出：
1、 调用函数kmem_cache_create分配类型为radix_tree_node、名称为radix_tree_node的slab高速缓存，存入全局变量radix_tree_node_cachep中
2、 调用函数radix_tree_init_maxindex初始化书中各层的最大索引数组height_to_maxindex（1-6层）
3、 调用函数hotcpu_notifier，设置热插拔cpu时的回调函数
2、radix_tree_insert
源码：

/**
 *  radix_tree_insert    -    insert into a radix tree
 *  @root:      radix tree root
 *  @index:     index key
 *  @item:      item to insert
 *
 *  Insert an item into the radix tree at position @index.
 */
int radix_tree_insert(struct radix_tree_root *root,
            unsigned long index, void *item)
{
    struct radix_tree_node *node = NULL, *tmp, **slot;
    unsigned int height, shift;
    int offset;
    int error;

    /* Make sure the tree is high enough.  */
    if ((!index && !root->rnode) ||
            index > radix_tree_maxindex(root->height)) {
        error = radix_tree_extend(root, index);
        if (error)
            return error;
    }

    slot = &root->rnode;
    height = root->height;
    shift = (height-1) * RADIX_TREE_MAP_SHIFT; //当前层偏移需要移动的位数

    offset = 0;         /* uninitialised var warning */
    while (height > 0) {
        if (*slot == NULL) {
            /* Have to add a child node.  */
            if (!(tmp = radix_tree_node_alloc(root)))
                return -ENOMEM;
            *slot = tmp;
            if (node)
                node->count++;
        }

        /* Go a level down */
        offset = (index >> shift) & RADIX_TREE_MAP_MASK;
        node = *slot;
        slot = (struct radix_tree_node **)(node->slots + offset);
        shift -= RADIX_TREE_MAP_SHIFT;
        height--;
    }

    if (*slot != NULL)
        return -EEXIST;
    if (node) {
        node->count++;
        BUG_ON(tag_get(node, 0, offset));
        BUG_ON(tag_get(node, 1, offset));
    }

    *slot = item;
    return 0;
}

处理流程：
1、 调用函数radix_tree_extend扩展树的层数以满足index
2、 循环初始化各层的radix_tree_node对象
3、 初始化最终的页的指针
3、radix_tree_delete
源码：

/**
 *  radix_tree_delete    -    delete an item from a radix tree
 *  @root:      radix tree root
 *  @index:     index key
 *
 *  Remove the item at @index from the radix tree rooted at @root.
 *
 *  Returns the address of the deleted item, or NULL if it was not present.
 */
void *radix_tree_delete(struct radix_tree_root *root, unsigned long index)
{
    struct radix_tree_path path[RADIX_TREE_MAX_PATH], *pathp = path;
    struct radix_tree_path *orig_pathp;
    unsigned int height, shift;
    void *ret = NULL;
    char tags[RADIX_TREE_TAGS];
    int nr_cleared_tags;

    height = root->height;
    if (index > radix_tree_maxindex(height))
        goto out;

    shift = (height - 1) * RADIX_TREE_MAP_SHIFT;
    pathp->node = NULL;
    pathp->slot = &root->rnode;

    while (height > 0) {
        int offset;

        if (*pathp->slot == NULL)
            goto out;

        offset = (index >> shift) & RADIX_TREE_MAP_MASK;
        pathp[1].offset = offset;
        pathp[1].node = *pathp[0].slot;
        pathp[1].slot = (struct radix_tree_node **)
                (pathp[1].node->slots + offset);
        pathp++;
        shift -= RADIX_TREE_MAP_SHIFT;
        height--;
    }

    ret = *pathp[0].slot;
    if (ret == NULL)
        goto out;

    orig_pathp = pathp;

    /*
     * Clear all tags associated with the just-deleted item
     */
    memset(tags, 0, sizeof(tags));
    do {
        int tag;

        nr_cleared_tags = RADIX_TREE_TAGS;
        for (tag = 0; tag < RADIX_TREE_TAGS; tag++) {
            int idx;

            if (tags[tag])
                continue;

            tag_clear(pathp[0].node, tag, pathp[0].offset);

            for (idx = 0; idx < RADIX_TREE_TAG_LONGS; idx++) {
                if (pathp[0].node->tags[tag][idx]) {
                    tags[tag] = 1;
                    nr_cleared_tags--;
                    break;
                }
            }
        }
        pathp--;
    } while (pathp[0].node && nr_cleared_tags);

    pathp = orig_pathp;
    *pathp[0].slot = NULL;
    while (pathp[0].node && --pathp[0].node->count == 0) {
        pathp--;
        BUG_ON(*pathp[0].slot == NULL);
        *pathp[0].slot = NULL;
        radix_tree_node_free(pathp[1].node);
    }
    if (root->rnode == NULL)
        root->height = 0;
out:
    return ret;
}

处理流程：
1、 根据index把各层的节点对象和偏移值存入radix_tree_path对象的offset和node字段中
2、 运行一个三层循环，最外层处理各层节点，中间层循环标记数组，最内层循环各个子节点标记，如果子节点的所有标记都为0，则清楚本节点的标记
3、 从最底层节点开始，循环处理每一层节点，如果节点不为空且节点中的有效子节点个数为0，则调用函数radix_tree_node_free释放该节点
4、 如果树的根节点为空，这把树的高度设置为0（当删除一个最底层节点时，如果没有其他页子节点，树的高度为0；如果还有其他页子节点，树的高度不变）

4、radix_tree_lookup
函数功能：
在radix_tree_root中查找索引页，找到则返回页地址，未找到返回NULL
函数源码：

/**
 *  radix_tree_lookup    -    perform lookup operation on a radix tree
 *  @root:      radix tree root
 *  @index:     index key
 *
 *  Lookup the item at the position @index in the radix tree @root.
 */
void *radix_tree_lookup(struct radix_tree_root *root, unsigned long index)
{
    unsigned int height, shift;
    struct radix_tree_node **slot;

    height = root->height;  //树的高度
    if (index > radix_tree_maxindex(height))  //判断页索引是否超出树的最大索引
        return NULL;

    shift = (height-1) * RADIX_TREE_MAP_SHIFT; //树中各层页索引需要移动的位数
    slot = &root->rnode; //树中的当前节点

    while (height > 0) {
        if (*slot == NULL)  //已结束
            return NULL;
        slot = (struct radix_tree_node **)
            ((*slot)->slots +
                ((index >> shift) & RADIX_TREE_MAP_MASK));//计算下一层树节点的指针
        shift -= RADIX_TREE_MAP_SHIFT;
        height--;
    }

    return *slot;
}

5、radix_tree_tag_set
功能：
把index所对应的树的路径上的所有节点相应偏移的标志设置为tag
源码：

/**
 *  radix_tree_tag_set - set a tag on a radix tree node
 *  @root:      radix tree root
 *  @index:     index key
 *  @tag:       tag index
 *
 *  Set the search tag corresponging to @index in the radix tree.  From
 *  the root all the way down to the leaf node.
 *
 *  Returns the address of the tagged item.   Setting a tag on a not-present
 *  item is a bug.
 */
void *radix_tree_tag_set(struct radix_tree_root *root,
            unsigned long index, int tag)
{
    unsigned int height, shift;
    struct radix_tree_node **slot;

    height = root->height;
    if (index > radix_tree_maxindex(height))
        return NULL;

    shift = (height - 1) * RADIX_TREE_MAP_SHIFT;
    slot = &root->rnode;

    while (height > 0) {
        int offset;

        offset = (index >> shift) & RADIX_TREE_MAP_MASK;
        tag_set(*slot, tag, offset);
        slot = (struct radix_tree_node **)((*slot)->slots + offset);
        BUG_ON(*slot == NULL);
        shift -= RADIX_TREE_MAP_SHIFT;
        height--;
    }

    return *slot;
}

6、radix_tree_tag_clear
源码：

/**
 *  radix_tree_tag_clear - clear a tag on a radix tree node
 *  @root:      radix tree root
 *  @index:     index key
 *  @tag:       tag index
 *
 *  Clear the search tag corresponging to @index in the radix tree.  If
 *  this causes the leaf node to have no tags set then clear the tag in the
 *  next-to-leaf node, etc.
 *
 *  Returns the address of the tagged item on success, else NULL.  ie:
 *  has the same return value and semantics as radix_tree_lookup().
 */
void *radix_tree_tag_clear(struct radix_tree_root *root,
            unsigned long index, int tag)
{
    struct radix_tree_path path[RADIX_TREE_MAX_PATH], *pathp = path;
    unsigned int height, shift;
    void *ret = NULL;

    height = root->height;
    if (index > radix_tree_maxindex(height))
        goto out;

    shift = (height - 1) * RADIX_TREE_MAP_SHIFT;
    pathp->node = NULL;
    pathp->slot = &root->rnode;

    while (height > 0) {
        int offset;

        if (*pathp->slot == NULL)
            goto out;

        offset = (index >> shift) & RADIX_TREE_MAP_MASK;
        pathp[1].offset = offset;
        pathp[1].node = *pathp[0].slot;
        pathp[1].slot = (struct radix_tree_node **)
                (pathp[1].node->slots + offset);
        pathp++;
        shift -= RADIX_TREE_MAP_SHIFT;
        height--;
    }

    ret = *pathp[0].slot;
    if (ret == NULL)
        goto out;

    do {
        int idx;

        tag_clear(pathp[0].node, tag, pathp[0].offset);
        for (idx = 0; idx < RADIX_TREE_TAG_LONGS; idx++) {
            if (pathp[0].node->tags[tag][idx])
                goto out;
        }
        pathp--;
    } while (pathp[0].node);
out:
    return ret;
}

处理流程：
1、 根据index在树中查找，把各层节点信息存入radix_tree_path类型的数组中
2、 从底层开始循环处理各层所找到的节点，把当前偏移处的标记清除，如果子节点标记中有设置的则退出，没有则继续循环下一个节点
7、radix_tree_tag_get
功能：
返回index对应的最底层节点对应的标记
源码：

/**
 *  radix_tree_tag_get - get a tag on a radix tree node
 *  @root:      radix tree root
 *  @index:     index key
 *  @tag:       tag index
 *
 *  Return the search tag corresponging to @index in the radix tree.
 *
 *  Returns zero if the tag is unset, or if there is no corresponding item
 *  in the tree.
 */
int radix_tree_tag_get(struct radix_tree_root *root,
            unsigned long index, int tag)
{
    unsigned int height, shift;
    struct radix_tree_node **slot;
    int saw_unset_tag = 0;

    height = root->height;
    if (index > radix_tree_maxindex(height))
        return 0;

    shift = (height - 1) * RADIX_TREE_MAP_SHIFT;
    slot = &root->rnode;

    for ( ; ; ) {
        int offset;

        if (*slot == NULL)
            return 0;

        offset = (index >> shift) & RADIX_TREE_MAP_MASK;

        /*
         * This is just a debug check.  Later, we can bale as soon as
         * we see an unset tag.
         */
        if (!tag_get(*slot, tag, offset))
            saw_unset_tag = 1;
        if (height == 1) {
            int ret = tag_get(*slot, tag, offset);

            BUG_ON(ret && saw_unset_tag);
            return ret;
        }
        slot = (struct radix_tree_node **)((*slot)->slots + offset);
        shift -= RADIX_TREE_MAP_SHIFT;
        height--;
    }
}

8、radix_tree_gang_lookup
功能：
循环调用函数__lookup，查找radix_tree_root中最底层的非空页
源码：

/**
 *  radix_tree_gang_lookup - perform multiple lookup on a radix tree
 *  @root:      radix tree root
 *  @results:   where the results of the lookup are placed
 *  @first_index:   start the lookup from this key
 *  @max_items: place up to this many items at *results
 *
 *  Performs an index-ascending scan of the tree for present items.  Places
 *  them at *@results and returns the number of items which were placed at
 *  *@results.
 *
 *  The implementation is naive.
 */
unsigned int
radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
            unsigned long first_index, unsigned int max_items)
{
    const unsigned long max_index = radix_tree_maxindex(root->height);
    unsigned long cur_index = first_index;
    unsigned int ret = 0;

    while (ret < max_items) {
        unsigned int nr_found;
        unsigned long next_index;   /* Index of next search */

        if (cur_index > max_index)
            break;
        nr_found = __lookup(root, results + ret, cur_index,
                    max_items - ret, &next_index);
        ret += nr_found;
        if (next_index == 0)
            break;
        cur_index = next_index;
    }
    return ret;
}

9、radix_tree_gang_lookup_tag
功能：
循环调用函数__lookup_tag，查找radix_tree_root中最底层的设置了tag标记的页
源码：

/**
 *  radix_tree_gang_lookup_tag - perform multiple lookup on a radix tree
 *                               based on a tag
 *  @root:      radix tree root
 *  @results:   where the results of the lookup are placed
 *  @first_index:   start the lookup from this key
 *  @max_items: place up to this many items at *results
 *  @tag:       the tag index
 *
 *  Performs an index-ascending scan of the tree for present items which
 *  have the tag indexed by @tag set.  Places the items at *@results and
 *  returns the number of items which were placed at *@results.
 */
unsigned int
radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
        unsigned long first_index, unsigned int max_items, int tag)
{
    const unsigned long max_index = radix_tree_maxindex(root->height);
    unsigned long cur_index = first_index;
    unsigned int ret = 0;

    while (ret < max_items) {
        unsigned int nr_found;
        unsigned long next_index;   /* Index of next search */

        if (cur_index > max_index)
            break;
        nr_found = __lookup_tag(root, results + ret, cur_index,
                    max_items - ret, &next_index, tag);
        ret += nr_found;
        if (next_index == 0)
            break;
        cur_index = next_index;
    }
    return ret;
}

10、radix_tree_tagged
功能：
判断radix_tree_root中是否有设置了tag标记的页，有则返回1，没有则返回0
源码：

/**
 *  radix_tree_tagged - test whether any items in the tree are tagged
 *  @root:      radix tree root
 *  @tag:       tag to test
 */
int radix_tree_tagged(struct radix_tree_root *root, int tag)
{
    int idx;

    if (!root->rnode)
        return 0;
    for (idx = 0; idx < RADIX_TREE_TAG_LONGS; idx++) {
        if (root->rnode->tags[tag][idx])
            return 1;
    }
    return 0;
}

11、radix_tree_preload
功能：
补充每cpu变量radix_tree_preloads中的radix_tree_node对象，在把页加入高速缓存中时调用（add_to_page_cache）
源码：

/*
 * Load up this CPU's radix_tree_node buffer with sufficient objects to
 * ensure that the addition of a single element in the tree cannot fail.  On
 * success, return zero, with preemption disabled.  On error, return -ENOMEM
 * with preemption not disabled.
 */
int radix_tree_preload(int gfp_mask)
{
    struct radix_tree_preload *rtp;
    struct radix_tree_node *node;
    int ret = -ENOMEM;

    preempt_disable();
    rtp = &__get_cpu_var(radix_tree_preloads);
    while (rtp->nr < ARRAY_SIZE(rtp->nodes)) {
        preempt_enable();
        node = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask);
        if (node == NULL)
            goto out;
        preempt_disable();
        rtp = &__get_cpu_var(radix_tree_preloads);
        if (rtp->nr < ARRAY_SIZE(rtp->nodes))
            rtp->nodes[rtp->nr++] = node;
        else
            kmem_cache_free(radix_tree_node_cachep, node);
    }
    ret = 0;
out:
    return ret;
}

文件私有函数

1、radix_tree_maxindex
功能：
该函数隐藏树高度对应的最大索引号的具体实现
源码：

/*
 *  Return the maximum key which can be store into a
 *  radix tree with height HEIGHT.
 */
static inline unsigned long radix_tree_maxindex(unsigned int height)
{
    return height_to_maxindex[height];
}

2、radix_tree_extend
功能：
根据index需要扩展树的深度
源码：

/*
 *  Extend a radix tree so it can store key @index.
 */
static int radix_tree_extend(struct radix_tree_root *root, unsigned long index)
{
    struct radix_tree_node *node;
    unsigned int height;
    char tags[RADIX_TREE_TAGS];
    int tag;

    /* Figure out what the height should be.  */
    height = root->height + 1;
    while (index > radix_tree_maxindex(height))
        height++;

    if (root->rnode == NULL) {
        root->height = height;
        goto out;
    }

    /*
     * Prepare the tag status of the top-level node for propagation
     * into the newly-pushed top-level node(s)
     */
    for (tag = 0; tag < RADIX_TREE_TAGS; tag++) {
        int idx;

        tags[tag] = 0;
        for (idx = 0; idx < RADIX_TREE_TAG_LONGS; idx++) {
            if (root->rnode->tags[tag][idx]) {
                tags[tag] = 1;
                break;
            }
        }
    }

    do {
        if (!(node = radix_tree_node_alloc(root)))
            return -ENOMEM;

        /* Increase the height.  */
        node->slots[0] = root->rnode;

        /* Propagate the aggregated tag info into the new root */
        for (tag = 0; tag < RADIX_TREE_TAGS; tag++) {
            if (tags[tag])
                tag_set(node, tag, 0);
        }

        node->count = 1;
        root->rnode = node;
        root->height++;
    } while (height > root->height);
out:
    return 0;
}

3、radix_tree_node_alloc
源码：

/*
 * This assumes that the caller has performed appropriate preallocation, and
 * that the caller has pinned this thread of control to the current CPU.
 */
static struct radix_tree_node *
radix_tree_node_alloc(struct radix_tree_root *root)
{
    struct radix_tree_node *ret;

    ret = kmem_cache_alloc(radix_tree_node_cachep, root->gfp_mask);
    if (ret == NULL && !(root->gfp_mask & __GFP_WAIT)) {
        struct radix_tree_preload *rtp;

        rtp = &__get_cpu_var(radix_tree_preloads);
        if (rtp->nr) {
            ret = rtp->nodes[rtp->nr - 1];
            rtp->nodes[rtp->nr - 1] = NULL;
            rtp->nr--;
        }
    }
    return ret;
}

处理流程：
1、 调用函数kmem_cache_alloc在slab高速缓存radix_tree_node_cachep中分配radix_tree_node对象，地址存入局部变量ret中并返回
2、 如果分配失败，在本地cpu变量radix_tree_preloads中分配radix_tree_node对象，地址存入局部变量ret中并返回
4、tag_set
功能：
设置节点子节点0的相应标志值
源码：

static inline void tag_set(struct radix_tree_node *node, int tag, int offset)
{
    if (!test_bit(offset, &node->tags[tag][0]))
        __set_bit(offset, &node->tags[tag][0]);
}

5、radix_tree_node_free
功能：
释放radix_tree_node对象给slab高速缓存
源码：

static inline void
radix_tree_node_free(struct radix_tree_node *node)
{
    kmem_cache_free(radix_tree_node_cachep, node);
}

6、__lookup
功能：
搜索radix_tree_root中最底层节点中的所有非空页返回
源码：

static unsigned int
__lookup(struct radix_tree_root *root, void **results, unsigned long index,
    unsigned int max_items, unsigned long *next_index)
{
    unsigned int nr_found = 0;
    unsigned int shift;
    unsigned int height = root->height;
    struct radix_tree_node *slot;

    shift = (height-1) * RADIX_TREE_MAP_SHIFT;
    slot = root->rnode;

    while (height > 0) {  //循环处理树中的每一层
        unsigned long i = (index >> shift) & RADIX_TREE_MAP_MASK;//当前层开始索引

        for ( ; i < RADIX_TREE_MAP_SIZE; i++) {//在当前层中查找第一个不为空的子树索引，存入i中
            if (slot->slots[i] != NULL)
                break;
            index &= ~((1UL << shift) - 1);
            index += 1UL << shift;
            if (index == 0)
                goto out;   /* 32-bit wraparound */
        }
        if (i == RADIX_TREE_MAP_SIZE) //如果当前层为空
            goto out;
        height--;
        if (height == 0) {  /* Bottom level: grab some items */
            unsigned long j = index & RADIX_TREE_MAP_MASK; //最后一层的开始索引

            for ( ; j < RADIX_TREE_MAP_SIZE; j++) {//搜索最后一层中的所有非空页返回
                index++;
                if (slot->slots[j]) {
                    results[nr_found++] = slot->slots[j];
                    if (nr_found == max_items)
                        goto out;
                }
            }
        }
        shift -= RADIX_TREE_MAP_SHIFT;
        slot = slot->slots[i];
    }
out:
    *next_index = index;
    return nr_found;
}

7、__lookup_tag
功能：
搜索radix_tree_root中最底层节点中的所有设置了tag标记的页并返回
源码：

/*
 * FIXME: the two tag_get()s here should use find_next_bit() instead of
 * open-coding the search.
 */
static unsigned int
__lookup_tag(struct radix_tree_root *root, void **results, unsigned long index,
    unsigned int max_items, unsigned long *next_index, int tag)
{
    unsigned int nr_found = 0;
    unsigned int shift;
    unsigned int height = root->height;
    struct radix_tree_node *slot;

    shift = (height - 1) * RADIX_TREE_MAP_SHIFT;
    slot = root->rnode;

    while (height > 0) {
        unsigned long i = (index >> shift) & RADIX_TREE_MAP_MASK;

        for ( ; i < RADIX_TREE_MAP_SIZE; i++) { //查找第一个设置了tag标记的节点
            if (tag_get(slot, tag, i)) {
                BUG_ON(slot->slots[i] == NULL);
                break;
            }
            index &= ~((1UL << shift) - 1);
            index += 1UL << shift;
            if (index == 0)
                goto out;   /* 32-bit wraparound */
        }
        if (i == RADIX_TREE_MAP_SIZE) 
            goto out;
        height--;
        if (height == 0) {  /* Bottom level: grab some items */
            unsigned long j = index & RADIX_TREE_MAP_MASK;

            for ( ; j < RADIX_TREE_MAP_SIZE; j++) {//查找最后一层中设置了tag标记的节点并返回
                index++;
                if (tag_get(slot, tag, j)) { 
                    BUG_ON(slot->slots[j] == NULL);
                    results[nr_found++] = slot->slots[j];
                    if (nr_found == max_items)
                        goto out;
                }
            }
        }
        shift -= RADIX_TREE_MAP_SHIFT;
        slot = slot->slots[i];
    }
out:
    *next_index = index;
    return nr_found;
}