/*
 * Copyright (C) 2001 Momchil Velikov
 * Portions Copyright (C) 2001 Christoph Hellwig
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/radix-tree.h>
#include <linux/percpu.h>
#include <linux/slab.h>
#include <linux/gfp.h>
#include <linux/string.h>

/*
 * Radix tree node definition.
 */
#define RADIX_TREE_MAP_SHIFT  6
#define RADIX_TREE_MAP_SIZE  (1UL << RADIX_TREE_MAP_SHIFT)
#define RADIX_TREE_MAP_MASK  (RADIX_TREE_MAP_SIZE-1)

struct radix_tree_node {
        unsigned int    count;
        void            *slots[RADIX_TREE_MAP_SIZE];
};

struct radix_tree_path {
        struct radix_tree_node *node, **slot;
};

#define RADIX_TREE_INDEX_BITS  (8 /* CHAR_BIT */ * sizeof(unsigned long))
#define RADIX_TREE_MAX_PATH (RADIX_TREE_INDEX_BITS/RADIX_TREE_MAP_SHIFT + 2)

static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH];

/*
 * Radix tree node cache.
 */
static kmem_cache_t *radix_tree_node_cachep;

/*
 * Per-cpu pool of preloaded nodes
 */
struct radix_tree_preload {
        int nr;
        struct radix_tree_node *nodes[RADIX_TREE_MAX_PATH];
};
DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, };

/*
 * 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;
}

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

/*
 * 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;
}

/*
 *      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];
}

/*
 *      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;

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

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

                        /* Increase the height.  */
                        node->slots[0] = root->rnode;
                        node->count = 1;
                        root->rnode = node;
                        root->height++;
                } while (height > root->height);
        } else 
                root->height = height;

        return 0;
}

/**
 *      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 error;

        /* Make sure the tree is high enough.  */
        if (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;

        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.  */
                node = *slot;
                slot = (struct radix_tree_node **)
                        (node->slots + ((index >> shift) & RADIX_TREE_MAP_MASK));
                shift -= RADIX_TREE_MAP_SHIFT;
                height--;
        }

        if (*slot != NULL)
                return -EEXIST;
        if (node)
                node->count++;

        *slot = item;
        return 0;
}
EXPORT_SYMBOL(radix_tree_insert);

/**
 *      radix_tree_lookup    -    perform lookup operation on a radix tree
 *      @root:          radix tree root
 *      @index:         index key
 *
 *      Lookup them 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 (void *) *slot;
}
EXPORT_SYMBOL(radix_tree_lookup);

static /* inline */ 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++) {
                        if (slot->slots[i] != NULL)
                                break;
                        index &= ~((1 << shift) - 1);
                        index += 1 << 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;
}

/**
 *      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;

        if (root->rnode == NULL)
                goto out;
        if (max_index == 0) {                   /* Bah.  Special case */
                if (first_index == 0) {
                        if (max_items > 0) {
                                *results = root->rnode;
                                ret = 1;
                        }
                }
                goto out;
        }
        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;
        }
out:
        return ret;
}
EXPORT_SYMBOL(radix_tree_gang_lookup);

/**
 *      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;
        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) {
                if (*pathp->slot == NULL)
                        goto out;

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

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

        *pathp[0].slot = NULL;
        while (pathp[0].node && --pathp[0].node->count == 0) {
                pathp--;
                *pathp[0].slot = NULL;
                radix_tree_node_free(pathp[1].node);
        }

        if (root->rnode == NULL)
                root->height = 0;  /* Empty tree, we can reset the height */
out:
        return ret;
}
EXPORT_SYMBOL(radix_tree_delete);

static void
radix_tree_node_ctor(void *node, kmem_cache_t *cachep, unsigned long flags)
{
        memset(node, 0, sizeof(struct radix_tree_node));
}

static __init unsigned long __maxindex(unsigned int height)
{
        unsigned int tmp = height * RADIX_TREE_MAP_SHIFT;
        unsigned long index = (~0UL >> (RADIX_TREE_INDEX_BITS - tmp - 1)) >> 1;

        if (tmp >= RADIX_TREE_INDEX_BITS)
                index = ~0UL;
        return index;
}

static __init void radix_tree_init_maxindex(void)
{
        unsigned int i;

        for (i = 0; i < ARRAY_SIZE(height_to_maxindex); i++)
                height_to_maxindex[i] = __maxindex(i);
}

void __init radix_tree_init(void)
{
        radix_tree_node_cachep = kmem_cache_create("radix_tree_node",
                        sizeof(struct radix_tree_node), 0,
                        0, radix_tree_node_ctor, NULL);
        if (!radix_tree_node_cachep)
                panic ("Failed to create radix_tree_node cache\n");
        radix_tree_init_maxindex();
}