// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
 *
 * Development of this code funded by Astaro AG (http://www.astaro.com/)
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/rbtree.h>
#include <linux/bsearch.h>
#include <linux/netlink.h>
#include <linux/netfilter.h>
#include <linux/netfilter/nf_tables.h>
#include <net/netfilter/nf_tables_core.h>

struct nft_array_interval {
        struct nft_set_ext      *from;
        struct nft_set_ext      *to;
};

struct nft_array {
        u32                     max_intervals;
        u32                     num_intervals;
        struct nft_array_interval *intervals;
        struct rcu_head         rcu_head;
};

struct nft_rbtree {
        struct rb_root          root;
        rwlock_t                lock;
        struct nft_array __rcu  *array;
        struct nft_array        *array_next;
        unsigned long           start_rbe_cookie;
        unsigned long           last_gc;
        struct list_head        expired;
        u64                     last_tstamp;
};

struct nft_rbtree_elem {
        struct nft_elem_priv    priv;
        union {
                struct rb_node  node;
                struct list_head list;
        };
        struct nft_set_ext      ext;
};

static bool nft_rbtree_interval_end(const struct nft_rbtree_elem *rbe)
{
        return nft_set_ext_exists(&rbe->ext, NFT_SET_EXT_FLAGS) &&
               (*nft_set_ext_flags(&rbe->ext) & NFT_SET_ELEM_INTERVAL_END);
}

static bool nft_rbtree_interval_start(const struct nft_rbtree_elem *rbe)
{
        return !nft_rbtree_interval_end(rbe);
}

static bool nft_rbtree_interval_null(const struct nft_set *set,
                                     const struct nft_rbtree_elem *rbe)
{
        return (!memchr_inv(nft_set_ext_key(&rbe->ext), 0, set->klen) &&
                nft_rbtree_interval_end(rbe));
}

static int nft_rbtree_cmp(const struct nft_set *set,
                          const struct nft_rbtree_elem *e1,
                          const struct nft_rbtree_elem *e2)
{
        return memcmp(nft_set_ext_key(&e1->ext), nft_set_ext_key(&e2->ext),
                      set->klen);
}

struct nft_array_lookup_ctx {
        const u32       *key;
        u32             klen;
};

static int nft_array_lookup_cmp(const void *pkey, const void *entry)
{
        const struct nft_array_interval *interval = entry;
        const struct nft_array_lookup_ctx *ctx = pkey;
        int a, b;

        if (!interval->from)
                return 1;

        a = memcmp(ctx->key, nft_set_ext_key(interval->from), ctx->klen);
        if (!interval->to)
                b = -1;
        else
                b = memcmp(ctx->key, nft_set_ext_key(interval->to), ctx->klen);

        if (a >= 0 && b < 0)
                return 0;

        if (a < 0)
                return -1;

        return 1;
}

INDIRECT_CALLABLE_SCOPE
const struct nft_set_ext *
nft_rbtree_lookup(const struct net *net, const struct nft_set *set,
                  const u32 *key)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_array *array = rcu_dereference(priv->array);
        const struct nft_array_interval *interval;
        struct nft_array_lookup_ctx ctx = {
                .key    = key,
                .klen   = set->klen,
        };

        if (!array)
                return NULL;

        interval = bsearch(&ctx, array->intervals, array->num_intervals,
                           sizeof(struct nft_array_interval),
                           nft_array_lookup_cmp);
        if (!interval || nft_set_elem_expired(interval->from))
                return NULL;

        return interval->from;
}

struct nft_array_get_ctx {
        const u32       *key;
        unsigned int    flags;
        u32             klen;
};

static int nft_array_get_cmp(const void *pkey, const void *entry)
{
        const struct nft_array_interval *interval = entry;
        const struct nft_array_get_ctx *ctx = pkey;
        int a, b;

        if (!interval->from)
                return 1;

        a = memcmp(ctx->key, nft_set_ext_key(interval->from), ctx->klen);
        if (!interval->to)
                b = -1;
        else
                b = memcmp(ctx->key, nft_set_ext_key(interval->to), ctx->klen);

        if (a >= 0) {
                if (ctx->flags & NFT_SET_ELEM_INTERVAL_END && b <= 0)
                        return 0;
                else if (b < 0)
                        return 0;
        }

        if (a < 0)
                return -1;

        return 1;
}

static struct nft_elem_priv *
nft_rbtree_get(const struct net *net, const struct nft_set *set,
               const struct nft_set_elem *elem, unsigned int flags)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_array *array = rcu_dereference(priv->array);
        const struct nft_array_interval *interval;
        struct nft_array_get_ctx ctx = {
                .key    = (const u32 *)&elem->key.val,
                .flags  = flags,
                .klen   = set->klen,
        };
        struct nft_rbtree_elem *rbe;

        if (!array)
                return ERR_PTR(-ENOENT);

        interval = bsearch(&ctx, array->intervals, array->num_intervals,
                           sizeof(struct nft_array_interval), nft_array_get_cmp);
        if (!interval || nft_set_elem_expired(interval->from))
                return ERR_PTR(-ENOENT);

        if (flags & NFT_SET_ELEM_INTERVAL_END)
                rbe = container_of(interval->to, struct nft_rbtree_elem, ext);
        else
                rbe = container_of(interval->from, struct nft_rbtree_elem, ext);

        return &rbe->priv;
}

static void nft_rbtree_gc_elem_move(struct net *net, struct nft_set *set,
                                    struct nft_rbtree *priv,
                                    struct nft_rbtree_elem *rbe)
{
        lockdep_assert_held_write(&priv->lock);
        nft_setelem_data_deactivate(net, set, &rbe->priv);
        rb_erase(&rbe->node, &priv->root);

        /* collected later on in commit callback */
        list_add(&rbe->list, &priv->expired);
}

static const struct nft_rbtree_elem *
nft_rbtree_gc_elem(const struct nft_set *__set, struct nft_rbtree *priv,
                   struct nft_rbtree_elem *rbe)
{
        struct nft_set *set = (struct nft_set *)__set;
        struct rb_node *prev = rb_prev(&rbe->node);
        struct net *net = read_pnet(&set->net);
        struct nft_rbtree_elem *rbe_prev;

        /* search for end interval coming before this element.
         * end intervals don't carry a timeout extension, they
         * are coupled with the interval start element.
         */
        while (prev) {
                rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node);
                if (nft_rbtree_interval_end(rbe_prev) &&
                    nft_set_elem_active(&rbe_prev->ext, NFT_GENMASK_ANY))
                        break;

                prev = rb_prev(prev);
        }

        rbe_prev = NULL;
        if (prev) {
                rbe_prev = rb_entry(prev, struct nft_rbtree_elem, node);
                nft_rbtree_gc_elem_move(net, set, priv, rbe_prev);
        }

        nft_rbtree_gc_elem_move(net, set, priv, rbe);

        return rbe_prev;
}

static bool nft_rbtree_update_first(const struct nft_set *set,
                                    struct nft_rbtree_elem *rbe,
                                    struct rb_node *first)
{
        struct nft_rbtree_elem *first_elem;

        first_elem = rb_entry(first, struct nft_rbtree_elem, node);
        /* this element is closest to where the new element is to be inserted:
         * update the first element for the node list path.
         */
        if (nft_rbtree_cmp(set, rbe, first_elem) < 0)
                return true;

        return false;
}

/* Only for anonymous sets which do not allow updates, all element are active. */
static struct nft_rbtree_elem *nft_rbtree_prev_active(struct nft_rbtree_elem *rbe)
{
        struct rb_node *node;

        node = rb_prev(&rbe->node);
        if (!node)
                return NULL;

        return rb_entry(node, struct nft_rbtree_elem, node);
}

static struct nft_rbtree_elem *
__nft_rbtree_next_active(struct rb_node *node, u8 genmask)
{
        struct nft_rbtree_elem *next_rbe;

        while (node) {
                next_rbe = rb_entry(node, struct nft_rbtree_elem, node);
                if (!nft_set_elem_active(&next_rbe->ext, genmask)) {
                        node = rb_next(node);
                        continue;
                }

                return next_rbe;
        }

        return NULL;
}

static struct nft_rbtree_elem *
nft_rbtree_next_active(struct nft_rbtree_elem *rbe, u8 genmask)
{
        return __nft_rbtree_next_active(rb_next(&rbe->node), genmask);
}

static void nft_rbtree_maybe_reset_start_cookie(struct nft_rbtree *priv,
                                                u64 tstamp)
{
        if (priv->last_tstamp != tstamp) {
                priv->start_rbe_cookie = 0;
                priv->last_tstamp = tstamp;
        }
}

static void nft_rbtree_set_start_cookie(struct nft_rbtree *priv,
                                        const struct nft_rbtree_elem *rbe)
{
        priv->start_rbe_cookie = (unsigned long)rbe;
}

static bool nft_rbtree_cmp_start_cookie(struct nft_rbtree *priv,
                                        const struct nft_rbtree_elem *rbe)
{
        return priv->start_rbe_cookie == (unsigned long)rbe;
}

static bool nft_rbtree_insert_same_interval(const struct net *net,
                                            struct nft_rbtree *priv,
                                            struct nft_rbtree_elem *rbe)
{
        u8 genmask = nft_genmask_next(net);
        struct nft_rbtree_elem *next_rbe;

        if (!priv->start_rbe_cookie)
                return true;

        next_rbe = nft_rbtree_next_active(rbe, genmask);
        if (next_rbe) {
                /* Closest start element differs from last element added. */
                if (nft_rbtree_interval_start(next_rbe) &&
                    nft_rbtree_cmp_start_cookie(priv, next_rbe)) {
                        priv->start_rbe_cookie = 0;
                        return true;
                }
        }

        priv->start_rbe_cookie = 0;

        return false;
}

static int __nft_rbtree_insert(const struct net *net, const struct nft_set *set,
                               struct nft_rbtree_elem *new,
                               struct nft_elem_priv **elem_priv, u64 tstamp)
{
        struct nft_rbtree_elem *rbe, *rbe_le = NULL, *rbe_ge = NULL, *rbe_prev;
        struct rb_node *node, *next, *parent, **p, *first = NULL;
        struct nft_rbtree *priv = nft_set_priv(set);
        u8 cur_genmask = nft_genmask_cur(net);
        u8 genmask = nft_genmask_next(net);
        int d;

        /* Descend the tree to search for an existing element greater than the
         * key value to insert that is greater than the new element. This is the
         * first element to walk the ordered elements to find possible overlap.
         */
        parent = NULL;
        p = &priv->root.rb_node;
        while (*p != NULL) {
                parent = *p;
                rbe = rb_entry(parent, struct nft_rbtree_elem, node);
                d = nft_rbtree_cmp(set, rbe, new);

                if (d < 0) {
                        p = &parent->rb_left;
                } else if (d > 0) {
                        if (!first ||
                            nft_rbtree_update_first(set, rbe, first))
                                first = &rbe->node;

                        p = &parent->rb_right;
                } else {
                        if (nft_rbtree_interval_end(rbe))
                                p = &parent->rb_left;
                        else
                                p = &parent->rb_right;
                }
        }

        if (!first)
                first = rb_first(&priv->root);

        /* Detect overlap by going through the list of valid tree nodes.
         * Values stored in the tree are in reversed order, starting from
         * highest to lowest value.
         */
        for (node = first; node != NULL; node = next) {
                next = rb_next(node);

                rbe = rb_entry(node, struct nft_rbtree_elem, node);

                if (!nft_set_elem_active(&rbe->ext, genmask))
                        continue;

                /* perform garbage collection to avoid bogus overlap reports
                 * but skip new elements in this transaction.
                 */
                if (__nft_set_elem_expired(&rbe->ext, tstamp) &&
                    nft_set_elem_active(&rbe->ext, cur_genmask)) {
                        const struct nft_rbtree_elem *removed_end;

                        removed_end = nft_rbtree_gc_elem(set, priv, rbe);
                        if (IS_ERR(removed_end))
                                return PTR_ERR(removed_end);

                        if (removed_end == rbe_le || removed_end == rbe_ge)
                                return -EAGAIN;

                        continue;
                }

                d = nft_rbtree_cmp(set, rbe, new);
                if (d == 0) {
                        /* Matching end element: no need to look for an
                         * overlapping greater or equal element.
                         */
                        if (nft_rbtree_interval_end(rbe)) {
                                rbe_le = rbe;
                                break;
                        }

                        /* first element that is greater or equal to key value. */
                        if (!rbe_ge) {
                                rbe_ge = rbe;
                                continue;
                        }

                        /* this is a closer more or equal element, update it. */
                        if (nft_rbtree_cmp(set, rbe_ge, new) != 0) {
                                rbe_ge = rbe;
                                continue;
                        }

                        /* element is equal to key value, make sure flags are
                         * the same, an existing more or equal start element
                         * must not be replaced by more or equal end element.
                         */
                        if ((nft_rbtree_interval_start(new) &&
                             nft_rbtree_interval_start(rbe_ge)) ||
                            (nft_rbtree_interval_end(new) &&
                             nft_rbtree_interval_end(rbe_ge))) {
                                rbe_ge = rbe;
                                continue;
                        }
                } else if (d > 0) {
                        /* annotate element greater than the new element. */
                        rbe_ge = rbe;
                        continue;
                } else if (d < 0) {
                        /* annotate element less than the new element. */
                        rbe_le = rbe;
                        break;
                }
        }

        if (nft_rbtree_interval_null(set, new))
                priv->start_rbe_cookie = 0;
        else if (nft_rbtree_interval_start(new) && priv->start_rbe_cookie)
                priv->start_rbe_cookie = 0;

        /* - new start element matching existing start element: full overlap
         *   reported as -EEXIST, cleared by caller if NLM_F_EXCL is not given.
         */
        if (rbe_ge && !nft_rbtree_cmp(set, new, rbe_ge) &&
            nft_rbtree_interval_start(rbe_ge) == nft_rbtree_interval_start(new)) {
                *elem_priv = &rbe_ge->priv;
                nft_rbtree_set_start_cookie(priv, rbe_ge);
                return -EEXIST;
        }

        /* - new end element matching existing end element: full overlap
         *   reported as -EEXIST, cleared by caller if NLM_F_EXCL is not given.
         */
        if (rbe_le && !nft_rbtree_cmp(set, new, rbe_le) &&
            nft_rbtree_interval_end(rbe_le) == nft_rbtree_interval_end(new)) {
                /* - ignore null interval, otherwise NLM_F_CREATE bogusly
                 *   reports EEXIST.
                 */
                if (nft_rbtree_interval_null(set, new))
                        return -ECANCELED;

                *elem_priv = &rbe_le->priv;

                /* - start and end element belong to the same interval. */
                if (!nft_rbtree_insert_same_interval(net, priv, rbe_le))
                        return -ENOTEMPTY;

                return -EEXIST;
        }

        /* - new start element with existing closest, less or equal key value
         *   being a start element: partial overlap, reported as -ENOTEMPTY.
         *   Anonymous sets allow for two consecutive start element since they
         *   are constant, but validate that this new start element does not
         *   sit in between an existing start and end elements: partial overlap,
         *   reported as -ENOTEMPTY.
         */
        if (rbe_le &&
            nft_rbtree_interval_start(rbe_le) && nft_rbtree_interval_start(new)) {
                if (!nft_set_is_anonymous(set))
                        return -ENOTEMPTY;

                rbe_prev = nft_rbtree_prev_active(rbe_le);
                if (rbe_prev && nft_rbtree_interval_end(rbe_prev))
                        return -ENOTEMPTY;
        }

        /* - new end element with existing closest, less or equal key value
         *   being a end element: partial overlap, reported as -ENOTEMPTY.
         */
        if (rbe_le &&
            nft_rbtree_interval_end(rbe_le) && nft_rbtree_interval_end(new))
                return -ENOTEMPTY;

        /* - new end element with existing closest, greater or equal key value
         *   being an end element: partial overlap, reported as -ENOTEMPTY
         */
        if (rbe_ge &&
            nft_rbtree_interval_end(rbe_ge) && nft_rbtree_interval_end(new))
                return -ENOTEMPTY;

        /* Accepted element: pick insertion point depending on key value */
        parent = NULL;
        p = &priv->root.rb_node;
        while (*p != NULL) {
                parent = *p;
                rbe = rb_entry(parent, struct nft_rbtree_elem, node);
                d = nft_rbtree_cmp(set, rbe, new);

                if (d < 0)
                        p = &parent->rb_left;
                else if (d > 0)
                        p = &parent->rb_right;
                else if (nft_rbtree_interval_end(rbe))
                        p = &parent->rb_left;
                else
                        p = &parent->rb_right;
        }

        rb_link_node_rcu(&new->node, parent, p);
        rb_insert_color(&new->node, &priv->root);
        return 0;
}

static int nft_array_intervals_alloc(struct nft_array *array, u32 max_intervals)
{
        struct nft_array_interval *intervals;

        intervals = kvzalloc_objs(struct nft_array_interval, max_intervals,
                                  GFP_KERNEL_ACCOUNT);
        if (!intervals)
                return -ENOMEM;

        if (array->intervals)
                kvfree(array->intervals);

        array->intervals = intervals;
        array->max_intervals = max_intervals;

        return 0;
}

static struct nft_array *nft_array_alloc(u32 max_intervals)
{
        struct nft_array *array;

        array = kzalloc_obj(*array, GFP_KERNEL_ACCOUNT);
        if (!array)
                return NULL;

        if (nft_array_intervals_alloc(array, max_intervals) < 0) {
                kfree(array);
                return NULL;
        }

        return array;
}

/* Similar to nft_rbtree_{u,k}size to hide details to userspace, but consider
 * packed representation coming from userspace for anonymous sets too.
 */
static u32 nft_array_elems(const struct nft_set *set)
{
        u32 nelems = atomic_read(&set->nelems) - set->ndeact;

        /* Adjacent intervals are represented with a single start element in
         * anonymous sets, use the current element counter as is.
         */
        if (nft_set_is_anonymous(set))
                return nelems;

        /* Add extra room for never matching interval at the beginning and open
         * interval at the end which only use a single element to represent it.
         * The conversion to array will compact intervals, this allows reduce
         * memory consumption.
         */
        return (nelems / 2) + 2;
}

#define NFT_ARRAY_INITIAL_SIZE          1024
#define NFT_ARRAY_INITIAL_ANON_SIZE     16
#define NFT_ARRAY_INITIAL_ANON_THRESH   (8192U / sizeof(struct nft_array_interval))

static int nft_array_may_resize(const struct nft_set *set, bool flush)
{
        u32 initial_intervals, max_intervals, new_max_intervals, delta;
        u32 shrinked_max_intervals, nelems = nft_array_elems(set);
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_array *array;

        if (nft_set_is_anonymous(set))
                initial_intervals = NFT_ARRAY_INITIAL_ANON_SIZE;
        else
                initial_intervals = NFT_ARRAY_INITIAL_SIZE;

        if (priv->array_next) {
                max_intervals = priv->array_next->max_intervals;
                new_max_intervals = priv->array_next->max_intervals;
        } else {
                if (priv->array) {
                        max_intervals = priv->array->max_intervals;
                        new_max_intervals = priv->array->max_intervals;
                } else {
                        max_intervals = 0;
                        new_max_intervals = initial_intervals;
                }
        }

        if (nft_set_is_anonymous(set))
                goto maybe_grow;

        if (flush) {
                /* Set flush just started, nelems still report elements.*/
                nelems = 0;
                new_max_intervals = NFT_ARRAY_INITIAL_SIZE;
                goto realloc_array;
        }

        if (check_add_overflow(new_max_intervals, new_max_intervals,
                               &shrinked_max_intervals))
                return -EOVERFLOW;

        shrinked_max_intervals = DIV_ROUND_UP(shrinked_max_intervals, 3);

        if (shrinked_max_intervals > NFT_ARRAY_INITIAL_SIZE &&
            nelems < shrinked_max_intervals) {
                new_max_intervals = shrinked_max_intervals;
                goto realloc_array;
        }
maybe_grow:
        if (nelems > new_max_intervals) {
                if (nft_set_is_anonymous(set) &&
                    new_max_intervals < NFT_ARRAY_INITIAL_ANON_THRESH) {
                        new_max_intervals <<= 1;
                } else {
                        delta = new_max_intervals >> 1;
                        if (check_add_overflow(new_max_intervals, delta,
                                               &new_max_intervals))
                                return -EOVERFLOW;
                }
        }

realloc_array:
        if (WARN_ON_ONCE(nelems > new_max_intervals))
                return -ENOMEM;

        if (priv->array_next) {
                if (max_intervals == new_max_intervals)
                        return 0;

                if (nft_array_intervals_alloc(priv->array_next, new_max_intervals) < 0)
                        return -ENOMEM;
        } else {
                array = nft_array_alloc(new_max_intervals);
                if (!array)
                        return -ENOMEM;

                priv->array_next = array;
        }

        return 0;
}

static int nft_rbtree_insert(const struct net *net, const struct nft_set *set,
                             const struct nft_set_elem *elem,
                             struct nft_elem_priv **elem_priv)
{
        struct nft_rbtree_elem *rbe = nft_elem_priv_cast(elem->priv);
        struct nft_rbtree *priv = nft_set_priv(set);
        u64 tstamp = nft_net_tstamp(net);
        int err;

        nft_rbtree_maybe_reset_start_cookie(priv, tstamp);

        if (nft_array_may_resize(set, false) < 0)
                return -ENOMEM;

        do {
                if (fatal_signal_pending(current))
                        return -EINTR;

                cond_resched();

                write_lock_bh(&priv->lock);
                err = __nft_rbtree_insert(net, set, rbe, elem_priv, tstamp);
                write_unlock_bh(&priv->lock);
        } while (err == -EAGAIN);

        return err;
}

static void nft_rbtree_erase(struct nft_rbtree *priv, struct nft_rbtree_elem *rbe)
{
        write_lock_bh(&priv->lock);
        rb_erase(&rbe->node, &priv->root);
        write_unlock_bh(&priv->lock);
}

static void nft_rbtree_remove(const struct net *net,
                              const struct nft_set *set,
                              struct nft_elem_priv *elem_priv)
{
        struct nft_rbtree_elem *rbe = nft_elem_priv_cast(elem_priv);
        struct nft_rbtree *priv = nft_set_priv(set);

        nft_rbtree_erase(priv, rbe);
}

static void nft_rbtree_activate(const struct net *net,
                                const struct nft_set *set,
                                struct nft_elem_priv *elem_priv)
{
        struct nft_rbtree_elem *rbe = nft_elem_priv_cast(elem_priv);

        nft_clear(net, &rbe->ext);
}

static struct nft_rbtree_elem *
nft_rbtree_next_inactive(struct nft_rbtree_elem *rbe, u8 genmask)
{
        struct nft_rbtree_elem *next_rbe;
        struct rb_node *node;

        node = rb_next(&rbe->node);
        if (node) {
                next_rbe = rb_entry(node, struct nft_rbtree_elem, node);
                if (nft_rbtree_interval_start(next_rbe) &&
                    !nft_set_elem_active(&next_rbe->ext, genmask))
                        return next_rbe;
        }

        return NULL;
}

static bool nft_rbtree_deactivate_same_interval(const struct net *net,
                                                struct nft_rbtree *priv,
                                                struct nft_rbtree_elem *rbe)
{
        u8 genmask = nft_genmask_next(net);
        struct nft_rbtree_elem *next_rbe;

        if (!priv->start_rbe_cookie)
                return true;

        next_rbe = nft_rbtree_next_inactive(rbe, genmask);
        if (next_rbe) {
                /* Closest start element differs from last element added. */
                if (nft_rbtree_interval_start(next_rbe) &&
                    nft_rbtree_cmp_start_cookie(priv, next_rbe)) {
                        priv->start_rbe_cookie = 0;
                        return true;
                }
        }

        priv->start_rbe_cookie = 0;

        return false;
}

static void nft_rbtree_flush(const struct net *net,
                             const struct nft_set *set,
                             struct nft_elem_priv *elem_priv)
{
        struct nft_rbtree_elem *rbe = nft_elem_priv_cast(elem_priv);

        nft_set_elem_change_active(net, set, &rbe->ext);
}

static struct nft_elem_priv *
nft_rbtree_deactivate(const struct net *net, const struct nft_set *set,
                      const struct nft_set_elem *elem)
{
        struct nft_rbtree_elem *rbe, *this = nft_elem_priv_cast(elem->priv);
        struct nft_rbtree *priv = nft_set_priv(set);
        const struct rb_node *parent = priv->root.rb_node;
        u8 genmask = nft_genmask_next(net);
        u64 tstamp = nft_net_tstamp(net);
        int d;

        nft_rbtree_maybe_reset_start_cookie(priv, tstamp);

        if (nft_rbtree_interval_start(this) ||
            nft_rbtree_interval_null(set, this))
                priv->start_rbe_cookie = 0;

        if (nft_array_may_resize(set, false) < 0)
                return NULL;

        while (parent != NULL) {
                rbe = rb_entry(parent, struct nft_rbtree_elem, node);

                d = memcmp(nft_set_ext_key(&rbe->ext), &elem->key.val,
                                           set->klen);
                if (d < 0)
                        parent = parent->rb_left;
                else if (d > 0)
                        parent = parent->rb_right;
                else {
                        if (nft_rbtree_interval_end(rbe) &&
                            nft_rbtree_interval_start(this)) {
                                parent = parent->rb_left;
                                continue;
                        } else if (nft_rbtree_interval_start(rbe) &&
                                   nft_rbtree_interval_end(this)) {
                                parent = parent->rb_right;
                                continue;
                        } else if (__nft_set_elem_expired(&rbe->ext, tstamp)) {
                                break;
                        } else if (!nft_set_elem_active(&rbe->ext, genmask)) {
                                parent = parent->rb_left;
                                continue;
                        }

                        if (nft_rbtree_interval_start(rbe))
                                nft_rbtree_set_start_cookie(priv, rbe);
                        else if (!nft_rbtree_deactivate_same_interval(net, priv, rbe))
                                return NULL;

                        nft_rbtree_flush(net, set, &rbe->priv);
                        return &rbe->priv;
                }
        }
        return NULL;
}

static void nft_rbtree_do_walk(const struct nft_ctx *ctx,
                               struct nft_set *set,
                               struct nft_set_iter *iter)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_rbtree_elem *rbe;
        struct rb_node *node;

        for (node = rb_first(&priv->root); node != NULL; node = rb_next(node)) {
                rbe = rb_entry(node, struct nft_rbtree_elem, node);

                if (iter->count < iter->skip)
                        goto cont;

                iter->err = iter->fn(ctx, set, iter, &rbe->priv);
                if (iter->err < 0)
                        return;
cont:
                iter->count++;
        }
}

static void nft_rbtree_walk(const struct nft_ctx *ctx,
                            struct nft_set *set,
                            struct nft_set_iter *iter)
{
        struct nft_rbtree *priv = nft_set_priv(set);

        switch (iter->type) {
        case NFT_ITER_UPDATE_CLONE:
                if (nft_array_may_resize(set, true) < 0) {
                        iter->err = -ENOMEM;
                        break;
                }
                fallthrough;
        case NFT_ITER_UPDATE:
                lockdep_assert_held(&nft_pernet(ctx->net)->commit_mutex);

                nft_rbtree_do_walk(ctx, set, iter);
                break;
        case NFT_ITER_READ:
                read_lock_bh(&priv->lock);
                nft_rbtree_do_walk(ctx, set, iter);
                read_unlock_bh(&priv->lock);
                break;
        default:
                iter->err = -EINVAL;
                WARN_ON_ONCE(1);
                break;
        }
}

static void nft_rbtree_gc_scan(struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_rbtree_elem *rbe, *rbe_end = NULL;
        struct net *net = read_pnet(&set->net);
        u64 tstamp = nft_net_tstamp(net);
        struct rb_node *node, *next;

        for (node = rb_first(&priv->root); node ; node = next) {
                next = rb_next(node);

                rbe = rb_entry(node, struct nft_rbtree_elem, node);

                /* elements are reversed in the rbtree for historical reasons,
                 * from highest to lowest value, that is why end element is
                 * always visited before the start element.
                 */
                if (nft_rbtree_interval_end(rbe)) {
                        rbe_end = rbe;
                        continue;
                }
                if (!__nft_set_elem_expired(&rbe->ext, tstamp))
                        continue;

                /* end element needs to be removed first, it has
                 * no timeout extension.
                 */
                write_lock_bh(&priv->lock);
                if (rbe_end) {
                        nft_rbtree_gc_elem_move(net, set, priv, rbe_end);
                        rbe_end = NULL;
                }

                nft_rbtree_gc_elem_move(net, set, priv, rbe);
                write_unlock_bh(&priv->lock);
        }

        priv->last_gc = jiffies;
}

static void nft_rbtree_gc_queue(struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_rbtree_elem *rbe, *rbe_end;
        struct nft_trans_gc *gc;

        if (list_empty(&priv->expired))
                return;

        gc = nft_trans_gc_alloc(set, 0, GFP_KERNEL);
        if (!gc)
                return;

        list_for_each_entry_safe(rbe, rbe_end, &priv->expired, list) {
                list_del(&rbe->list);
                nft_trans_gc_elem_add(gc, rbe);

                gc = nft_trans_gc_queue_sync(gc, GFP_KERNEL);
                if (!gc)
                        return;
        }

        gc = nft_trans_gc_catchall_sync(gc);
        nft_trans_gc_queue_sync_done(gc);
}

static u64 nft_rbtree_privsize(const struct nlattr * const nla[],
                               const struct nft_set_desc *desc)
{
        return sizeof(struct nft_rbtree);
}

static int nft_rbtree_init(const struct nft_set *set,
                           const struct nft_set_desc *desc,
                           const struct nlattr * const nla[])
{
        struct nft_rbtree *priv = nft_set_priv(set);

        BUILD_BUG_ON(offsetof(struct nft_rbtree_elem, priv) != 0);

        rwlock_init(&priv->lock);
        priv->root = RB_ROOT;
        INIT_LIST_HEAD(&priv->expired);

        priv->array = NULL;
        priv->array_next = NULL;

        return 0;
}

static void __nft_array_free(struct nft_array *array)
{
        kvfree(array->intervals);
        kfree(array);
}

static void nft_rbtree_destroy(const struct nft_ctx *ctx,
                               const struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_rbtree_elem *rbe, *next;
        struct nft_array *array;
        struct rb_node *node;

        list_for_each_entry_safe(rbe, next, &priv->expired, list) {
                list_del(&rbe->list);
                nf_tables_set_elem_destroy(ctx, set, &rbe->priv);
        }

        while ((node = priv->root.rb_node) != NULL) {
                rb_erase(node, &priv->root);
                rbe = rb_entry(node, struct nft_rbtree_elem, node);
                nf_tables_set_elem_destroy(ctx, set, &rbe->priv);
        }

        array = rcu_dereference_protected(priv->array, true);
        if (array)
                __nft_array_free(array);
        if (priv->array_next)
                __nft_array_free(priv->array_next);
}

static bool nft_rbtree_estimate(const struct nft_set_desc *desc, u32 features,
                                struct nft_set_estimate *est)
{
        if (desc->field_count > 1)
                return false;

        if (desc->size)
                est->size = sizeof(struct nft_rbtree) +
                            desc->size * sizeof(struct nft_rbtree_elem);
        else
                est->size = ~0;

        est->lookup = NFT_SET_CLASS_O_LOG_N;
        est->space  = NFT_SET_CLASS_O_N;

        return true;
}

static void nft_array_free_rcu(struct rcu_head *rcu_head)
{
        struct nft_array *array = container_of(rcu_head, struct nft_array, rcu_head);

        __nft_array_free(array);
}

static void nft_rbtree_commit(struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_rbtree_elem *rbe, *prev_rbe;
        struct nft_array *old;
        u32 num_intervals = 0;
        struct rb_node *node;

        /* No changes, skip, eg. elements updates only. */
        if (!priv->array_next)
                return;

        /* GC can be performed if the binary search blob is going
         * to be rebuilt.  It has to be done in two phases: first
         * scan tree and move all expired elements to the expired
         * list.
         *
         * Then, after blob has been re-built and published to other
         * CPUs, queue collected entries for freeing.
         */
        if (time_after_eq(jiffies, priv->last_gc + nft_set_gc_interval(set)))
                nft_rbtree_gc_scan(set);

        /* Reverse walk to create an array from smaller to largest interval. */
        node = rb_last(&priv->root);
        if (node)
                prev_rbe = rb_entry(node, struct nft_rbtree_elem, node);
        else
                prev_rbe = NULL;

        while (prev_rbe) {
                rbe = prev_rbe;

                if (nft_rbtree_interval_start(rbe))
                        priv->array_next->intervals[num_intervals].from = &rbe->ext;
                else if (nft_rbtree_interval_end(rbe))
                        priv->array_next->intervals[num_intervals++].to = &rbe->ext;

                if (num_intervals >= priv->array_next->max_intervals) {
                        pr_warn_once("malformed interval set from userspace?");
                        goto err_out;
                }

                node = rb_prev(node);
                if (!node)
                        break;

                prev_rbe = rb_entry(node, struct nft_rbtree_elem, node);

                /* For anonymous sets, when adjacent ranges are found,
                 * the end element is not added to the set to pack the set
                 * representation. Use next start element to complete this
                 * interval.
                 */
                if (nft_rbtree_interval_start(rbe) &&
                    nft_rbtree_interval_start(prev_rbe) &&
                    priv->array_next->intervals[num_intervals].from)
                        priv->array_next->intervals[num_intervals++].to = &prev_rbe->ext;

                if (num_intervals >= priv->array_next->max_intervals) {
                        pr_warn_once("malformed interval set from userspace?");
                        goto err_out;
                }
        }

        if (priv->array_next->intervals[num_intervals].from)
                num_intervals++;
err_out:
        priv->array_next->num_intervals = num_intervals;
        old = rcu_replace_pointer(priv->array, priv->array_next,
                                  lockdep_is_held(&nft_pernet(read_pnet(&set->net))->commit_mutex));
        priv->array_next = NULL;
        if (old)
                call_rcu(&old->rcu_head, nft_array_free_rcu);

        /* New blob is public, queue collected entries for freeing.
         * call_rcu ensures elements stay around until readers are done.
         */
        nft_rbtree_gc_queue(set);
}

static void nft_rbtree_abort(const struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_array *array_next;

        if (!priv->array_next)
                return;

        array_next = priv->array_next;
        priv->array_next = NULL;
        __nft_array_free(array_next);
}

static void nft_rbtree_gc_init(const struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);

        priv->last_gc = jiffies;
}

/* rbtree stores ranges as singleton elements, each range is composed of two
 * elements ...
 */
static u32 nft_rbtree_ksize(u32 size)
{
        return size * 2;
}

/* ... hide this detail to userspace. */
static u32 nft_rbtree_usize(u32 size)
{
        if (!size)
                return 0;

        return size / 2;
}

static u32 nft_rbtree_adjust_maxsize(const struct nft_set *set)
{
        struct nft_rbtree *priv = nft_set_priv(set);
        struct nft_rbtree_elem *rbe;
        struct rb_node *node;
        const void *key;

        node = rb_last(&priv->root);
        if (!node)
                return 0;

        rbe = rb_entry(node, struct nft_rbtree_elem, node);
        if (!nft_rbtree_interval_end(rbe))
                return 0;

        key = nft_set_ext_key(&rbe->ext);
        if (memchr(key, 1, set->klen))
                return 0;

        /* this is the all-zero no-match element. */
        return 1;
}

const struct nft_set_type nft_set_rbtree_type = {
        .features       = NFT_SET_INTERVAL | NFT_SET_MAP | NFT_SET_OBJECT | NFT_SET_TIMEOUT,
        .ops            = {
                .privsize       = nft_rbtree_privsize,
                .elemsize       = offsetof(struct nft_rbtree_elem, ext),
                .estimate       = nft_rbtree_estimate,
                .init           = nft_rbtree_init,
                .destroy        = nft_rbtree_destroy,
                .insert         = nft_rbtree_insert,
                .remove         = nft_rbtree_remove,
                .deactivate     = nft_rbtree_deactivate,
                .flush          = nft_rbtree_flush,
                .activate       = nft_rbtree_activate,
                .commit         = nft_rbtree_commit,
                .abort          = nft_rbtree_abort,
                .gc_init        = nft_rbtree_gc_init,
                .lookup         = nft_rbtree_lookup,
                .walk           = nft_rbtree_walk,
                .get            = nft_rbtree_get,
                .ksize          = nft_rbtree_ksize,
                .usize          = nft_rbtree_usize,
                .adjust_maxsize = nft_rbtree_adjust_maxsize,
        },
};