Release 4.14 net/ipv6/ip6_fib.c
/*
* Linux INET6 implementation
* Forwarding Information Database
*
* Authors:
* Pedro Roque <roque@di.fc.ul.pt>
*
* 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 of the License, or (at your option) any later version.
*
* Changes:
* Yuji SEKIYA @USAGI: Support default route on router node;
* remove ip6_null_entry from the top of
* routing table.
* Ville Nuorvala: Fixed routing subtrees.
*/
#define pr_fmt(fmt) "IPv6: " fmt
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/net.h>
#include <linux/route.h>
#include <linux/netdevice.h>
#include <linux/in6.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <net/ipv6.h>
#include <net/ndisc.h>
#include <net/addrconf.h>
#include <net/lwtunnel.h>
#include <net/fib_notifier.h>
#include <net/ip6_fib.h>
#include <net/ip6_route.h>
#define RT6_DEBUG 2
#if RT6_DEBUG >= 3
#define RT6_TRACE(x...) pr_debug(x)
#else
#define RT6_TRACE(x...) do { ; } while (0)
#endif
static struct kmem_cache *fib6_node_kmem __read_mostly;
struct fib6_cleaner {
struct fib6_walker w;
struct net *net;
int (*func)(struct rt6_info *, void *arg);
int sernum;
void *arg;
};
#ifdef CONFIG_IPV6_SUBTREES
#define FWS_INIT FWS_S
#else
#define FWS_INIT FWS_L
#endif
static void fib6_prune_clones(struct net *net, struct fib6_node *fn);
static struct rt6_info *fib6_find_prefix(struct net *net, struct fib6_node *fn);
static struct fib6_node *fib6_repair_tree(struct net *net, struct fib6_node *fn);
static int fib6_walk(struct net *net, struct fib6_walker *w);
static int fib6_walk_continue(struct fib6_walker *w);
/*
* A routing update causes an increase of the serial number on the
* affected subtree. This allows for cached routes to be asynchronously
* tested when modifications are made to the destination cache as a
* result of redirects, path MTU changes, etc.
*/
static void fib6_gc_timer_cb(unsigned long arg);
#define FOR_WALKERS(net, w) \
list_for_each_entry(w, &(net)->ipv6.fib6_walkers, lh)
static void fib6_walker_link(struct net *net, struct fib6_walker *w)
{
write_lock_bh(&net->ipv6.fib6_walker_lock);
list_add(&w->lh, &net->ipv6.fib6_walkers);
write_unlock_bh(&net->ipv6.fib6_walker_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Adrian Bunk | 26 | 50.98% | 1 | 25.00% |
| Michal Kubeček | 17 | 33.33% | 1 | 25.00% |
| Alexey Dobriyan | 7 | 13.73% | 1 | 25.00% |
| Hannes Frederic Sowa | 1 | 1.96% | 1 | 25.00% |
| Total | 51 | 100.00% | 4 | 100.00% |
static void fib6_walker_unlink(struct net *net, struct fib6_walker *w)
{
write_lock_bh(&net->ipv6.fib6_walker_lock);
list_del(&w->lh);
write_unlock_bh(&net->ipv6.fib6_walker_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Adrian Bunk | 25 | 56.82% | 1 | 25.00% |
| Michal Kubeček | 13 | 29.55% | 1 | 25.00% |
| Alexey Dobriyan | 5 | 11.36% | 1 | 25.00% |
| Hannes Frederic Sowa | 1 | 2.27% | 1 | 25.00% |
| Total | 44 | 100.00% | 4 | 100.00% |
static int fib6_new_sernum(struct net *net)
{
int new, old;
do {
old = atomic_read(&net->ipv6.fib6_sernum);
new = old < INT_MAX ? old + 1 : 1;
} while (atomic_cmpxchg(&net->ipv6.fib6_sernum,
old, new) != old);
return new;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 52 | 80.00% | 2 | 50.00% |
| Linus Torvalds (pre-git) | 13 | 20.00% | 2 | 50.00% |
| Total | 65 | 100.00% | 4 | 100.00% |
enum {
FIB6_NO_SERNUM_CHANGE = 0,
};
/*
* Auxiliary address test functions for the radix tree.
*
* These assume a 32bit processor (although it will work on
* 64bit processors)
*/
/*
* test bit
*/
#if defined(__LITTLE_ENDIAN)
# define BITOP_BE32_SWIZZLE (0x1F & ~7)
#else
# define BITOP_BE32_SWIZZLE 0
#endif
static __be32 addr_bit_set(const void *token, int fn_bit)
{
const __be32 *addr = token;
/*
* Here,
* 1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)
* is optimized version of
* htonl(1 << ((~fn_bit)&0x1F))
* See include/asm-generic/bitops/le.h.
*/
return (__force __be32)(1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)) &
addr[fn_bit >> 5];
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 34 | 69.39% | 2 | 28.57% |
| Eric Dumazet | 8 | 16.33% | 2 | 28.57% |
| Hideaki Yoshifuji / 吉藤英明 | 4 | 8.16% | 1 | 14.29% |
| Al Viro | 2 | 4.08% | 1 | 14.29% |
| Wang Yufen | 1 | 2.04% | 1 | 14.29% |
| Total | 49 | 100.00% | 7 | 100.00% |
static struct fib6_node *node_alloc(void)
{
struct fib6_node *fn;
fn = kmem_cache_zalloc(fib6_node_kmem, GFP_ATOMIC);
return fn;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 14 | 51.85% | 2 | 40.00% |
| Hannes Frederic Sowa | 10 | 37.04% | 1 | 20.00% |
| Robert P. J. Day | 2 | 7.41% | 1 | 20.00% |
| Christoph Lameter | 1 | 3.70% | 1 | 20.00% |
| Total | 27 | 100.00% | 5 | 100.00% |
static void node_free_immediate(struct fib6_node *fn)
{
kmem_cache_free(fib6_node_kmem, fn);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 16 | 88.89% | 2 | 50.00% |
| Wei Wang | 1 | 5.56% | 1 | 25.00% |
| Robert P. J. Day | 1 | 5.56% | 1 | 25.00% |
| Total | 18 | 100.00% | 4 | 100.00% |
static void node_free_rcu(struct rcu_head *head)
{
struct fib6_node *fn = container_of(head, struct fib6_node, rcu);
kmem_cache_free(fib6_node_kmem, fn);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Wei Wang | 33 | 100.00% | 1 | 100.00% |
| Total | 33 | 100.00% | 1 | 100.00% |
static void node_free(struct fib6_node *fn)
{
call_rcu(&fn->rcu, node_free_rcu);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Wei Wang | 21 | 100.00% | 1 | 100.00% |
| Total | 21 | 100.00% | 1 | 100.00% |
void rt6_free_pcpu(struct rt6_info *non_pcpu_rt)
{
int cpu;
if (!non_pcpu_rt->rt6i_pcpu)
return;
for_each_possible_cpu(cpu) {
struct rt6_info **ppcpu_rt;
struct rt6_info *pcpu_rt;
ppcpu_rt = per_cpu_ptr(non_pcpu_rt->rt6i_pcpu, cpu);
pcpu_rt = *ppcpu_rt;
if (pcpu_rt) {
dst_dev_put(&pcpu_rt->dst);
dst_release(&pcpu_rt->dst);
*ppcpu_rt = NULL;
}
}
free_percpu(non_pcpu_rt->rt6i_pcpu);
non_pcpu_rt->rt6i_pcpu = NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin KaFai Lau | 78 | 82.98% | 3 | 60.00% |
| Wei Wang | 16 | 17.02% | 2 | 40.00% |
| Total | 94 | 100.00% | 5 | 100.00% |
EXPORT_SYMBOL_GPL(rt6_free_pcpu);
static void fib6_free_table(struct fib6_table *table)
{
inetpeer_invalidate_tree(&table->tb6_peers);
kfree(table);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Sabrina Dubroca | 24 | 100.00% | 1 | 100.00% |
| Total | 24 | 100.00% | 1 | 100.00% |
static void fib6_link_table(struct net *net, struct fib6_table *tb)
{
unsigned int h;
/*
* Initialize table lock at a single place to give lockdep a key,
* tables aren't visible prior to being linked to the list.
*/
rwlock_init(&tb->tb6_lock);
h = tb->tb6_id & (FIB6_TABLE_HASHSZ - 1);
/*
* No protection necessary, this is the only list mutatation
* operation, tables never disappear once they exist.
*/
hlist_add_head_rcu(&tb->tb6_hlist, &net->ipv6.fib_table_hash[h]);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 41 | 68.33% | 1 | 25.00% |
| Daniel Lezcano | 9 | 15.00% | 1 | 25.00% |
| Thomas Graf | 9 | 15.00% | 1 | 25.00% |
| Neil Horman | 1 | 1.67% | 1 | 25.00% |
| Total | 60 | 100.00% | 4 | 100.00% |
#ifdef CONFIG_IPV6_MULTIPLE_TABLES
static struct fib6_table *fib6_alloc_table(struct net *net, u32 id)
{
struct fib6_table *table;
table = kzalloc(sizeof(*table), GFP_ATOMIC);
if (table) {
table->tb6_id = id;
table->tb6_root.leaf = net->ipv6.ip6_null_entry;
table->tb6_root.fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
inet_peer_base_init(&table->tb6_peers);
}
return table;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Thomas Graf | 64 | 79.01% | 1 | 33.33% |
| Daniel Lezcano | 9 | 11.11% | 1 | 33.33% |
| David S. Miller | 8 | 9.88% | 1 | 33.33% |
| Total | 81 | 100.00% | 3 | 100.00% |
struct fib6_table *fib6_new_table(struct net *net, u32 id)
{
struct fib6_table *tb;
if (id == 0)
id = RT6_TABLE_MAIN;
tb = fib6_get_table(net, id);
if (tb)
return tb;
tb = fib6_alloc_table(net, id);
if (tb)
fib6_link_table(net, tb);
return tb;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Thomas Graf | 58 | 84.06% | 1 | 33.33% |
| Daniel Lezcano | 11 | 15.94% | 2 | 66.67% |
| Total | 69 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL_GPL(fib6_new_table);
struct fib6_table *fib6_get_table(struct net *net, u32 id)
{
struct fib6_table *tb;
struct hlist_head *head;
unsigned int h;
if (id == 0)
id = RT6_TABLE_MAIN;
h = id & (FIB6_TABLE_HASHSZ - 1);
rcu_read_lock();
head = &net->ipv6.fib_table_hash[h];
hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
if (tb->tb6_id == id) {
rcu_read_unlock();
return tb;
}
}
rcu_read_unlock();
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 46 | 47.92% | 1 | 25.00% |
| Thomas Graf | 27 | 28.12% | 1 | 25.00% |
| Daniel Lezcano | 22 | 22.92% | 1 | 25.00% |
| Neil Horman | 1 | 1.04% | 1 | 25.00% |
| Total | 96 | 100.00% | 4 | 100.00% |
EXPORT_SYMBOL_GPL(fib6_get_table);
static void __net_init fib6_tables_init(struct net *net)
{
fib6_link_table(net, net->ipv6.fib6_main_tbl);
fib6_link_table(net, net->ipv6.fib6_local_tbl);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 17 | 50.00% | 1 | 33.33% |
| Daniel Lezcano | 16 | 47.06% | 1 | 33.33% |
| Alexey Dobriyan | 1 | 2.94% | 1 | 33.33% |
| Total | 34 | 100.00% | 3 | 100.00% |
#else
struct fib6_table *fib6_new_table(struct net *net, u32 id)
{
return fib6_get_table(net, id);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 16 | 69.57% | 1 | 50.00% |
| Daniel Lezcano | 7 | 30.43% | 1 | 50.00% |
| Total | 23 | 100.00% | 2 | 100.00% |
struct fib6_table *fib6_get_table(struct net *net, u32 id)
{
return net->ipv6.fib6_main_tbl;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 13 | 59.09% | 1 | 50.00% |
| Daniel Lezcano | 9 | 40.91% | 1 | 50.00% |
| Total | 22 | 100.00% | 2 | 100.00% |
struct dst_entry *fib6_rule_lookup(struct net *net, struct flowi6 *fl6,
int flags, pol_lookup_t lookup)
{
struct rt6_info *rt;
rt = lookup(net, net->ipv6.fib6_main_tbl, fl6, flags);
if (rt->dst.error == -EAGAIN) {
ip6_rt_put(rt);
rt = net->ipv6.ip6_null_entry;
dst_hold(&rt->dst);
}
return &rt->dst;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Xin Long | 47 | 55.29% | 1 | 20.00% |
| Patrick McHardy | 24 | 28.24% | 1 | 20.00% |
| Daniel Lezcano | 11 | 12.94% | 2 | 40.00% |
| David S. Miller | 3 | 3.53% | 1 | 20.00% |
| Total | 85 | 100.00% | 5 | 100.00% |
static void __net_init fib6_tables_init(struct net *net)
{
fib6_link_table(net, net->ipv6.fib6_main_tbl);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 12 | 52.17% | 1 | 33.33% |
| Daniel Lezcano | 10 | 43.48% | 1 | 33.33% |
| Alexey Dobriyan | 1 | 4.35% | 1 | 33.33% |
| Total | 23 | 100.00% | 3 | 100.00% |
#endif
unsigned int fib6_tables_seq_read(struct net *net)
{
unsigned int h, fib_seq = 0;
rcu_read_lock();
for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
struct hlist_head *head = &net->ipv6.fib_table_hash[h];
struct fib6_table *tb;
hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
read_lock_bh(&tb->tb6_lock);
fib_seq += tb->fib_seq;
read_unlock_bh(&tb->tb6_lock);
}
}
rcu_read_unlock();
return fib_seq;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 95 | 100.00% | 1 | 100.00% |
| Total | 95 | 100.00% | 1 | 100.00% |
static int call_fib6_entry_notifier(struct notifier_block *nb, struct net *net,
enum fib_event_type event_type,
struct rt6_info *rt)
{
struct fib6_entry_notifier_info info = {
.rt = rt,
};
return call_fib6_notifier(nb, net, event_type, &info.info);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 51 | 100.00% | 1 | 100.00% |
| Total | 51 | 100.00% | 1 | 100.00% |
static int call_fib6_entry_notifiers(struct net *net,
enum fib_event_type event_type,
struct rt6_info *rt)
{
struct fib6_entry_notifier_info info = {
.rt = rt,
};
rt->rt6i_table->fib_seq++;
return call_fib6_notifiers(net, event_type, &info.info);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 51 | 100.00% | 2 | 100.00% |
| Total | 51 | 100.00% | 2 | 100.00% |
struct fib6_dump_arg {
struct net *net;
struct notifier_block *nb;
};
static void fib6_rt_dump(struct rt6_info *rt, struct fib6_dump_arg *arg)
{
if (rt == arg->net->ipv6.ip6_null_entry)
return;
call_fib6_entry_notifier(arg->nb, arg->net, FIB_EVENT_ENTRY_ADD, rt);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 44 | 100.00% | 1 | 100.00% |
| Total | 44 | 100.00% | 1 | 100.00% |
static int fib6_node_dump(struct fib6_walker *w)
{
struct rt6_info *rt;
for (rt = w->leaf; rt; rt = rt->dst.rt6_next)
fib6_rt_dump(rt, w->args);
w->leaf = NULL;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 52 | 100.00% | 1 | 100.00% |
| Total | 52 | 100.00% | 1 | 100.00% |
static void fib6_table_dump(struct net *net, struct fib6_table *tb,
struct fib6_walker *w)
{
w->root = &tb->tb6_root;
read_lock_bh(&tb->tb6_lock);
fib6_walk(net, w);
read_unlock_bh(&tb->tb6_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 53 | 100.00% | 1 | 100.00% |
| Total | 53 | 100.00% | 1 | 100.00% |
/* Called with rcu_read_lock() */
int fib6_tables_dump(struct net *net, struct notifier_block *nb)
{
struct fib6_dump_arg arg;
struct fib6_walker *w;
unsigned int h;
w = kzalloc(sizeof(*w), GFP_ATOMIC);
if (!w)
return -ENOMEM;
w->func = fib6_node_dump;
arg.net = net;
arg.nb = nb;
w->args = &arg;
for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
struct hlist_head *head = &net->ipv6.fib_table_hash[h];
struct fib6_table *tb;
hlist_for_each_entry_rcu(tb, head, tb6_hlist)
fib6_table_dump(net, tb, w);
}
kfree(w);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ido Schimmel | 135 | 100.00% | 1 | 100.00% |
| Total | 135 | 100.00% | 1 | 100.00% |
static int fib6_dump_node(struct fib6_walker *w)
{
int res;
struct rt6_info *rt;
for (rt = w->leaf; rt; rt = rt->dst.rt6_next) {
res = rt6_dump_route(rt, w->args);
if (res < 0) {
/* Frame is full, suspend walking */
w->leaf = rt;
return 1;
}
/* Multipath routes are dumped in one route with the
* RTA_MULTIPATH attribute. Jump 'rt' to point to the
* last sibling of this route (no need to dump the
* sibling routes again)
*/
if (rt->rt6i_nsiblings)
rt = list_last_entry(&rt->rt6i_siblings,
struct rt6_info,
rt6i_siblings);
}
w->leaf = NULL;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 73 | 73.74% | 1 | 25.00% |
| David Ahern | 22 | 22.22% | 1 | 25.00% |
| Eric Dumazet | 3 | 3.03% | 1 | 25.00% |
| Hannes Frederic Sowa | 1 | 1.01% | 1 | 25.00% |
| Total | 99 | 100.00% | 4 | 100.00% |
static void fib6_dump_end(struct netlink_callback *cb)
{
struct net *net = sock_net(cb->skb->sk);
struct fib6_walker *w = (void *)cb->args[2];
if (w) {
if (cb->args[4]) {
cb->args[4] = 0;
fib6_walker_unlink(net, w);
}
cb->args[2] = 0;
kfree(w);
}
cb->done = (void *)cb->args[3];
cb->args[1] = 3;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 70 | 62.50% | 1 | 25.00% |
| Herbert Xu | 25 | 22.32% | 1 | 25.00% |
| Michal Kubeček | 16 | 14.29% | 1 | 25.00% |
| Hannes Frederic Sowa | 1 | 0.89% | 1 | 25.00% |
| Total | 112 | 100.00% | 4 | 100.00% |
static int fib6_dump_done(struct netlink_callback *cb)
{
fib6_dump_end(cb);
return cb->done ? cb->done(cb) : 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 30 | 100.00% | 1 | 100.00% |
| Total | 30 | 100.00% | 1 | 100.00% |
static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb,
struct netlink_callback *cb)
{
struct net *net = sock_net(skb->sk);
struct fib6_walker *w;
int res;
w = (void *)cb->args[2];
w->root = &table->tb6_root;
if (cb->args[4] == 0) {
w->count = 0;
w->skip = 0;
read_lock_bh(&table->tb6_lock);
res = fib6_walk(net, w);
read_unlock_bh(&table->tb6_lock);
if (res > 0) {
cb->args[4] = 1;
cb->args[5] = w->root->fn_sernum;
}
} else {
if (cb->args[5] != w->root->fn_sernum) {
/* Begin at the root if the tree changed */
cb->args[5] = w->root->fn_sernum;
w->state = FWS_INIT;
w->node = w->root;
w->skip = w->count;
} else
w->skip = 0;
read_lock_bh(&table->tb6_lock);
res = fib6_walk_continue(w);
read_unlock_bh(&table->tb6_lock);
if (res <= 0) {
fib6_walker_unlink(net, w);
cb->args[4] = 0;
}
}
return res;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 237 | 92.58% | 2 | 40.00% |
| Michal Kubeček | 16 | 6.25% | 1 | 20.00% |
| Herbert Xu | 2 | 0.78% | 1 | 20.00% |
| Hannes Frederic Sowa | 1 | 0.39% | 1 | 20.00% |
| Total | 256 | 100.00% | 5 | 100.00% |
static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
{
struct net *net = sock_net(skb->sk);
unsigned int h, s_h;
unsigned int e = 0, s_e;
struct rt6_rtnl_dump_arg arg;
struct fib6_walker *w;
struct fib6_table *tb;
struct hlist_head *head;
int res = 0;
s_h = cb->args[0];
s_e = cb->args[1];
w = (void *)cb->args[2];
if (!w) {
/* New dump:
*
* 1. hook callback destructor.
*/
cb->args[3] = (long)cb->done;
cb->done = fib6_dump_done;
/*
* 2. allocate and initialize walker.
*/
w = kzalloc(sizeof(*w), GFP_ATOMIC);
if (!w)
return -ENOMEM;
w->func = fib6_dump_node;
cb->args[2] = (long)w;
}
arg.skb = skb;
arg.cb = cb;
arg.net = net;
w->args = &arg;
rcu_read_lock();
for (h = s_h; h < FIB6_TABLE_HASHSZ; h++, s_e = 0) {
e = 0;
head = &net->ipv6.fib_table_hash[h];
hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
if (e < s_e)
goto next;
res = fib6_dump_table(tb, skb, cb);
if (res != 0)
goto out;
next:
e++;
}
}
out:
rcu_read_unlock();
cb->args[1] = e;
cb->args[0] = h;
res = res < 0 ? res : skb->len;
if (res <= 0)
fib6_dump_end(cb);
return res;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Patrick McHardy | 249 | 77.33% | 1 | 8.33% |
| Thomas Graf | 27 | 8.39% | 3 | 25.00% |
| Daniel Lezcano | 17 | 5.28% | 1 | 8.33% |
| Denis V. Lunev | 9 | 2.80% | 1 | 8.33% |
| Eric Dumazet | 7 | 2.17% | 1 | 8.33% |
| Brian Haley | 6 | 1.86% | 1 | 8.33% |
| Hideaki Yoshifuji / 吉藤英明 | 3 | 0.93% | 1 | 8.33% |
| David S. Miller | 2 | 0.62% | 1 | 8.33% |
| Neil Horman | 1 | 0.31% | 1 | 8.33% |
| Hannes Frederic Sowa | 1 | 0.31% | 1 | 8.33% |
| Total | 322 | 100.00% | 12 | 100.00% |
/*
* Routing Table
*
* return the appropriate node for a routing tree "add" operation
* by either creating and inserting or by returning an existing
* node.
*/
static struct fib6_node *fib6_add_1(struct fib6_node *root,
struct in6_addr *addr, int plen,
int offset, int allow_create,
int replace_required, int sernum,
struct netlink_ext_ack *extack)
{
struct fib6_node *fn, *in, *ln;
struct fib6_node *pn = NULL;
struct rt6key *key;
int bit;
__be32 dir = 0;
RT6_TRACE("fib6_add_1\n");
/* insert node in tree */
fn = root;
do {
key = (struct rt6key *)((u8 *)fn->leaf + offset);
/*
* Prefix match
*/
if (plen < fn->fn_bit ||
!ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) {
if (!allow_create) {
if (replace_required) {
NL_SET_ERR_MSG(extack,
"Can not replace route - no match found");
pr_warn("Can't replace route, no match found\n");
return ERR_PTR(-ENOENT);
}
pr_warn("NLM_F_CREATE should be set when creating new route\n");
}
goto insert_above;
}
/*
* Exact match ?
*/
if (plen == fn->fn_bit) {
/* clean up an intermediate node */
if (!(fn->fn_flags & RTN_RTINFO)) {
rt6_release(fn->leaf);
fn->leaf = NULL;
}
fn->fn_sernum = sernum;
return fn;
}
/*
* We have more bits to go
*/
/* Try to walk down on tree. */
fn->fn_sernum = sernum;
dir = addr_bit_set(addr, fn->fn_bit);
pn = fn;
fn = dir ? fn->right : fn->left;
} while (fn);
if (!allow_create) {
/* We should not create new node because
* NLM_F_REPLACE was specified without NLM_F_CREATE
* I assume it is safe to require NLM_F_CREATE when
* REPLACE flag is used! Later we may want to remove the
* check for replace_required, because according
* to netlink specification, NLM_F_CREATE
* MUST be specified if new route is created.
* That would keep IPv6 consistent with IPv4
*/
if (replace_required) {
NL_SET_ERR_MSG(extack,
"Can not replace route - no match found");
pr_warn("Can't replace route, no match found\n");
return ERR_PTR(-ENOENT);
}
pr_warn("NLM_F_CREATE should be set when creating new route\n");
}
/*
* We walked to the bottom of tree.
* Create new leaf node without children.
*/
ln = node_alloc();
if (!ln)
return ERR_PTR(-ENOMEM);
ln->fn_bit = plen;
ln->parent = pn;
ln->fn_sernum = sernum;
if (dir)
pn->right = ln;
else
pn->left = ln;
return ln;
insert_above:
/*
* split since we don't have a common prefix anymore or
* we have a less significant route.
* we've to insert an intermediate node on the list
* this new node will point to the one we need to create
* and the current
*/
pn = fn->parent;
/* find 1st bit in difference between the 2 addrs.
See comment in __ipv6_addr_diff: bit may be an invalid value,
but if it is >= plen, the value is ignored in any case.
*/
bit = __ipv6_addr_diff(addr, &key->addr, sizeof(*addr));
/*
* (intermediate)[in]
* / \
* (new leaf node)[ln] (old node)[fn]
*/
if (plen > bit) {
in = node_alloc();
ln = node_alloc();
if (!in || !ln) {
if (in)
node_free_immediate(in);
if (ln)
node_free_immediate(ln);
return ERR_PTR(-ENOMEM);
}
/*
* new intermediate node.
* RTN_RTINFO will
* be off since that an address that chooses one of
* the branches would not match less specific routes
* in the other branch
*/
in->fn_bit = bit;
in->parent = pn;
in->leaf = fn->leaf;
atomic_inc(&in->leaf->rt6i_ref);
in->fn_sernum = sernum;
/* update parent pointer */
if (dir)
pn->right = in;
else
pn->left = in;
ln->fn_bit = plen;
ln->parent = in;
fn->parent = in;
ln->fn_sernum = sernum;
if (addr_bit_set(addr, bit)) {
in->right = ln;
in->left = fn;
} else {
in->left = ln;
in->right = fn;
}
} else { /* plen <= bit */
/*
* (new leaf node)[ln]
* / \
* (old node)[fn] NULL
*/
ln = node_alloc();
if (!ln)
return ERR_PTR(-ENOMEM);
ln->fn_bit = plen;
ln->parent = pn;
ln->fn_sernum = sernum;
if (dir)
pn->right = ln;
else
pn->left = ln;
if (addr_bit_set(&key->addr, plen))
ln->right = fn;
else
ln->left = fn;
fn->parent = ln;
}
return ln;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 509 | 79.78% | 3 | 16.67% |
| Matti Vaittinen | 62 | 9.72% | 2 | 11.11% |
| David Ahern | 19 | 2.98% | 2 | 11.11% |
| Lin Ming | 15 | 2.35% | 1 | 5.56% |
| David S. Miller | 9 | 1.41% | 2 | 11.11% |
| Fan Du | 7 | 1.10% | 1 | 5.56% |
| Hideaki Yoshifuji / 吉藤英明 | 7 | 1.10% | 3 | 16.67% |
| Joe Perches | 4 | 0.63% | 1 | 5.56% |
| Hannes Frederic Sowa | 3 | 0.47% | 1 | 5.56% |
| Wei Wang | 2 | 0.31% | 1 | 5.56% |
| Al Viro | 1 | 0.16% | 1 | 5.56% |
| Total | 638 | 100.00% | 18 | 100.00% |
static bool rt6_qualify_for_ecmp(struct rt6_info *rt)
{
return (rt->rt6i_flags & (RTF_GATEWAY|RTF_ADDRCONF|RTF_DYNAMIC)) ==
RTF_GATEWAY;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 28 | 100.00% | 1 | 100.00% |
| Total | 28 | 100.00% | 1 | 100.00% |
static void fib6_copy_metrics(u32 *mp, const struct mx6_config *mxc)
{
int i;
for (i = 0; i < RTAX_MAX; i++) {
if (test_bit(i, mxc->mx_valid))
mp[i] = mxc->mx[i];
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Florian Westphal | 57 | 100.00% | 1 | 100.00% |
| Total | 57 | 100.00% | 1 | 100.00% |
static int fib6_commit_metrics(struct dst_entry *dst, struct mx6_config *mxc)
{
if (!mxc->mx)
return 0;
if (dst->flags & DST_HOST) {
u32 *mp = dst_metrics_write_ptr(dst);
if (unlikely(!mp))
return -ENOMEM;
fib6_copy_metrics(mp, mxc);
} else {
dst_init_metrics(dst, mxc->mx, false);
/* We've stolen mx now. */
mxc->mx = NULL;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Michal Kubeček | 45 | 51.14% | 1 | 33.33% |
| Florian Westphal | 35 | 39.77% | 1 | 33.33% |
| Daniel Borkmann | 8 | 9.09% | 1 | 33.33% |
| Total | 88 | 100.00% | 3 | 100.00% |
static void fib6_purge_rt(struct rt6_info *rt, struct fib6_node *fn,
struct net *net)
{
if (atomic_read(&rt->rt6i_ref) != 1) {
/* This route is used as dummy address holder in some split
* nodes. It is not leaked, but it still holds other resources,
* which must be released in time. So, scan ascendant nodes
* and replace dummy references to this route with references
* to still alive ones.
*/
while (fn) {
if (!(fn->fn_flags & RTN_RTINFO) && fn->leaf == rt) {
fn->leaf = fib6_find_prefix(net, fn);
atomic_inc(&fn->leaf->rt6i_ref);
rt6_release(rt);
}
fn = fn->parent;
}
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 93 | 100.00% | 1 | 100.00% |
| Total | 93 | 100.00% | 1 | 100.00% |
/*
* Insert routing information in a node.
*/
static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
struct nl_info *info, struct mx6_config *mxc)
{
struct rt6_info *iter = NULL;
struct rt6_info **ins;
struct rt6_info **fallback_ins = NULL;
int replace = (info->nlh &&
(info->nlh->nlmsg_flags & NLM_F_REPLACE));
int add = (!info->nlh ||
(info->nlh->nlmsg_flags & NLM_F_CREATE));
int found = 0;
bool rt_can_ecmp = rt6_qualify_for_ecmp(rt);
u16 nlflags = NLM_F_EXCL;
int err;
if (info->nlh && (info->nlh->nlmsg_flags & NLM_F_APPEND))
nlflags |= NLM_F_APPEND;
ins = &fn->leaf;
for (iter = fn->leaf; iter; iter = iter->dst.rt6_next) {
/*
* Search for duplicates
*/
if (iter->rt6i_metric == rt->rt6i_metric) {
/*
* Same priority level
*/
if (info->nlh &&
(info->nlh->nlmsg_flags & NLM_F_EXCL))
return -EEXIST;
nlflags &= ~NLM_F_EXCL;
if (replace) {
if (rt_can_ecmp == rt6_qualify_for_ecmp(iter)) {
found++;
break;
}
if (rt_can_ecmp)
fallback_ins = fallback_ins ?: ins;
goto next_iter;
}
if (rt6_duplicate_nexthop(iter, rt)) {
if (rt->rt6i_nsiblings)
rt->rt6i_nsiblings = 0;
if (!(iter->rt6i_flags & RTF_EXPIRES))
return -EEXIST;
if (!(rt->rt6i_flags & RTF_EXPIRES))
rt6_clean_expires(iter);
else
rt6_set_expires(iter, rt->dst.expires);
iter->rt6i_pmtu = rt->rt6i_pmtu;
return -EEXIST;
}
/* If we have the same destination and the same metric,
* but not the same gateway, then the route we try to
* add is sibling to this route, increment our counter
* of siblings, and later we will add our route to the
* list.
* Only static routes (which don't have flag
* RTF_EXPIRES) are used for ECMPv6.
*
* To avoid long list, we only had siblings if the
* route have a gateway.
*/
if (rt_can_ecmp &&
rt6_qualify_for_ecmp(iter))
rt->rt6i_nsiblings++;
}
if (iter->rt6i_metric > rt->rt6i_metric)
break;
next_iter:
ins = &iter->dst.rt6_next;
}
if (fallback_ins && !found) {
/* No ECMP-able route found, replace first non-ECMP one */
ins = fallback_ins;
iter = *ins;
found++;
}
/* Reset round-robin state, if necessary */
if (ins == &fn->leaf)
fn->rr_ptr = NULL;
/* Link this route to others same route. */
if (rt->rt6i_nsiblings) {
unsigned int rt6i_nsiblings;
struct rt6_info *sibling, *temp_sibling;
/* Find the first route that have the same metric */
sibling = fn->leaf;
while (sibling) {
if (sibling->rt6i_metric == rt->rt6i_metric &&
rt6_qualify_for_ecmp(sibling)) {
list_add_tail(&rt->rt6i_siblings,
&sibling->rt6i_siblings);
break;
}
sibling = sibling->dst.rt6_next;
}
/* For each sibling in the list, increment the counter of
* siblings. BUG() if counters does not match, list of siblings
* is broken!
*/
rt6i_nsiblings = 0;
list_for_each_entry_safe(sibling, temp_sibling,
&rt->rt6i_siblings, rt6i_siblings) {
sibling->rt6i_nsiblings++;
BUG_ON(sibling->rt6i_nsiblings != rt->rt6i_nsiblings);
rt6i_nsiblings++;
}
BUG_ON(rt6i_nsiblings != rt->rt6i_nsiblings);
}
/*
* insert node
*/
if (!replace) {
if (!add)
pr_warn("NLM_F_CREATE should be set when creating new route\n");
add:
nlflags |= NLM_F_CREATE;
err = fib6_commit_metrics(&rt->dst, mxc);
if (err)
return err;
rt->dst.rt6_next = iter;
*ins = rt;
rcu_assign_pointer(rt->rt6i_node, fn);
atomic_inc(&rt->rt6i_ref);
call_fib6_entry_notifiers(info->nl_net, FIB_EVENT_ENTRY_ADD,
rt);
if (!info->skip_notify)
inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
info->nl_net->ipv6.rt6_stats->fib_rt_entries++;
if (!(fn->fn_flags & RTN_RTINFO)) {
info->nl_net->ipv6.rt6_stats->fib_route_nodes++;
fn->fn_flags |= RTN_RTINFO;
}
} else {
int nsiblings;
if (!found) {
if (add)
goto add;
pr_warn("NLM_F_REPLACE set, but no existing node found!\n");
return -ENOENT;
}
err = fib6_commit_metrics(&rt->dst, mxc);
if (err)
return err;
*ins = rt;
rcu_assign_pointer(rt->rt6i_node, fn);
rt->dst.rt6_next = iter->dst.rt6_next;
atomic_inc(&rt->rt6i_ref);
call_fib6_entry_notifiers(info->nl_net, FIB_EVENT_ENTRY_REPLACE,
rt);
if (!info->skip_notify)
inet6_rt_notify(RTM_NEWROUTE, rt, info, NLM_F_REPLACE);
if (!(fn->fn_flags & RTN_RTINFO)) {
info->nl_net->ipv6.rt6_stats->fib_route_nodes++;
fn->fn_flags |= RTN_RTINFO;
}
nsiblings = iter->rt6i_nsiblings;
iter->rt6i_node = NULL;
fib6_purge_rt(iter, fn, info->nl_net);
if (fn->rr_ptr == iter)
fn->rr_ptr = NULL;
rt6_release(iter);
if (nsiblings) {
/* Replacing an ECMP route, remove all siblings */
ins = &rt->dst.rt6_next;
iter = *ins;
while (iter) {
if (iter->rt6i_metric > rt->rt6i_metric)
break;
if (rt6_qualify_for_ecmp(iter)) {
*ins = iter->dst.rt6_next;
iter->rt6i_node = NULL;
fib6_purge_rt(iter, fn, info->nl_net);
if (fn->rr_ptr == iter)
fn->rr_ptr = NULL;
rt6_release(iter);
nsiblings--;
} else {
ins = &iter->dst.rt6_next;
}
iter = *ins;
}
WARN_ON(nsiblings != 0);
}
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Michal Kubeček | 196 | 20.70% | 2 | 6.06% |
| Linus Torvalds (pre-git) | 189 | 19.96% | 4 | 12.12% |
| Matti Vaittinen | 182 | 19.22% | 1 | 3.03% |
| Nicolas Dichtel | 136 | 14.36% | 1 | 3.03% |
| Wei Wang | 36 | 3.80% | 2 | 6.06% |
| David Ahern | 35 | 3.70% | 3 | 9.09% |
| Ido Schimmel | 34 | 3.59% | 2 | 6.06% |
| Hannes Frederic Sowa | 33 | 3.48% | 2 | 6.06% |
| David S. Miller | 24 | 2.53% | 4 | 12.12% |
| Guillaume Nault | 15 | 1.58% | 1 | 3.03% |
| Benjamin Thery | 12 | 1.27% | 1 | 3.03% |
| Sabrina Dubroca | 11 | 1.16% | 1 | 3.03% |
| Eric Dumazet | 9 | 0.95% | 1 | 3.03% |
| Gao Feng | 9 | 0.95% | 1 | 3.03% |
| Martin KaFai Lau | 8 | 0.84% | 1 | 3.03% |
| Mathew Richardson | 4 | 0.42% | 1 | 3.03% |
| Florian Westphal | 4 | 0.42% | 1 | 3.03% |
| Thomas Graf | 3 | 0.32% | 1 | 3.03% |
| Roopa Prabhu | 3 | 0.32% | 1 | 3.03% |
| Joe Perches | 2 | 0.21% | 1 | 3.03% |
| Daniel Lezcano | 2 | 0.21% | 1 | 3.03% |
| Total | 947 | 100.00% | 33 | 100.00% |
static void fib6_start_gc(struct net *net, struct rt6_info *rt)
{
if (!timer_pending(&net->ipv6.ip6_fib_timer) &&
(rt->rt6i_flags & (RTF_EXPIRES | RTF_CACHE)))
mod_timer(&net->ipv6.ip6_fib_timer,
jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 36 | 59.02% | 4 | 50.00% |
| Daniel Lezcano | 19 | 31.15% | 2 | 25.00% |
| Stephen Hemminger | 6 | 9.84% | 2 | 25.00% |
| Total | 61 | 100.00% | 8 | 100.00% |
void fib6_force_start_gc(struct net *net)
{
if (!timer_pending(&net->ipv6.ip6_fib_timer))
mod_timer(&net->ipv6.ip6_fib_timer,
jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David S. Miller | 19 | 44.19% | 1 | 20.00% |
| Daniel Lezcano | 18 | 41.86% | 2 | 40.00% |
| Stephen Hemminger | 6 | 13.95% | 2 | 40.00% |
| Total | 43 | 100.00% | 5 | 100.00% |
/*
* Add routing information to the routing tree.
* <destination addr>/<source addr>
* with source addr info in sub-trees
*/
int fib6_add(struct fib6_node *root, struct rt6_info *rt,
struct nl_info *info, struct mx6_config *mxc,
struct netlink_ext_ack *extack)
{
struct fib6_node *fn, *pn = NULL;
int err = -ENOMEM;
int allow_create = 1;
int replace_required = 0;
int sernum = fib6_new_sernum(info->nl_net);
if (WARN_ON_ONCE(!atomic_read(&rt->dst.__refcnt)))
return -EINVAL;
if (info->nlh) {
if (!(info->nlh->nlmsg_flags & NLM_F_CREATE))
allow_create = 0;
if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
replace_required = 1;
}
if (!allow_create && !replace_required)
pr_warn("RTM_NEWROUTE with no NLM_F_CREATE or NLM_F_REPLACE\n");
fn = fib6_add_1(root, &rt->rt6i_dst.addr, rt->rt6i_dst.plen,
offsetof(struct rt6_info, rt6i_dst), allow_create,
replace_required, sernum, extack);
if (IS_ERR(fn)) {
err = PTR_ERR(fn);
fn = NULL;
goto out;
}
pn = fn;
#ifdef CONFIG_IPV6_SUBTREES
if (rt->rt6i_src.plen) {
struct fib6_node *sn;
if (!fn->subtree) {
struct fib6_node *sfn;
/*
* Create subtree.
*
* fn[main tree]
* |
* sfn[subtree root]
* \
* sn[new leaf node]
*/
/* Create subtree root node */
sfn = node_alloc();
if (!sfn)
goto failure;
sfn->leaf = info->nl_net->ipv6.ip6_null_entry;
atomic_inc(&info->nl_net->ipv6.ip6_null_entry->rt6i_ref);
sfn->fn_flags = RTN_ROOT;
sfn->fn_sernum = sernum;
/* Now add the first leaf node to new subtree */
sn = fib6_add_1(sfn, &rt->rt6i_src.addr,
rt->rt6i_src.plen,
offsetof(struct rt6_info, rt6i_src),
allow_create, replace_required, sernum,
extack);
if (IS_ERR(sn)) {
/* If it is failed, discard just allocated
root, and then (in failure) stale node
in main tree.
*/
node_free_immediate(sfn);
err = PTR_ERR(sn);
goto failure;
}
/* Now link new subtree to main tree */
sfn->parent = fn;
fn->subtree = sfn;
} else {
sn = fib6_add_1(fn->subtree, &rt->rt6i_src.addr,
rt->rt6i_src.plen,
offsetof(struct rt6_info, rt6i_src),
allow_create, replace_required, sernum,
extack);
if (IS_ERR(sn)) {
err = PTR_ERR(sn);
goto failure;
}
}
if (!fn->leaf) {
fn->leaf = rt;
atomic_inc(&rt->rt6i_ref);
}
fn = sn;
}
#endif
err = fib6_add_rt2node(fn, rt, info, mxc);
if (!err) {
fib6_start_gc(info->nl_net, rt);
if (!(rt->rt6i_flags & RTF_CACHE))
fib6_prune_clones(info->nl_net, pn);
}
out:
if (err) {
#ifdef CONFIG_IPV6_SUBTREES
/*
* If fib6_add_1 has cleared the old leaf pointer in the
* super-tree leaf node we have to find a new one for it.
*/
if (pn != fn && pn->leaf == rt) {
pn->leaf = NULL;
atomic_dec(&rt->rt6i_ref);
}
if (pn != fn && !pn->leaf && !(pn->fn_flags & RTN_RTINFO)) {
pn->leaf = fib6_find_prefix(info->nl_net, pn);
#if RT6_DEBUG >= 2
if (!pn->leaf) {
WARN_ON(pn->leaf == NULL);
pn->leaf = info->nl_net->ipv6.ip6_null_entry;
}
#endif
atomic_inc(&pn->leaf->rt6i_ref);
}
#endif
goto failure;
}
return err;
failure:
/* fn->leaf could be NULL if fn is an intermediate node and we
* failed to add the new route to it in both subtree creation
* failure and fib6_add_rt2node() failure case.
* In both cases, fib6_repair_tree() should be called to fix
* fn->leaf.
*/
if (fn && !(fn->fn_flags & (RTN_RTINFO|RTN_ROOT)))
fib6_repair_tree(info->nl_net, fn);
/* Always release dst as dst->__refcnt is guaranteed
* to be taken before entering this function
*/
dst_release_immediate(&rt->dst);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 274 | 40.90% | 4 | 12.12% |
| Hideaki Yoshifuji / 吉藤英明 | 131 | 19.55% | 4 | 12.12% |
| Matti Vaittinen | 100 | 14.93% | 1 | 3.03% |
| David S. Miller | 33 | 4.93% | 3 | 9.09% |
| Daniel Lezcano | 31 | 4.63% | 3 | 9.09% |
| Martin KaFai Lau | 20 | 2.99% | 1 | 3.03% |
| Hannes Frederic Sowa | 17 | 2.54% | 2 | 6.06% |
| Wei Wang | 12 | 1.79% | 4 | 12.12% |
| David Ahern | 11 | 1.64% | 1 | 3.03% |
| Wei Yongjun | 10 | 1.49% | 1 | 3.03% |
| Lin Ming | 6 | 0.90% | 1 | 3.03% |
| Daniel Borkmann | 4 | 0.60% | 1 | 3.03% |
| Benjamin Thery | 4 | 0.60% | 1 | 3.03% |
| Michal Kubeček | 4 | 0.60% | 1 | 3.03% |
| Mathew Richardson | 4 | 0.60% | 1 | 3.03% |
| Thomas Graf | 3 | 0.45% | 1 | 3.03% |
| Florian Westphal | 3 | 0.45% | 1 | 3.03% |
| Ilpo Järvinen | 2 | 0.30% | 1 | 3.03% |
| Joe Perches | 1 | 0.15% | 1 | 3.03% |
| Total | 670 | 100.00% | 33 | 100.00% |
/*
* Routing tree lookup
*
*/
struct lookup_args {
int offset; /* key offset on rt6_info */
const struct in6_addr *addr; /* search key */
};
static struct fib6_node *fib6_lookup_1(struct fib6_node *root,
struct lookup_args *args)
{
struct fib6_node *fn;
__be32 dir;
if (unlikely(args->offset == 0))
return NULL;
/*
* Descend on a tree
*/
fn = root;
for (;;) {
struct fib6_node *next;
dir = addr_bit_set(args->addr, fn->fn_bit);
next = dir ? fn->right : fn->left;
if (next) {
fn = next;
continue;
}
break;
}
while (fn) {
if (FIB6_SUBTREE(fn) || fn->fn_flags & RTN_RTINFO) {
struct rt6key *key;
key = (struct rt6key *) ((u8 *) fn->leaf +
args->offset);
if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) {
#ifdef CONFIG_IPV6_SUBTREES
if (fn->subtree) {
struct fib6_node *sfn;
sfn = fib6_lookup_1(fn->subtree,
args + 1);
if (!sfn)
goto backtrack;
fn = sfn;
}
#endif
if (fn->fn_flags & RTN_RTINFO)
return fn;
}
}
#ifdef CONFIG_IPV6_SUBTREES
backtrack:
#endif
if (fn->fn_flags & RTN_ROOT)
break;
fn = fn->parent;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 153 | 63.75% | 1 | 14.29% |
| Hideaki Yoshifuji / 吉藤英明 | 59 | 24.58% | 4 | 57.14% |
| Hannes Frederic Sowa | 27 | 11.25% | 1 | 14.29% |
| Al Viro | 1 | 0.42% | 1 | 14.29% |
| Total | 240 | 100.00% | 7 | 100.00% |
struct fib6_node *fib6_lookup(struct fib6_node *root, const struct in6_addr *daddr,
const struct in6_addr *saddr)
{
struct fib6_node *fn;
struct lookup_args args[] = {
{
.offset = offsetof(struct rt6_info, rt6i_dst),
.addr = daddr,
},
#ifdef CONFIG_IPV6_SUBTREES
{
.offset = offsetof(struct rt6_info, rt6i_src),
.addr = saddr,
},
#endif
{
.offset = 0, /* sentinel */
}
};
fn = fib6_lookup_1(root, daddr ? args : args + 1);
if (!fn || fn->fn_flags & RTN_TL_ROOT)
fn = root;
return fn;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 69 | 57.98% | 2 | 25.00% |
| Hideaki Yoshifuji / 吉藤英明 | 47 | 39.50% | 4 | 50.00% |
| Eric Dumazet | 2 | 1.68% | 1 | 12.50% |
| David S. Miller | 1 | 0.84% | 1 | 12.50% |
| Total | 119 | 100.00% | 8 | 100.00% |
/*
* Get node with specified destination prefix (and source prefix,
* if subtrees are used)
*/
static struct fib6_node *fib6_locate_1(struct fib6_node *root,
const struct in6_addr *addr,
int plen, int offset)
{
struct fib6_node *fn;
for (fn = root; fn ; ) {
struct rt6key *key = (struct rt6key *)((u8 *)fn->leaf + offset);
/*
* Prefix match
*/
if (plen < fn->fn_bit ||
!ipv6_prefix_equal(&key->addr, addr, fn->fn_bit))
return NULL;
if (plen == fn->fn_bit)
return fn;
/*
* We have more bits to go
*/
if (addr_bit_set(addr, fn->fn_bit))
fn = fn->right;
else
fn = fn->left;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 127 | 98.45% | 2 | 50.00% |
| Hideaki Yoshifuji / 吉藤英明 | 1 | 0.78% | 1 | 25.00% |
| Eric Dumazet | 1 | 0.78% | 1 | 25.00% |
| Total | 129 | 100.00% | 4 | 100.00% |
struct fib6_node *fib6_locate(struct fib6_node *root,
const struct in6_addr *daddr, int dst_len,
const struct in6_addr *saddr, int src_len)
{
struct fib6_node *fn;
fn = fib6_locate_1(root, daddr, dst_len,
offsetof(struct rt6_info, rt6i_dst));
#ifdef CONFIG_IPV6_SUBTREES
if (src_len) {
WARN_ON(saddr == NULL);
if (fn && fn->subtree)
fn = fib6_locate_1(fn->subtree, saddr, src_len,
offsetof(struct rt6_info, rt6i_src));
}
#endif
if (fn && fn->fn_flags & RTN_RTINFO)
return fn;
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 98 | 83.76% | 3 | 42.86% |
| Hideaki Yoshifuji / 吉藤英明 | 15 | 12.82% | 2 | 28.57% |
| Eric Dumazet | 2 | 1.71% | 1 | 14.29% |
| Ilpo Järvinen | 2 | 1.71% | 1 | 14.29% |
| Total | 117 | 100.00% | 7 | 100.00% |
/*
* Deletion
*
*/
static struct rt6_info *fib6_find_prefix(struct net *net, struct fib6_node *fn)
{
if (fn->fn_flags & RTN_ROOT)
return net->ipv6.ip6_null_entry;
while (fn) {
if (fn->left)
return fn->left->leaf;
if (fn->right)
return fn->right->leaf;
fn = FIB6_SUBTREE(fn);
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 65 | 86.67% | 2 | 50.00% |
| Daniel Lezcano | 9 | 12.00% | 1 | 25.00% |
| Hideaki Yoshifuji / 吉藤英明 | 1 | 1.33% | 1 | 25.00% |
| Total | 75 | 100.00% | 4 | 100.00% |
/*
* Called to trim the tree of intermediate nodes when possible. "fn"
* is the node we want to try and remove.
*/
static struct fib6_node *fib6_repair_tree(struct net *net,
struct fib6_node *fn)
{
int children;
int nstate;
struct fib6_node *child, *pn;
struct fib6_walker *w;
int iter = 0;
for (;;) {
RT6_TRACE("fixing tree: plen=%d iter=%d\n", fn->fn_bit, iter);
iter++;
WARN_ON(fn->fn_flags & RTN_RTINFO);
WARN_ON(fn->fn_flags & RTN_TL_ROOT);
WARN_ON(fn->leaf);
children = 0;
child = NULL;
if (fn->right)
child = fn->right, children |= 1;
if (fn->left)
child = fn->left, children |= 2;
if (children == 3 || FIB6_SUBTREE(fn)
#ifdef CONFIG_IPV6_SUBTREES
/* Subtree root (i.e. fn) may have one child */
|| (children && fn->fn_flags & RTN_ROOT)
#endif
) {
fn->leaf = fib6_find_prefix(net, fn);
#if RT6_DEBUG >= 2
if (!fn->leaf) {
WARN_ON(!fn->leaf);
fn->leaf = net->ipv6.ip6_null_entry;
}
#endif
atomic_inc(&fn->leaf->rt6i_ref);
return fn->parent;
}
pn = fn->parent;
#ifdef CONFIG_IPV6_SUBTREES
if (FIB6_SUBTREE(pn) == fn) {
WARN_ON(!(fn->fn_flags & RTN_ROOT));
FIB6_SUBTREE(pn) = NULL;
nstate = FWS_L;
} else {
WARN_ON(fn->fn_flags & RTN_ROOT);
#endif
if (pn->right == fn)
pn->right = child;
else if (pn->left == fn)
pn->left = child;
#if RT6_DEBUG >= 2
else
WARN_ON(1);
#endif
if (child)
child->parent = pn;
nstate = FWS_R;
#ifdef CONFIG_IPV6_SUBTREES
}
#endif
read_lock(&net->ipv6.fib6_walker_lock);
FOR_WALKERS(net, w) {
if (!child) {
if (w->root == fn) {
w->root = w->node = NULL;
RT6_TRACE("W %p adjusted by delroot 1\n", w);
} else if (w->node == fn) {
RT6_TRACE("W %p adjusted by delnode 1, s=%d/%d\n", w, w->state, nstate);
w->node = pn;
w->state = nstate;
}
} else {
if (w->root == fn) {
w->root = child;
RT6_TRACE("W %p adjusted by delroot 2\n", w);
}
if (w->node == fn) {
w->node = child;
if (children&2) {
RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state);
w->state = w->state >= FWS_R ? FWS_U : FWS_INIT;
} else {
RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state);
w->state = w->state >= FWS_C ? FWS_U : FWS_INIT;
}
}
}
}
read_unlock(&net->ipv6.fib6_walker_lock);
node_free(fn);
if (pn->fn_flags & RTN_RTINFO || FIB6_SUBTREE(pn))
return pn;
rt6_release(pn->leaf);
pn->leaf = NULL;
fn = pn;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 523 | 91.11% | 4 | 36.36% |
| Ilpo Järvinen | 12 | 2.09% | 1 | 9.09% |
| Linus Torvalds | 11 | 1.92% | 1 | 9.09% |
| Daniel Lezcano | 11 | 1.92% | 1 | 9.09% |
| Michal Kubeček | 10 | 1.74% | 1 | 9.09% |
| Hideaki Yoshifuji / 吉藤英明 | 4 | 0.70% | 1 | 9.09% |
| David S. Miller | 2 | 0.35% | 1 | 9.09% |
| Hannes Frederic Sowa | 1 | 0.17% | 1 | 9.09% |
| Total | 574 | 100.00% | 11 | 100.00% |
static void fib6_del_route(struct fib6_node *fn, struct rt6_info **rtp,
struct nl_info *info)
{
struct fib6_walker *w;
struct rt6_info *rt = *rtp;
struct net *net = info->nl_net;
RT6_TRACE("fib6_del_route\n");
/* Unlink it */
*rtp = rt->dst.rt6_next;
rt->rt6i_node = NULL;
net->ipv6.rt6_stats->fib_rt_entries--;
net->ipv6.rt6_stats->fib_discarded_routes++;
/* Reset round-robin state, if necessary */
if (fn->rr_ptr == rt)
fn->rr_ptr = NULL;
/* Remove this entry from other siblings */
if (rt->rt6i_nsiblings) {
struct rt6_info *sibling, *next_sibling;
list_for_each_entry_safe(sibling, next_sibling,
&rt->rt6i_siblings, rt6i_siblings)
sibling->rt6i_nsiblings--;
rt->rt6i_nsiblings = 0;
list_del_init(&rt->rt6i_siblings);
}
/* Adjust walkers */
read_lock(&net->ipv6.fib6_walker_lock);
FOR_WALKERS(net, w) {
if (w->state == FWS_C && w->leaf == rt) {
RT6_TRACE("walker %p adjusted by delroute\n", w);
w->leaf = rt->dst.rt6_next;
if (!w->leaf)
w->state = FWS_U;
}
}
read_unlock(&net->ipv6.fib6_walker_lock);
rt->dst.rt6_next = NULL;
/* If it was last route, expunge its radix tree node */
if (!fn->leaf) {
fn->fn_flags &= ~RTN_RTINFO;
net->ipv6.rt6_stats->fib_route_nodes--;
fn = fib6_repair_tree(net, fn);
}
fib6_purge_rt(rt, fn, net);
call_fib6_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, rt);
if (!info->skip_notify)
inet6_rt_notify(RTM_DELROUTE, rt, info, 0);
rt6_release(rt);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 154 | 50.83% | 5 | 21.74% |
| Nicolas Dichtel | 46 | 15.18% | 1 | 4.35% |
| Benjamin Thery | 21 | 6.93% | 1 | 4.35% |
| David S. Miller | 17 | 5.61% | 2 | 8.70% |
| Michal Kubeček | 10 | 3.30% | 1 | 4.35% |
| Eric Dumazet | 9 | 2.97% | 1 | 4.35% |
| Ido Schimmel | 9 | 2.97% | 1 | 4.35% |
| David Ahern | 7 | 2.31% | 1 | 4.35% |
| Linus Torvalds | 7 | 2.31% | 1 | 4.35% |
| Daniel Lezcano | 6 | 1.98% | 2 | 8.70% |
| Randy Dunlap | 4 | 1.32% | 1 | 4.35% |
| Hannes Frederic Sowa | 4 | 1.32% | 2 | 8.70% |
| Mathew Richardson | 3 | 0.99% | 1 | 4.35% |
| Thomas Graf | 3 | 0.99% | 1 | 4.35% |
| Roopa Prabhu | 2 | 0.66% | 1 | 4.35% |
| Jamal Hadi Salim | 1 | 0.33% | 1 | 4.35% |
| Total | 303 | 100.00% | 23 | 100.00% |
int fib6_del(struct rt6_info *rt, struct nl_info *info)
{
struct fib6_node *fn = rcu_dereference_protected(rt->rt6i_node,
lockdep_is_held(&rt->rt6i_table->tb6_lock));
struct net *net = info->nl_net;
struct rt6_info **rtp;
#if RT6_DEBUG >= 2
if (rt->dst.obsolete > 0) {
WARN_ON(fn);
return -ENOENT;
}
#endif
if (!fn || rt == net->ipv6.ip6_null_entry)
return -ENOENT;
WARN_ON(!(fn->fn_flags & RTN_RTINFO));
if (!(rt->rt6i_flags & RTF_CACHE)) {
struct fib6_node *pn = fn;
#ifdef CONFIG_IPV6_SUBTREES
/* clones of this route might be in another subtree */
if (rt->rt6i_src.plen) {
while (!(pn->fn_flags & RTN_ROOT))
pn = pn->parent;
pn = pn->parent;
}
#endif
fib6_prune_clones(info->nl_net, pn);
}
/*
* Walk the leaf entries looking for ourself
*/
for (rtp = &fn->leaf; *rtp; rtp = &(*rtp)->dst.rt6_next) {
if (*rtp == rt) {
fib6_del_route(fn, rtp, info);
return 0;
}
}
return -ENOENT;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 130 | 56.77% | 4 | 28.57% |
| Hideaki Yoshifuji / 吉藤英明 | 49 | 21.40% | 1 | 7.14% |
| Wei Wang | 21 | 9.17% | 1 | 7.14% |
| Daniel Lezcano | 9 | 3.93% | 1 | 7.14% |
| Ilpo Järvinen | 5 | 2.18% | 1 | 7.14% |
| Benjamin Thery | 4 | 1.75% | 1 | 7.14% |
| Mathew Richardson | 3 | 1.31% | 1 | 7.14% |
| Thomas Graf | 3 | 1.31% | 1 | 7.14% |
| Eric Dumazet | 3 | 1.31% | 1 | 7.14% |
| David S. Miller | 2 | 0.87% | 2 | 14.29% |
| Total | 229 | 100.00% | 14 | 100.00% |
/*
* Tree traversal function.
*
* Certainly, it is not interrupt safe.
* However, it is internally reenterable wrt itself and fib6_add/fib6_del.
* It means, that we can modify tree during walking
* and use this function for garbage collection, clone pruning,
* cleaning tree when a device goes down etc. etc.
*
* It guarantees that every node will be traversed,
* and that it will be traversed only once.
*
* Callback function w->func may return:
* 0 -> continue walking.
* positive value -> walking is suspended (used by tree dumps,
* and probably by gc, if it will be split to several slices)
* negative value -> terminate walking.
*
* The function itself returns:
* 0 -> walk is complete.
* >0 -> walk is incomplete (i.e. suspended)
* <0 -> walk is terminated by an error.
*/
static int fib6_walk_continue(struct fib6_walker *w)
{
struct fib6_node *fn, *pn;
for (;;) {
fn = w->node;
if (!fn)
return 0;
if (w->prune && fn != w->root &&
fn->fn_flags & RTN_RTINFO && w->state < FWS_C) {
w->state = FWS_C;
w->leaf = fn->leaf;
}
switch (w->state) {
#ifdef CONFIG_IPV6_SUBTREES
case FWS_S:
if (FIB6_SUBTREE(fn)) {
w->node = FIB6_SUBTREE(fn);
continue;
}
w->state = FWS_L;
#endif
case FWS_L:
if (fn->left) {
w->node = fn->left;
w->state = FWS_INIT;
continue;
}
w->state = FWS_R;
case FWS_R:
if (fn->right) {
w->node = fn->right;
w->state = FWS_INIT;
continue;
}
w->state = FWS_C;
w->leaf = fn->leaf;
case FWS_C:
if (w->leaf && fn->fn_flags & RTN_RTINFO) {
int err;
if (w->skip) {
w->skip--;
goto skip;
}
err = w->func(w);
if (err)
return err;
w->count++;
continue;
}
skip:
w->state = FWS_U;
case FWS_U:
if (fn == w->root)
return 0;
pn = fn->parent;
w->node = pn;
#ifdef CONFIG_IPV6_SUBTREES
if (FIB6_SUBTREE(pn) == fn) {
WARN_ON(!(fn->fn_flags & RTN_ROOT));
w->state = FWS_L;
continue;
}
#endif
if (pn->left == fn) {
w->state = FWS_R;
continue;
}
if (pn->right == fn) {
w->state = FWS_C;
w->leaf = w->node->leaf;
continue;
}
#if RT6_DEBUG >= 2
WARN_ON(1);
#endif
}
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 337 | 89.63% | 2 | 20.00% |
| Patrick McHardy | 20 | 5.32% | 1 | 10.00% |
| Ilpo Järvinen | 6 | 1.60% | 1 | 10.00% |
| Kumar Sundararajan | 5 | 1.33% | 1 | 10.00% |
| Hideaki Yoshifuji / 吉藤英明 | 3 | 0.80% | 1 | 10.00% |
| Eric Dumazet | 2 | 0.53% | 1 | 10.00% |
| Adrian Bunk | 1 | 0.27% | 1 | 10.00% |
| Hannes Frederic Sowa | 1 | 0.27% | 1 | 10.00% |
| David S. Miller | 1 | 0.27% | 1 | 10.00% |
| Total | 376 | 100.00% | 10 | 100.00% |
static int fib6_walk(struct net *net, struct fib6_walker *w)
{
int res;
w->state = FWS_INIT;
w->node = w->root;
fib6_walker_link(net, w);
res = fib6_walk_continue(w);
if (res <= 0)
fib6_walker_unlink(net, w);
return res;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 52 | 82.54% | 1 | 25.00% |
| Michal Kubeček | 9 | 14.29% | 1 | 25.00% |
| Adrian Bunk | 1 | 1.59% | 1 | 25.00% |
| Hannes Frederic Sowa | 1 | 1.59% | 1 | 25.00% |
| Total | 63 | 100.00% | 4 | 100.00% |
static int fib6_clean_node(struct fib6_walker *w)
{
int res;
struct rt6_info *rt;
struct fib6_cleaner *c = container_of(w, struct fib6_cleaner, w);
struct nl_info info = {
.nl_net = c->net,
};
if (c->sernum != FIB6_NO_SERNUM_CHANGE &&
w->node->fn_sernum != c->sernum)
w->node->fn_sernum = c->sernum;
if (!c->func) {
WARN_ON_ONCE(c->sernum == FIB6_NO_SERNUM_CHANGE);
w->leaf = NULL;
return 0;
}
for (rt = w->leaf; rt; rt = rt->dst.rt6_next) {
res = c->func(rt, c->arg);
if (res < 0) {
w->leaf = rt;
res = fib6_del(rt, &info);
if (res) {
#if RT6_DEBUG >= 2
pr_debug("%s: del failed: rt=%p@%p err=%d\n",
__func__, rt,
rcu_access_pointer(rt->rt6i_node),
res);
#endif
continue;
}
return 0;
}
WARN_ON(res != 0);
}
w->leaf = rt;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 118 | 56.19% | 1 | 9.09% |
| Hannes Frederic Sowa | 58 | 27.62% | 2 | 18.18% |
| Benjamin Thery | 19 | 9.05% | 2 | 18.18% |
| Joe Perches | 4 | 1.90% | 1 | 9.09% |
| Eric Dumazet | 3 | 1.43% | 1 | 9.09% |
| Wei Wang | 3 | 1.43% | 1 | 9.09% |
| Ilpo Järvinen | 2 | 0.95% | 1 | 9.09% |
| Denis V. Lunev | 2 | 0.95% | 1 | 9.09% |
| Mathew Richardson | 1 | 0.48% | 1 | 9.09% |
| Total | 210 | 100.00% | 11 | 100.00% |
/*
* Convenient frontend to tree walker.
*
* func is called on each route.
* It may return -1 -> delete this route.
* 0 -> continue walking
*
* prune==1 -> only immediate children of node (certainly,
* ignoring pure split nodes) will be scanned.
*/
static void fib6_clean_tree(struct net *net, struct fib6_node *root,
int (*func)(struct rt6_info *, void *arg),
bool prune, int sernum, void *arg)
{
struct fib6_cleaner c;
c.w.root = root;
c.w.func = fib6_clean_node;
c.w.prune = prune;
c.w.count = 0;
c.w.skip = 0;
c.func = func;
c.sernum = sernum;
c.arg = arg;
c.net = net;
fib6_walk(net, &c.w);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 78 | 65.55% | 1 | 14.29% |
| Patrick McHardy | 16 | 13.45% | 1 | 14.29% |
| Benjamin Thery | 11 | 9.24% | 1 | 14.29% |
| Hannes Frederic Sowa | 11 | 9.24% | 2 | 28.57% |
| Michal Kubeček | 2 | 1.68% | 1 | 14.29% |
| Adrian Bunk | 1 | 0.84% | 1 | 14.29% |
| Total | 119 | 100.00% | 7 | 100.00% |
static void __fib6_clean_all(struct net *net,
int (*func)(struct rt6_info *, void *),
int sernum, void *arg)
{
struct fib6_table *table;
struct hlist_head *head;
unsigned int h;
rcu_read_lock();
for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
head = &net->ipv6.fib_table_hash[h];
hlist_for_each_entry_rcu(table, head, tb6_hlist) {
write_lock_bh(&table->tb6_lock);
fib6_clean_tree(net, &table->tb6_root,
func, false, sernum, arg);
write_unlock_bh(&table->tb6_lock);
}
}
rcu_read_unlock();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Thomas Graf | 69 | 56.10% | 1 | 12.50% |
| Daniel Lezcano | 22 | 17.89% | 2 | 25.00% |
| Patrick McHardy | 21 | 17.07% | 1 | 12.50% |
| Hannes Frederic Sowa | 8 | 6.50% | 2 | 25.00% |
| Benjamin Thery | 2 | 1.63% | 1 | 12.50% |
| Neil Horman | 1 | 0.81% | 1 | 12.50% |
| Total | 123 | 100.00% | 8 | 100.00% |
void fib6_clean_all(struct net *net, int (*func)(struct rt6_info *, void *),
void *arg)
{
__fib6_clean_all(net, func, FIB6_NO_SERNUM_CHANGE, arg);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 39 | 100.00% | 1 | 100.00% |
| Total | 39 | 100.00% | 1 | 100.00% |
static int fib6_prune_clone(struct rt6_info *rt, void *arg)
{
if (rt->rt6i_flags & RTF_CACHE) {
RT6_TRACE("pruning clone %p\n", rt);
return -1;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 39 | 100.00% | 1 | 100.00% |
| Total | 39 | 100.00% | 1 | 100.00% |
static void fib6_prune_clones(struct net *net, struct fib6_node *fn)
{
fib6_clean_tree(net, fn, fib6_prune_clone, true,
FIB6_NO_SERNUM_CHANGE, NULL);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 20 | 64.52% | 2 | 33.33% |
| Benjamin Thery | 7 | 22.58% | 1 | 16.67% |
| Hannes Frederic Sowa | 3 | 9.68% | 2 | 33.33% |
| Duan Jiong | 1 | 3.23% | 1 | 16.67% |
| Total | 31 | 100.00% | 6 | 100.00% |
static void fib6_flush_trees(struct net *net)
{
int new_sernum = fib6_new_sernum(net);
__fib6_clean_all(net, NULL, new_sernum, NULL);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 30 | 100.00% | 4 | 100.00% |
| Total | 30 | 100.00% | 4 | 100.00% |
/*
* Garbage collection
*/
struct fib6_gc_args
{
int timeout;
int more;
};
static int fib6_age(struct rt6_info *rt, void *arg)
{
struct fib6_gc_args *gc_args = arg;
unsigned long now = jiffies;
/*
* check addrconf expiration here.
* Routes are expired even if they are in use.
*
* Also age clones. Note, that clones are aged out
* only if they are not in use now.
*/
if (rt->rt6i_flags & RTF_EXPIRES && rt->dst.expires) {
if (time_after(now, rt->dst.expires)) {
RT6_TRACE("expiring %p\n", rt);
return -1;
}
gc_args->more++;
} else if (rt->rt6i_flags & RTF_CACHE) {
if (time_after_eq(now, rt->dst.lastuse + gc_args->timeout))
rt->dst.obsolete = DST_OBSOLETE_KILL;
if (atomic_read(&rt->dst.__refcnt) == 1 &&
rt->dst.obsolete == DST_OBSOLETE_KILL) {
RT6_TRACE("aging clone %p\n", rt);
return -1;
} else if (rt->rt6i_flags & RTF_GATEWAY) {
struct neighbour *neigh;
__u8 neigh_flags = 0;
neigh = dst_neigh_lookup(&rt->dst, &rt->rt6i_gateway);
if (neigh) {
neigh_flags = neigh->flags;
neigh_release(neigh);
}
if (!(neigh_flags & NTF_ROUTER)) {
RT6_TRACE("purging route %p via non-router but gateway\n",
rt);
return -1;
}
}
gc_args->more++;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 87 | 37.83% | 2 | 15.38% |
| David S. Miller | 50 | 21.74% | 4 | 30.77% |
| Xin Long | 28 | 12.17% | 1 | 7.69% |
| Hideaki Yoshifuji / 吉藤英明 | 28 | 12.17% | 1 | 7.69% |
| Shirley Ma | 22 | 9.57% | 1 | 7.69% |
| Michal Kubeček | 9 | 3.91% | 1 | 7.69% |
| Thomas Graf | 3 | 1.30% | 1 | 7.69% |
| Randy Dunlap | 2 | 0.87% | 1 | 7.69% |
| Wei Wang | 1 | 0.43% | 1 | 7.69% |
| Total | 230 | 100.00% | 13 | 100.00% |
void fib6_run_gc(unsigned long expires, struct net *net, bool force)
{
struct fib6_gc_args gc_args;
unsigned long now;
if (force) {
spin_lock_bh(&net->ipv6.fib6_gc_lock);
} else if (!spin_trylock_bh(&net->ipv6.fib6_gc_lock)) {
mod_timer(&net->ipv6.ip6_fib_timer, jiffies + HZ);
return;
}
gc_args.timeout = expires ? (int)expires :
net->ipv6.sysctl.ip6_rt_gc_interval;
gc_args.more = 0;
fib6_clean_all(net, fib6_age, &gc_args);
now = jiffies;
net->ipv6.ip6_rt_last_gc = now;
if (gc_args.more)
mod_timer(&net->ipv6.ip6_fib_timer,
round_jiffies(now
+ net->ipv6.sysctl.ip6_rt_gc_interval));
else
del_timer(&net->ipv6.ip6_fib_timer);
spin_unlock_bh(&net->ipv6.fib6_gc_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 80 | 47.34% | 4 | 22.22% |
| Michal Kubeček | 47 | 27.81% | 4 | 22.22% |
| Daniel Lezcano | 32 | 18.93% | 4 | 22.22% |
| Stephen Hemminger | 7 | 4.14% | 3 | 16.67% |
| David S. Miller | 1 | 0.59% | 1 | 5.56% |
| Thomas Graf | 1 | 0.59% | 1 | 5.56% |
| Wei Wang | 1 | 0.59% | 1 | 5.56% |
| Total | 169 | 100.00% | 18 | 100.00% |
static void fib6_gc_timer_cb(unsigned long arg)
{
fib6_run_gc(0, (struct net *)arg, true);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Daniel Lezcano | 22 | 91.67% | 1 | 50.00% |
| Michal Kubeček | 2 | 8.33% | 1 | 50.00% |
| Total | 24 | 100.00% | 2 | 100.00% |
static int __net_init fib6_net_init(struct net *net)
{
size_t size = sizeof(struct hlist_head) * FIB6_TABLE_HASHSZ;
int err;
err = fib6_notifier_init(net);
if (err)
return err;
spin_lock_init(&net->ipv6.fib6_gc_lock);
rwlock_init(&net->ipv6.fib6_walker_lock);
INIT_LIST_HEAD(&net->ipv6.fib6_walkers);
setup_timer(&net->ipv6.ip6_fib_timer, fib6_gc_timer_cb, (unsigned long)net);
net->ipv6.rt6_stats = kzalloc(sizeof(*net->ipv6.rt6_stats), GFP_KERNEL);
if (!net->ipv6.rt6_stats)
goto out_timer;
/* Avoid false sharing : Use at least a full cache line */
size = max_t(size_t, size, L1_CACHE_BYTES);
net->ipv6.fib_table_hash = kzalloc(size, GFP_KERNEL);
if (!net->ipv6.fib_table_hash)
goto out_rt6_stats;
net->ipv6.fib6_main_tbl = kzalloc(sizeof(*net->ipv6.fib6_main_tbl),
GFP_KERNEL);
if (!net->ipv6.fib6_main_tbl)
goto out_fib_table_hash;
net->ipv6.fib6_main_tbl->tb6_id = RT6_TABLE_MAIN;
net->ipv6.fib6_main_tbl->tb6_root.leaf = net->ipv6.ip6_null_entry;
net->ipv6.fib6_main_tbl->tb6_root.fn_flags =
RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
inet_peer_base_init(&net->ipv6.fib6_main_tbl->tb6_peers);
#ifdef CONFIG_IPV6_MULTIPLE_TABLES
net->ipv6.fib6_local_tbl = kzalloc(sizeof(*net->ipv6.fib6_local_tbl),
GFP_KERNEL);
if (!net->ipv6.fib6_local_tbl)
goto out_fib6_main_tbl;
net->ipv6.fib6_local_tbl->tb6_id = RT6_TABLE_LOCAL;
net->ipv6.fib6_local_tbl->tb6_root.leaf = net->ipv6.ip6_null_entry;
net->ipv6.fib6_local_tbl->tb6_root.fn_flags =
RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
inet_peer_base_init(&net->ipv6.fib6_local_tbl->tb6_peers);
#endif
fib6_tables_init(net);
return 0;
#ifdef CONFIG_IPV6_MULTIPLE_TABLES
out_fib6_main_tbl:
kfree(net->ipv6.fib6_main_tbl);
#endif
out_fib_table_hash:
kfree(net->ipv6.fib_table_hash);
out_rt6_stats:
kfree(net->ipv6.rt6_stats);
out_timer:
fib6_notifier_exit(net);
return -ENOMEM;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Daniel Lezcano | 233 | 59.14% | 5 | 27.78% |
| Benjamin Thery | 41 | 10.41% | 1 | 5.56% |
| Michal Kubeček | 30 | 7.61% | 2 | 11.11% |
| Eric Dumazet | 24 | 6.09% | 1 | 5.56% |
| David S. Miller | 24 | 6.09% | 1 | 5.56% |
| Ido Schimmel | 22 | 5.58% | 1 | 5.56% |
| Stephen Hemminger | 12 | 3.05% | 2 | 11.11% |
| Thomas Graf | 4 | 1.02% | 2 | 11.11% |
| Linus Torvalds (pre-git) | 3 | 0.76% | 2 | 11.11% |
| Alexey Dobriyan | 1 | 0.25% | 1 | 5.56% |
| Total | 394 | 100.00% | 18 | 100.00% |
static void fib6_net_exit(struct net *net)
{
unsigned int i;
rt6_ifdown(net, NULL);
del_timer_sync(&net->ipv6.ip6_fib_timer);
for (i = 0; i < FIB6_TABLE_HASHSZ; i++) {
struct hlist_head *head = &net->ipv6.fib_table_hash[i];
struct hlist_node *tmp;
struct fib6_table *tb;
hlist_for_each_entry_safe(tb, tmp, head, tb6_hlist) {
hlist_del(&tb->tb6_hlist);
fib6_free_table(tb);
}
}
kfree(net->ipv6.fib_table_hash);
kfree(net->ipv6.rt6_stats);
fib6_notifier_exit(net);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Sabrina Dubroca | 53 | 44.17% | 1 | 9.09% |
| Daniel Lezcano | 40 | 33.33% | 4 | 36.36% |
| David S. Miller | 10 | 8.33% | 1 | 9.09% |
| Benjamin Thery | 9 | 7.50% | 1 | 9.09% |
| Ido Schimmel | 5 | 4.17% | 1 | 9.09% |
| Stephen Hemminger | 1 | 0.83% | 1 | 9.09% |
| Eric Dumazet | 1 | 0.83% | 1 | 9.09% |
| Pavel Emelyanov | 1 | 0.83% | 1 | 9.09% |
| Total | 120 | 100.00% | 11 | 100.00% |
static struct pernet_operations fib6_net_ops = {
.init = fib6_net_init,
.exit = fib6_net_exit,
};
int __init fib6_init(void)
{
int ret = -ENOMEM;
fib6_node_kmem = kmem_cache_create("fib6_nodes",
sizeof(struct fib6_node),
0, SLAB_HWCACHE_ALIGN,
NULL);
if (!fib6_node_kmem)
goto out;
ret = register_pernet_subsys(&fib6_net_ops);
if (ret)
goto out_kmem_cache_create;
ret = __rtnl_register(PF_INET6, RTM_GETROUTE, NULL, inet6_dump_fib,
0);
if (ret)
goto out_unregister_subsys;
__fib6_flush_trees = fib6_flush_trees;
out:
return ret;
out_unregister_subsys:
unregister_pernet_subsys(&fib6_net_ops);
out_kmem_cache_create:
kmem_cache_destroy(fib6_node_kmem);
goto out;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Daniel Lezcano | 69 | 65.71% | 2 | 25.00% |
| David S. Miller | 28 | 26.67% | 1 | 12.50% |
| Hannes Frederic Sowa | 4 | 3.81% | 1 | 12.50% |
| Greg Rose | 1 | 0.95% | 1 | 12.50% |
| Benjamin Thery | 1 | 0.95% | 1 | 12.50% |
| Linus Torvalds (pre-git) | 1 | 0.95% | 1 | 12.50% |
| Florian Westphal | 1 | 0.95% | 1 | 12.50% |
| Total | 105 | 100.00% | 8 | 100.00% |
void fib6_gc_cleanup(void)
{
unregister_pernet_subsys(&fib6_net_ops);
kmem_cache_destroy(fib6_node_kmem);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 7 | 38.89% | 1 | 25.00% |
| Daniel Lezcano | 6 | 33.33% | 2 | 50.00% |
| Daniel McNeil | 5 | 27.78% | 1 | 25.00% |
| Total | 18 | 100.00% | 4 | 100.00% |
#ifdef CONFIG_PROC_FS
struct ipv6_route_iter {
struct seq_net_private p;
struct fib6_walker w;
loff_t skip;
struct fib6_table *tbl;
int sernum;
};
static int ipv6_route_seq_show(struct seq_file *seq, void *v)
{
struct rt6_info *rt = v;
struct ipv6_route_iter *iter = seq->private;
seq_printf(seq, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
#ifdef CONFIG_IPV6_SUBTREES
seq_printf(seq, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
#else
seq_puts(seq, "00000000000000000000000000000000 00 ");
#endif
if (rt->rt6i_flags & RTF_GATEWAY)
seq_printf(seq, "%pi6", &rt->rt6i_gateway);
else
seq_puts(seq, "00000000000000000000000000000000");
seq_printf(seq, " %08x %08x %08x %08x %8s\n",
rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
rt->dst.__use, rt->rt6i_flags,
rt->dst.dev ? rt->dst.dev->name : "");
iter->w.leaf = NULL;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 171 | 100.00% | 1 | 100.00% |
| Total | 171 | 100.00% | 1 | 100.00% |
static int ipv6_route_yield(struct fib6_walker *w)
{
struct ipv6_route_iter *iter = w->args;
if (!iter->skip)
return 1;
do {
iter->w.leaf = iter->w.leaf->dst.rt6_next;
iter->skip--;
if (!iter->skip && iter->w.leaf)
return 1;
} while (iter->w.leaf);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 82 | 100.00% | 2 | 100.00% |
| Total | 82 | 100.00% | 2 | 100.00% |
static void ipv6_route_seq_setup_walk(struct ipv6_route_iter *iter,
struct net *net)
{
memset(&iter->w, 0, sizeof(iter->w));
iter->w.func = ipv6_route_yield;
iter->w.root = &iter->tbl->tb6_root;
iter->w.state = FWS_INIT;
iter->w.node = iter->w.root;
iter->w.args = iter;
iter->sernum = iter->w.root->fn_sernum;
INIT_LIST_HEAD(&iter->w.lh);
fib6_walker_link(net, &iter->w);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 107 | 93.86% | 2 | 66.67% |
| Michal Kubeček | 7 | 6.14% | 1 | 33.33% |
| Total | 114 | 100.00% | 3 | 100.00% |
static struct fib6_table *ipv6_route_seq_next_table(struct fib6_table *tbl,
struct net *net)
{
unsigned int h;
struct hlist_node *node;
if (tbl) {
h = (tbl->tb6_id & (FIB6_TABLE_HASHSZ - 1)) + 1;
node = rcu_dereference_bh(hlist_next_rcu(&tbl->tb6_hlist));
} else {
h = 0;
node = NULL;
}
while (!node && h < FIB6_TABLE_HASHSZ) {
node = rcu_dereference_bh(
hlist_first_rcu(&net->ipv6.fib_table_hash[h++]));
}
return hlist_entry_safe(node, struct fib6_table, tb6_hlist);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 114 | 100.00% | 1 | 100.00% |
| Total | 114 | 100.00% | 1 | 100.00% |
static void ipv6_route_check_sernum(struct ipv6_route_iter *iter)
{
if (iter->sernum != iter->w.root->fn_sernum) {
iter->sernum = iter->w.root->fn_sernum;
iter->w.state = FWS_INIT;
iter->w.node = iter->w.root;
WARN_ON(iter->w.skip);
iter->w.skip = iter->w.count;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 80 | 100.00% | 1 | 100.00% |
| Total | 80 | 100.00% | 1 | 100.00% |
static void *ipv6_route_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
int r;
struct rt6_info *n;
struct net *net = seq_file_net(seq);
struct ipv6_route_iter *iter = seq->private;
if (!v)
goto iter_table;
n = ((struct rt6_info *)v)->dst.rt6_next;
if (n) {
++*pos;
return n;
}
iter_table:
ipv6_route_check_sernum(iter);
read_lock(&iter->tbl->tb6_lock);
r = fib6_walk_continue(&iter->w);
read_unlock(&iter->tbl->tb6_lock);
if (r > 0) {
if (v)
++*pos;
return iter->w.leaf;
} else if (r < 0) {
fib6_walker_unlink(net, &iter->w);
return NULL;
}
fib6_walker_unlink(net, &iter->w);
iter->tbl = ipv6_route_seq_next_table(iter->tbl, net);
if (!iter->tbl)
return NULL;
ipv6_route_seq_setup_walk(iter, net);
goto iter_table;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 202 | 97.12% | 2 | 66.67% |
| Michal Kubeček | 6 | 2.88% | 1 | 33.33% |
| Total | 208 | 100.00% | 3 | 100.00% |
static void *ipv6_route_seq_start(struct seq_file *seq, loff_t *pos)
__acquires(RCU_BH)
{
struct net *net = seq_file_net(seq);
struct ipv6_route_iter *iter = seq->private;
rcu_read_lock_bh();
iter->tbl = ipv6_route_seq_next_table(NULL, net);
iter->skip = *pos;
if (iter->tbl) {
ipv6_route_seq_setup_walk(iter, net);
return ipv6_route_seq_next(seq, NULL, pos);
} else {
return NULL;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 89 | 97.80% | 1 | 50.00% |
| Michal Kubeček | 2 | 2.20% | 1 | 50.00% |
| Total | 91 | 100.00% | 2 | 100.00% |
static bool ipv6_route_iter_active(struct ipv6_route_iter *iter)
{
struct fib6_walker *w = &iter->w;
return w->node && !(w->state == FWS_U && w->node == w->root);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 43 | 100.00% | 2 | 100.00% |
| Total | 43 | 100.00% | 2 | 100.00% |
static void ipv6_route_seq_stop(struct seq_file *seq, void *v)
__releases(RCU_BH)
{
struct net *net = seq_file_net(seq);
struct ipv6_route_iter *iter = seq->private;
if (ipv6_route_iter_active(iter))
fib6_walker_unlink(net, &iter->w);
rcu_read_unlock_bh();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 46 | 79.31% | 1 | 50.00% |
| Michal Kubeček | 12 | 20.69% | 1 | 50.00% |
| Total | 58 | 100.00% | 2 | 100.00% |
static const struct seq_operations ipv6_route_seq_ops = {
.start = ipv6_route_seq_start,
.next = ipv6_route_seq_next,
.stop = ipv6_route_seq_stop,
.show = ipv6_route_seq_show
};
int ipv6_route_open(struct inode *inode, struct file *file)
{
return seq_open_net(inode, file, &ipv6_route_seq_ops,
sizeof(struct ipv6_route_iter));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hannes Frederic Sowa | 32 | 100.00% | 1 | 100.00% |
| Total | 32 | 100.00% | 1 | 100.00% |
#endif /* CONFIG_PROC_FS */
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 3394 | 33.51% | 13 | 7.65% |
| Hannes Frederic Sowa | 1467 | 14.49% | 11 | 6.47% |
| Patrick McHardy | 892 | 8.81% | 2 | 1.18% |
| Daniel Lezcano | 686 | 6.77% | 10 | 5.88% |
| Ido Schimmel | 571 | 5.64% | 5 | 2.94% |
| Michal Kubeček | 462 | 4.56% | 7 | 4.12% |
| Hideaki Yoshifuji / 吉藤英明 | 386 | 3.81% | 17 | 10.00% |
| Matti Vaittinen | 344 | 3.40% | 2 | 1.18% |
| Thomas Graf | 277 | 2.74% | 6 | 3.53% |
| David S. Miller | 234 | 2.31% | 13 | 7.65% |
| Nicolas Dichtel | 182 | 1.80% | 1 | 0.59% |
| Wei Wang | 147 | 1.45% | 8 | 4.71% |
| Benjamin Thery | 141 | 1.39% | 3 | 1.76% |
| Martin KaFai Lau | 109 | 1.08% | 5 | 2.94% |
| David Ahern | 104 | 1.03% | 9 | 5.29% |
| Florian Westphal | 100 | 0.99% | 2 | 1.18% |
| Sabrina Dubroca | 88 | 0.87% | 2 | 1.18% |
| Eric Dumazet | 76 | 0.75% | 8 | 4.71% |
| Xin Long | 75 | 0.74% | 2 | 1.18% |
| Adrian Bunk | 72 | 0.71% | 2 | 1.18% |
| Stephen Hemminger | 32 | 0.32% | 5 | 2.94% |
| Ilpo Järvinen | 29 | 0.29% | 1 | 0.59% |
| Herbert Xu | 27 | 0.27% | 1 | 0.59% |
| Shirley Ma | 22 | 0.22% | 1 | 0.59% |
| Lin Ming | 21 | 0.21% | 1 | 0.59% |
| Linus Torvalds | 21 | 0.21% | 1 | 0.59% |
| Joe Perches | 19 | 0.19% | 2 | 1.18% |
| Alexey Dobriyan | 15 | 0.15% | 2 | 1.18% |
| Mathew Richardson | 15 | 0.15% | 1 | 0.59% |
| Guillaume Nault | 15 | 0.15% | 1 | 0.59% |
| Daniel Borkmann | 12 | 0.12% | 2 | 1.18% |
| Denis V. Lunev | 11 | 0.11% | 2 | 1.18% |
| Wei Yongjun | 10 | 0.10% | 1 | 0.59% |
| Gao Feng | 9 | 0.09% | 1 | 0.59% |
| Roopa Prabhu | 8 | 0.08% | 2 | 1.18% |
| Fan Du | 7 | 0.07% | 1 | 0.59% |
| Randy Dunlap | 6 | 0.06% | 2 | 1.18% |
| Brian Haley | 6 | 0.06% | 1 | 0.59% |
| Kumar Sundararajan | 5 | 0.05% | 1 | 0.59% |
| Daniel McNeil | 5 | 0.05% | 1 | 0.59% |
| Neil Horman | 4 | 0.04% | 1 | 0.59% |
| Al Viro | 4 | 0.04% | 1 | 0.59% |
| Christoph Lameter | 3 | 0.03% | 2 | 1.18% |
| Robert P. J. Day | 3 | 0.03% | 1 | 0.59% |
| Tejun Heo | 3 | 0.03% | 1 | 0.59% |
| Steven Cole | 2 | 0.02% | 1 | 0.59% |
| Wang Yufen | 2 | 0.02% | 1 | 0.59% |
| Greg Rose | 1 | 0.01% | 1 | 0.59% |
| Jamal Hadi Salim | 1 | 0.01% | 1 | 0.59% |
| Pavel Emelyanov | 1 | 0.01% | 1 | 0.59% |
| Duan Jiong | 1 | 0.01% | 1 | 0.59% |
| Total | 10127 | 100.00% | 170 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.