ipv6: fib: Dump tables during registration to FIB chain

Dump all the FIB tables in each net namespace upon registration to the
FIB notification chain so that the callee will have a complete view of
the tables.

The integrity of the dump is ensured by a per-table sequence counter
that is incremented (under write lock) whenever a route is added or
deleted from the table.

All the sequence counters are read (under each table's read lock) and
summed, prior and after the dump. In case the counters differ, then the
dump is either restarted or the registration fails.

While it's possible for a table to be modified after its counter has
been read, this isn't really a problem. In case it happened before it
was read the second time, then the comparison at the end will fail. If
it happened afterwards, then we're guaranteed to be notified about the
change, as the notification block is registered prior to the second
read.

Signed-off-by: Ido Schimmel <idosch@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/ip6_fib.h b/include/net/ip6_fib.h
index dbe5537809f540b6c6fddcbd6f445bc483e8d5dd..0b3052157e6bfb37f10dbf175d14e2d04a2ff5d7 100644 (file)
--- a/include/net/ip6_fib.h
+++ b/include/net/ip6_fib.h
@@ -235,6 +235,7 @@ struct fib6_table {
        struct fib6_node        tb6_root;
        struct inet_peer_base   tb6_peers;
        unsigned int            flags;
+       unsigned int            fib_seq;
 #define RT6_TABLE_HAS_DFLT_ROUTER      BIT(0)
 };
 
@@ -308,6 +309,9 @@ int call_fib6_notifiers(struct net *net, enum fib_event_type event_type,
 int __net_init fib6_notifier_init(struct net *net);
 void __net_exit fib6_notifier_exit(struct net *net);
 
+unsigned int fib6_tables_seq_read(struct net *net);
+int fib6_tables_dump(struct net *net, struct notifier_block *nb);
+
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 int fib6_rules_init(void);
 void fib6_rules_cleanup(void);

diff --git a/net/ipv6/fib6_notifier.c b/net/ipv6/fib6_notifier.c
index 298efc678f3bc0ff89ef8f8a596486274ea1e739..66a103ef7e864a917a899cea4981efc87d26a7e4 100644 (file)
--- a/net/ipv6/fib6_notifier.c
+++ b/net/ipv6/fib6_notifier.c
@@ -23,12 +23,18 @@ int call_fib6_notifiers(struct net *net, enum fib_event_type event_type,
 
 static unsigned int fib6_seq_read(struct net *net)
 {
-       return fib6_rules_seq_read(net);
+       return fib6_tables_seq_read(net) + fib6_rules_seq_read(net);
 }
 
 static int fib6_dump(struct net *net, struct notifier_block *nb)
 {
-       return fib6_rules_dump(net, nb);
+       int err;
+
+       err = fib6_rules_dump(net, nb);
+       if (err)
+               return err;
+
+       return fib6_tables_dump(net, nb);
 }
 
 static const struct fib_notifier_ops fib6_notifier_ops_template = {

diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index 595a57cbbc7ba855a6d2b2feb2ed9fdd236b45b9..719c10480c74f9e8d3af74a48f2f7ab3e01c92ce 100644 (file)
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -303,6 +303,37 @@ static void __net_init fib6_tables_init(struct net *net)
 
 #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;
+}
+
+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);
+}
+
 static int call_fib6_entry_notifiers(struct net *net,
                                     enum fib_event_type event_type,
                                     struct rt6_info *rt)
@@ -311,9 +342,70 @@ static int call_fib6_entry_notifiers(struct net *net,
                .rt = rt,
        };
 
+       rt->rt6i_table->fib_seq++;
        return call_fib6_notifiers(net, event_type, &info.info);
 }
 
+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);
+}
+
+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;
+}
+
+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);
+}
+
+/* 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;
+}
+
 static int fib6_dump_node(struct fib6_walker *w)
 {
        int res;