blob: e31118f417b401a3ff01996f73c4aba325289fe9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09002 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Forwarding Information Database
4 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
Wang Yufen8db46f12014-03-28 12:07:02 +080012 *
13 * Changes:
14 * Yuji SEKIYA @USAGI: Support default route on router node;
15 * remove ip6_null_entry from the top of
16 * routing table.
17 * Ville Nuorvala: Fixed routing subtrees.
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
Joe Perchesf3213832012-05-15 14:11:53 +000019
20#define pr_fmt(fmt) "IPv6: " fmt
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/errno.h>
23#include <linux/types.h>
24#include <linux/net.h>
25#include <linux/route.h>
26#include <linux/netdevice.h>
27#include <linux/in6.h>
28#include <linux/init.h>
Thomas Grafc71099a2006-08-04 23:20:06 -070029#include <linux/list.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <net/ipv6.h>
33#include <net/ndisc.h>
34#include <net/addrconf.h>
Roopa Prabhu19e42e42015-07-21 10:43:48 +020035#include <net/lwtunnel.h>
Ido Schimmeldf77fe42017-08-03 13:28:17 +020036#include <net/fib_notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#include <net/ip6_fib.h>
39#include <net/ip6_route.h>
40
Wang Yufen437de072014-03-28 12:07:04 +080041static struct kmem_cache *fib6_node_kmem __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +020043struct fib6_cleaner {
44 struct fib6_walker w;
Benjamin Theryec7d43c2008-03-03 23:31:57 -080045 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 int (*func)(struct rt6_info *, void *arg);
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +020047 int sernum;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 void *arg;
49};
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#ifdef CONFIG_IPV6_SUBTREES
52#define FWS_INIT FWS_S
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#else
54#define FWS_INIT FWS_L
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#endif
56
Wei Wang66f5d6c2017-10-06 12:06:10 -070057static struct rt6_info *fib6_find_prefix(struct net *net,
58 struct fib6_table *table,
59 struct fib6_node *fn);
60static struct fib6_node *fib6_repair_tree(struct net *net,
61 struct fib6_table *table,
62 struct fib6_node *fn);
Michal Kubeček9a03cd82016-03-08 14:44:35 +010063static int fib6_walk(struct net *net, struct fib6_walker *w);
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +020064static int fib6_walk_continue(struct fib6_walker *w);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66/*
67 * A routing update causes an increase of the serial number on the
68 * affected subtree. This allows for cached routes to be asynchronously
69 * tested when modifications are made to the destination cache as a
70 * result of redirects, path MTU changes, etc.
71 */
72
Kees Cook86cb30e2017-10-17 20:21:24 -070073static void fib6_gc_timer_cb(struct timer_list *t);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -080074
Michal Kubeček9a03cd82016-03-08 14:44:35 +010075#define FOR_WALKERS(net, w) \
76 list_for_each_entry(w, &(net)->ipv6.fib6_walkers, lh)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Michal Kubeček9a03cd82016-03-08 14:44:35 +010078static void fib6_walker_link(struct net *net, struct fib6_walker *w)
Adrian Bunk90d41122006-08-14 23:49:16 -070079{
Michal Kubeček9a03cd82016-03-08 14:44:35 +010080 write_lock_bh(&net->ipv6.fib6_walker_lock);
81 list_add(&w->lh, &net->ipv6.fib6_walkers);
82 write_unlock_bh(&net->ipv6.fib6_walker_lock);
Adrian Bunk90d41122006-08-14 23:49:16 -070083}
84
Michal Kubeček9a03cd82016-03-08 14:44:35 +010085static void fib6_walker_unlink(struct net *net, struct fib6_walker *w)
Adrian Bunk90d41122006-08-14 23:49:16 -070086{
Michal Kubeček9a03cd82016-03-08 14:44:35 +010087 write_lock_bh(&net->ipv6.fib6_walker_lock);
Alexey Dobriyanbbef49d2010-02-18 08:13:30 +000088 list_del(&w->lh);
Michal Kubeček9a03cd82016-03-08 14:44:35 +010089 write_unlock_bh(&net->ipv6.fib6_walker_lock);
Adrian Bunk90d41122006-08-14 23:49:16 -070090}
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +020091
Hannes Frederic Sowa812918c2014-10-06 19:58:37 +020092static int fib6_new_sernum(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
Hannes Frederic Sowa42b18702014-10-06 19:58:35 +020094 int new, old;
95
96 do {
Hannes Frederic Sowa812918c2014-10-06 19:58:37 +020097 old = atomic_read(&net->ipv6.fib6_sernum);
Hannes Frederic Sowa42b18702014-10-06 19:58:35 +020098 new = old < INT_MAX ? old + 1 : 1;
Hannes Frederic Sowa812918c2014-10-06 19:58:37 +020099 } while (atomic_cmpxchg(&net->ipv6.fib6_sernum,
100 old, new) != old);
Hannes Frederic Sowa42b18702014-10-06 19:58:35 +0200101 return new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102}
103
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +0200104enum {
105 FIB6_NO_SERNUM_CHANGE = 0,
106};
107
Wei Wang180ca442017-10-06 12:05:56 -0700108void fib6_update_sernum(struct rt6_info *rt)
109{
Wei Wang180ca442017-10-06 12:05:56 -0700110 struct net *net = dev_net(rt->dst.dev);
111 struct fib6_node *fn;
112
Wei Wang180ca442017-10-06 12:05:56 -0700113 fn = rcu_dereference_protected(rt->rt6i_node,
Ido Schimmel922c2ac2018-01-07 12:45:14 +0200114 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Wei Wang180ca442017-10-06 12:05:56 -0700115 if (fn)
116 fn->fn_sernum = fib6_new_sernum(net);
Wei Wang180ca442017-10-06 12:05:56 -0700117}
118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119/*
120 * Auxiliary address test functions for the radix tree.
121 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900122 * These assume a 32bit processor (although it will work on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 * 64bit processors)
124 */
125
126/*
127 * test bit
128 */
YOSHIFUJI Hideaki / 吉藤英明02cdce52010-03-27 01:24:16 +0000129#if defined(__LITTLE_ENDIAN)
130# define BITOP_BE32_SWIZZLE (0x1F & ~7)
131#else
132# define BITOP_BE32_SWIZZLE 0
133#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +0200135static __be32 addr_bit_set(const void *token, int fn_bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000137 const __be32 *addr = token;
YOSHIFUJI Hideaki / 吉藤英明02cdce52010-03-27 01:24:16 +0000138 /*
139 * Here,
Wang Yufen8db46f12014-03-28 12:07:02 +0800140 * 1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)
YOSHIFUJI Hideaki / 吉藤英明02cdce52010-03-27 01:24:16 +0000141 * is optimized version of
142 * htonl(1 << ((~fn_bit)&0x1F))
143 * See include/asm-generic/bitops/le.h.
144 */
Eric Dumazet0eae88f2010-04-20 19:06:52 -0700145 return (__force __be32)(1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)) &
146 addr[fn_bit >> 5];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Wei Wang81eb8442017-10-06 12:06:11 -0700149static struct fib6_node *node_alloc(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
151 struct fib6_node *fn;
152
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800153 fn = kmem_cache_zalloc(fib6_node_kmem, GFP_ATOMIC);
Wei Wang81eb8442017-10-06 12:06:11 -0700154 if (fn)
155 net->ipv6.rt6_stats->fib_nodes++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 return fn;
158}
159
Wei Wang81eb8442017-10-06 12:06:11 -0700160static void node_free_immediate(struct net *net, struct fib6_node *fn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
162 kmem_cache_free(fib6_node_kmem, fn);
Wei Wang81eb8442017-10-06 12:06:11 -0700163 net->ipv6.rt6_stats->fib_nodes--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
165
Wei Wangc5cff852017-08-21 09:47:10 -0700166static void node_free_rcu(struct rcu_head *head)
167{
168 struct fib6_node *fn = container_of(head, struct fib6_node, rcu);
169
170 kmem_cache_free(fib6_node_kmem, fn);
171}
172
Wei Wang81eb8442017-10-06 12:06:11 -0700173static void node_free(struct net *net, struct fib6_node *fn)
Wei Wangc5cff852017-08-21 09:47:10 -0700174{
175 call_rcu(&fn->rcu, node_free_rcu);
Wei Wang81eb8442017-10-06 12:06:11 -0700176 net->ipv6.rt6_stats->fib_nodes--;
Wei Wangc5cff852017-08-21 09:47:10 -0700177}
178
Ido Schimmela460aa82017-08-03 13:28:25 +0200179void rt6_free_pcpu(struct rt6_info *non_pcpu_rt)
Martin KaFai Laud52d3992015-05-22 20:56:06 -0700180{
181 int cpu;
182
183 if (!non_pcpu_rt->rt6i_pcpu)
184 return;
185
186 for_each_possible_cpu(cpu) {
187 struct rt6_info **ppcpu_rt;
188 struct rt6_info *pcpu_rt;
189
190 ppcpu_rt = per_cpu_ptr(non_pcpu_rt->rt6i_pcpu, cpu);
191 pcpu_rt = *ppcpu_rt;
192 if (pcpu_rt) {
Wei Wang95145282017-06-17 10:42:34 -0700193 dst_dev_put(&pcpu_rt->dst);
Wei Wang1cfb71e2017-06-17 10:42:33 -0700194 dst_release(&pcpu_rt->dst);
Martin KaFai Laud52d3992015-05-22 20:56:06 -0700195 *ppcpu_rt = NULL;
196 }
197 }
198}
Ido Schimmela460aa82017-08-03 13:28:25 +0200199EXPORT_SYMBOL_GPL(rt6_free_pcpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Sabrina Dubrocaba1cc082017-09-08 10:26:19 +0200201static void fib6_free_table(struct fib6_table *table)
202{
203 inetpeer_invalidate_tree(&table->tb6_peers);
204 kfree(table);
205}
206
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800207static void fib6_link_table(struct net *net, struct fib6_table *tb)
Patrick McHardy1b43af52006-08-10 23:11:17 -0700208{
209 unsigned int h;
210
Thomas Graf375216a2006-10-21 20:20:54 -0700211 /*
212 * Initialize table lock at a single place to give lockdep a key,
213 * tables aren't visible prior to being linked to the list.
214 */
Wei Wang66f5d6c2017-10-06 12:06:10 -0700215 spin_lock_init(&tb->tb6_lock);
Neil Hormana33bc5c2009-07-30 18:52:15 -0700216 h = tb->tb6_id & (FIB6_TABLE_HASHSZ - 1);
Patrick McHardy1b43af52006-08-10 23:11:17 -0700217
218 /*
219 * No protection necessary, this is the only list mutatation
220 * operation, tables never disappear once they exist.
221 */
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800222 hlist_add_head_rcu(&tb->tb6_hlist, &net->ipv6.fib_table_hash[h]);
Patrick McHardy1b43af52006-08-10 23:11:17 -0700223}
224
225#ifdef CONFIG_IPV6_MULTIPLE_TABLES
Daniel Lezcanoe0b855902008-03-03 23:24:31 -0800226
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800227static struct fib6_table *fib6_alloc_table(struct net *net, u32 id)
Thomas Grafc71099a2006-08-04 23:20:06 -0700228{
229 struct fib6_table *table;
230
231 table = kzalloc(sizeof(*table), GFP_ATOMIC);
David S. Miller507c9b12011-12-03 17:50:45 -0500232 if (table) {
Thomas Grafc71099a2006-08-04 23:20:06 -0700233 table->tb6_id = id;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700234 rcu_assign_pointer(table->tb6_root.leaf,
235 net->ipv6.ip6_null_entry);
Thomas Grafc71099a2006-08-04 23:20:06 -0700236 table->tb6_root.fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
David S. Miller8e773272012-06-11 00:01:52 -0700237 inet_peer_base_init(&table->tb6_peers);
Thomas Grafc71099a2006-08-04 23:20:06 -0700238 }
239
240 return table;
241}
242
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800243struct fib6_table *fib6_new_table(struct net *net, u32 id)
Thomas Grafc71099a2006-08-04 23:20:06 -0700244{
245 struct fib6_table *tb;
246
247 if (id == 0)
248 id = RT6_TABLE_MAIN;
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800249 tb = fib6_get_table(net, id);
Thomas Grafc71099a2006-08-04 23:20:06 -0700250 if (tb)
251 return tb;
252
Daniel Lezcano8ed67782008-03-04 13:48:30 -0800253 tb = fib6_alloc_table(net, id);
David S. Miller507c9b12011-12-03 17:50:45 -0500254 if (tb)
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800255 fib6_link_table(net, tb);
Thomas Grafc71099a2006-08-04 23:20:06 -0700256
257 return tb;
258}
David Ahernb3b46632016-05-04 21:46:12 -0700259EXPORT_SYMBOL_GPL(fib6_new_table);
Thomas Grafc71099a2006-08-04 23:20:06 -0700260
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800261struct fib6_table *fib6_get_table(struct net *net, u32 id)
Thomas Grafc71099a2006-08-04 23:20:06 -0700262{
263 struct fib6_table *tb;
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800264 struct hlist_head *head;
Thomas Grafc71099a2006-08-04 23:20:06 -0700265 unsigned int h;
266
267 if (id == 0)
268 id = RT6_TABLE_MAIN;
Neil Hormana33bc5c2009-07-30 18:52:15 -0700269 h = id & (FIB6_TABLE_HASHSZ - 1);
Thomas Grafc71099a2006-08-04 23:20:06 -0700270 rcu_read_lock();
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800271 head = &net->ipv6.fib_table_hash[h];
Sasha Levinb67bfe02013-02-27 17:06:00 -0800272 hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
Thomas Grafc71099a2006-08-04 23:20:06 -0700273 if (tb->tb6_id == id) {
274 rcu_read_unlock();
275 return tb;
276 }
277 }
278 rcu_read_unlock();
279
280 return NULL;
281}
David Ahernc4850682015-10-12 11:47:08 -0700282EXPORT_SYMBOL_GPL(fib6_get_table);
Thomas Grafc71099a2006-08-04 23:20:06 -0700283
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000284static void __net_init fib6_tables_init(struct net *net)
Thomas Grafc71099a2006-08-04 23:20:06 -0700285{
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800286 fib6_link_table(net, net->ipv6.fib6_main_tbl);
287 fib6_link_table(net, net->ipv6.fib6_local_tbl);
Thomas Grafc71099a2006-08-04 23:20:06 -0700288}
Thomas Grafc71099a2006-08-04 23:20:06 -0700289#else
290
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800291struct fib6_table *fib6_new_table(struct net *net, u32 id)
Thomas Grafc71099a2006-08-04 23:20:06 -0700292{
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800293 return fib6_get_table(net, id);
Thomas Grafc71099a2006-08-04 23:20:06 -0700294}
295
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800296struct fib6_table *fib6_get_table(struct net *net, u32 id)
Thomas Grafc71099a2006-08-04 23:20:06 -0700297{
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800298 return net->ipv6.fib6_main_tbl;
Thomas Grafc71099a2006-08-04 23:20:06 -0700299}
300
David S. Miller4c9483b2011-03-12 16:22:43 -0500301struct dst_entry *fib6_rule_lookup(struct net *net, struct flowi6 *fl6,
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800302 int flags, pol_lookup_t lookup)
Thomas Grafc71099a2006-08-04 23:20:06 -0700303{
lucienab997ad2015-10-23 15:36:53 +0800304 struct rt6_info *rt;
305
306 rt = lookup(net, net->ipv6.fib6_main_tbl, fl6, flags);
Serhey Popovych07f61552017-06-20 13:29:25 +0300307 if (rt->dst.error == -EAGAIN) {
lucienab997ad2015-10-23 15:36:53 +0800308 ip6_rt_put(rt);
309 rt = net->ipv6.ip6_null_entry;
310 dst_hold(&rt->dst);
311 }
312
313 return &rt->dst;
Thomas Grafc71099a2006-08-04 23:20:06 -0700314}
315
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000316static void __net_init fib6_tables_init(struct net *net)
Thomas Grafc71099a2006-08-04 23:20:06 -0700317{
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800318 fib6_link_table(net, net->ipv6.fib6_main_tbl);
Thomas Grafc71099a2006-08-04 23:20:06 -0700319}
320
321#endif
322
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200323unsigned int fib6_tables_seq_read(struct net *net)
324{
325 unsigned int h, fib_seq = 0;
326
327 rcu_read_lock();
328 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
329 struct hlist_head *head = &net->ipv6.fib_table_hash[h];
330 struct fib6_table *tb;
331
Wei Wang66f5d6c2017-10-06 12:06:10 -0700332 hlist_for_each_entry_rcu(tb, head, tb6_hlist)
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200333 fib_seq += tb->fib_seq;
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200334 }
335 rcu_read_unlock();
336
337 return fib_seq;
338}
339
340static int call_fib6_entry_notifier(struct notifier_block *nb, struct net *net,
341 enum fib_event_type event_type,
342 struct rt6_info *rt)
343{
344 struct fib6_entry_notifier_info info = {
345 .rt = rt,
346 };
347
348 return call_fib6_notifier(nb, net, event_type, &info.info);
349}
350
Ido Schimmeldf77fe42017-08-03 13:28:17 +0200351static int call_fib6_entry_notifiers(struct net *net,
352 enum fib_event_type event_type,
David Ahern6c31e5a2017-10-27 17:37:13 -0700353 struct rt6_info *rt,
354 struct netlink_ext_ack *extack)
Ido Schimmeldf77fe42017-08-03 13:28:17 +0200355{
356 struct fib6_entry_notifier_info info = {
David Ahern6c31e5a2017-10-27 17:37:13 -0700357 .info.extack = extack,
Ido Schimmeldf77fe42017-08-03 13:28:17 +0200358 .rt = rt,
359 };
360
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200361 rt->rt6i_table->fib_seq++;
Ido Schimmeldf77fe42017-08-03 13:28:17 +0200362 return call_fib6_notifiers(net, event_type, &info.info);
363}
364
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200365struct fib6_dump_arg {
366 struct net *net;
367 struct notifier_block *nb;
368};
369
370static void fib6_rt_dump(struct rt6_info *rt, struct fib6_dump_arg *arg)
371{
372 if (rt == arg->net->ipv6.ip6_null_entry)
373 return;
374 call_fib6_entry_notifier(arg->nb, arg->net, FIB_EVENT_ENTRY_ADD, rt);
375}
376
377static int fib6_node_dump(struct fib6_walker *w)
378{
379 struct rt6_info *rt;
380
Wei Wang66f5d6c2017-10-06 12:06:10 -0700381 for_each_fib6_walker_rt(w)
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200382 fib6_rt_dump(rt, w->args);
383 w->leaf = NULL;
384 return 0;
385}
386
387static void fib6_table_dump(struct net *net, struct fib6_table *tb,
388 struct fib6_walker *w)
389{
390 w->root = &tb->tb6_root;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700391 spin_lock_bh(&tb->tb6_lock);
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200392 fib6_walk(net, w);
Wei Wang66f5d6c2017-10-06 12:06:10 -0700393 spin_unlock_bh(&tb->tb6_lock);
Ido Schimmele1ee0a52017-08-03 13:28:19 +0200394}
395
396/* Called with rcu_read_lock() */
397int fib6_tables_dump(struct net *net, struct notifier_block *nb)
398{
399 struct fib6_dump_arg arg;
400 struct fib6_walker *w;
401 unsigned int h;
402
403 w = kzalloc(sizeof(*w), GFP_ATOMIC);
404 if (!w)
405 return -ENOMEM;
406
407 w->func = fib6_node_dump;
408 arg.net = net;
409 arg.nb = nb;
410 w->args = &arg;
411
412 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
413 struct hlist_head *head = &net->ipv6.fib_table_hash[h];
414 struct fib6_table *tb;
415
416 hlist_for_each_entry_rcu(tb, head, tb6_hlist)
417 fib6_table_dump(net, tb, w);
418 }
419
420 kfree(w);
421
422 return 0;
423}
424
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +0200425static int fib6_dump_node(struct fib6_walker *w)
Patrick McHardy1b43af52006-08-10 23:11:17 -0700426{
427 int res;
428 struct rt6_info *rt;
429
Wei Wang66f5d6c2017-10-06 12:06:10 -0700430 for_each_fib6_walker_rt(w) {
Patrick McHardy1b43af52006-08-10 23:11:17 -0700431 res = rt6_dump_route(rt, w->args);
432 if (res < 0) {
433 /* Frame is full, suspend walking */
434 w->leaf = rt;
435 return 1;
436 }
David Ahernbeb1afac52017-02-02 12:37:09 -0800437
438 /* Multipath routes are dumped in one route with the
439 * RTA_MULTIPATH attribute. Jump 'rt' to point to the
440 * last sibling of this route (no need to dump the
441 * sibling routes again)
442 */
443 if (rt->rt6i_nsiblings)
444 rt = list_last_entry(&rt->rt6i_siblings,
445 struct rt6_info,
446 rt6i_siblings);
Patrick McHardy1b43af52006-08-10 23:11:17 -0700447 }
448 w->leaf = NULL;
449 return 0;
450}
451
452static void fib6_dump_end(struct netlink_callback *cb)
453{
Michal Kubeček9a03cd82016-03-08 14:44:35 +0100454 struct net *net = sock_net(cb->skb->sk);
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +0200455 struct fib6_walker *w = (void *)cb->args[2];
Patrick McHardy1b43af52006-08-10 23:11:17 -0700456
457 if (w) {
Herbert Xu7891cc82009-01-13 22:17:51 -0800458 if (cb->args[4]) {
459 cb->args[4] = 0;
Michal Kubeček9a03cd82016-03-08 14:44:35 +0100460 fib6_walker_unlink(net, w);
Herbert Xu7891cc82009-01-13 22:17:51 -0800461 }
Patrick McHardy1b43af52006-08-10 23:11:17 -0700462 cb->args[2] = 0;
463 kfree(w);
464 }
Wang Yufen437de072014-03-28 12:07:04 +0800465 cb->done = (void *)cb->args[3];
Patrick McHardy1b43af52006-08-10 23:11:17 -0700466 cb->args[1] = 3;
467}
468
469static int fib6_dump_done(struct netlink_callback *cb)
470{
471 fib6_dump_end(cb);
472 return cb->done ? cb->done(cb) : 0;
473}
474
475static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb,
476 struct netlink_callback *cb)
477{
Michal Kubeček9a03cd82016-03-08 14:44:35 +0100478 struct net *net = sock_net(skb->sk);
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +0200479 struct fib6_walker *w;
Patrick McHardy1b43af52006-08-10 23:11:17 -0700480 int res;
481
482 w = (void *)cb->args[2];
483 w->root = &table->tb6_root;
484
485 if (cb->args[4] == 0) {
Patrick McHardy2bec5a32010-02-08 05:19:03 +0000486 w->count = 0;
487 w->skip = 0;
488
Wei Wang66f5d6c2017-10-06 12:06:10 -0700489 spin_lock_bh(&table->tb6_lock);
Michal Kubeček9a03cd82016-03-08 14:44:35 +0100490 res = fib6_walk(net, w);
Wei Wang66f5d6c2017-10-06 12:06:10 -0700491 spin_unlock_bh(&table->tb6_lock);
Patrick McHardy2bec5a32010-02-08 05:19:03 +0000492 if (res > 0) {
Patrick McHardy1b43af52006-08-10 23:11:17 -0700493 cb->args[4] = 1;
Patrick McHardy2bec5a32010-02-08 05:19:03 +0000494 cb->args[5] = w->root->fn_sernum;
495 }
Patrick McHardy1b43af52006-08-10 23:11:17 -0700496 } else {
Patrick McHardy2bec5a32010-02-08 05:19:03 +0000497 if (cb->args[5] != w->root->fn_sernum) {
498 /* Begin at the root if the tree changed */
499 cb->args[5] = w->root->fn_sernum;
500 w->state = FWS_INIT;
501 w->node = w->root;
502 w->skip = w->count;
503 } else
504 w->skip = 0;
505
Wei Wang66f5d6c2017-10-06 12:06:10 -0700506 spin_lock_bh(&table->tb6_lock);
Patrick McHardy1b43af52006-08-10 23:11:17 -0700507 res = fib6_walk_continue(w);
Wei Wang66f5d6c2017-10-06 12:06:10 -0700508 spin_unlock_bh(&table->tb6_lock);
Herbert Xu7891cc82009-01-13 22:17:51 -0800509 if (res <= 0) {
Michal Kubeček9a03cd82016-03-08 14:44:35 +0100510 fib6_walker_unlink(net, w);
Herbert Xu7891cc82009-01-13 22:17:51 -0800511 cb->args[4] = 0;
Patrick McHardy1b43af52006-08-10 23:11:17 -0700512 }
Patrick McHardy1b43af52006-08-10 23:11:17 -0700513 }
Herbert Xu7891cc82009-01-13 22:17:51 -0800514
Patrick McHardy1b43af52006-08-10 23:11:17 -0700515 return res;
516}
517
Thomas Grafc127ea22007-03-22 11:58:32 -0700518static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
Patrick McHardy1b43af52006-08-10 23:11:17 -0700519{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900520 struct net *net = sock_net(skb->sk);
Patrick McHardy1b43af52006-08-10 23:11:17 -0700521 unsigned int h, s_h;
522 unsigned int e = 0, s_e;
523 struct rt6_rtnl_dump_arg arg;
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +0200524 struct fib6_walker *w;
Patrick McHardy1b43af52006-08-10 23:11:17 -0700525 struct fib6_table *tb;
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800526 struct hlist_head *head;
Patrick McHardy1b43af52006-08-10 23:11:17 -0700527 int res = 0;
528
529 s_h = cb->args[0];
530 s_e = cb->args[1];
531
532 w = (void *)cb->args[2];
David S. Miller507c9b12011-12-03 17:50:45 -0500533 if (!w) {
Patrick McHardy1b43af52006-08-10 23:11:17 -0700534 /* New dump:
535 *
536 * 1. hook callback destructor.
537 */
538 cb->args[3] = (long)cb->done;
539 cb->done = fib6_dump_done;
540
541 /*
542 * 2. allocate and initialize walker.
543 */
544 w = kzalloc(sizeof(*w), GFP_ATOMIC);
David S. Miller507c9b12011-12-03 17:50:45 -0500545 if (!w)
Patrick McHardy1b43af52006-08-10 23:11:17 -0700546 return -ENOMEM;
547 w->func = fib6_dump_node;
548 cb->args[2] = (long)w;
549 }
550
551 arg.skb = skb;
552 arg.cb = cb;
Brian Haley191cd582008-08-14 15:33:21 -0700553 arg.net = net;
Patrick McHardy1b43af52006-08-10 23:11:17 -0700554 w->args = &arg;
555
Eric Dumazete67f88d2011-04-27 22:56:07 +0000556 rcu_read_lock();
Neil Hormana33bc5c2009-07-30 18:52:15 -0700557 for (h = s_h; h < FIB6_TABLE_HASHSZ; h++, s_e = 0) {
Patrick McHardy1b43af52006-08-10 23:11:17 -0700558 e = 0;
Daniel Lezcano58f09b72008-03-03 23:25:27 -0800559 head = &net->ipv6.fib_table_hash[h];
Sasha Levinb67bfe02013-02-27 17:06:00 -0800560 hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
Patrick McHardy1b43af52006-08-10 23:11:17 -0700561 if (e < s_e)
562 goto next;
563 res = fib6_dump_table(tb, skb, cb);
564 if (res != 0)
565 goto out;
566next:
567 e++;
568 }
569 }
570out:
Eric Dumazete67f88d2011-04-27 22:56:07 +0000571 rcu_read_unlock();
Patrick McHardy1b43af52006-08-10 23:11:17 -0700572 cb->args[1] = e;
573 cb->args[0] = h;
574
575 res = res < 0 ? res : skb->len;
576 if (res <= 0)
577 fib6_dump_end(cb);
578 return res;
579}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581/*
582 * Routing Table
583 *
584 * return the appropriate node for a routing tree "add" operation
585 * by either creating and inserting or by returning an existing
586 * node.
587 */
588
Wei Wang81eb8442017-10-06 12:06:11 -0700589static struct fib6_node *fib6_add_1(struct net *net,
590 struct fib6_table *table,
Wei Wang66f5d6c2017-10-06 12:06:10 -0700591 struct fib6_node *root,
592 struct in6_addr *addr, int plen,
593 int offset, int allow_create,
594 int replace_required,
595 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
597 struct fib6_node *fn, *in, *ln;
598 struct fib6_node *pn = NULL;
599 struct rt6key *key;
600 int bit;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900601 __be32 dir = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 RT6_TRACE("fib6_add_1\n");
604
605 /* insert node in tree */
606
607 fn = root;
608
609 do {
Wei Wang66f5d6c2017-10-06 12:06:10 -0700610 struct rt6_info *leaf = rcu_dereference_protected(fn->leaf,
611 lockdep_is_held(&table->tb6_lock));
612 key = (struct rt6key *)((u8 *)leaf + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614 /*
615 * Prefix match
616 */
617 if (plen < fn->fn_bit ||
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000618 !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) {
Matti Vaittinen14df0152011-11-16 21:18:02 +0000619 if (!allow_create) {
620 if (replace_required) {
David Ahernd5d531c2017-05-21 10:12:05 -0600621 NL_SET_ERR_MSG(extack,
622 "Can not replace route - no match found");
Joe Perchesf3213832012-05-15 14:11:53 +0000623 pr_warn("Can't replace route, no match found\n");
Matti Vaittinen14df0152011-11-16 21:18:02 +0000624 return ERR_PTR(-ENOENT);
625 }
Joe Perchesf3213832012-05-15 14:11:53 +0000626 pr_warn("NLM_F_CREATE should be set when creating new route\n");
Matti Vaittinen14df0152011-11-16 21:18:02 +0000627 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 goto insert_above;
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000629 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 /*
632 * Exact match ?
633 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 if (plen == fn->fn_bit) {
636 /* clean up an intermediate node */
David S. Miller507c9b12011-12-03 17:50:45 -0500637 if (!(fn->fn_flags & RTN_RTINFO)) {
Wei Wang66f5d6c2017-10-06 12:06:10 -0700638 RCU_INIT_POINTER(fn->leaf, NULL);
639 rt6_release(leaf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return fn;
643 }
644
645 /*
646 * We have more bits to go
647 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 /* Try to walk down on tree. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 dir = addr_bit_set(addr, fn->fn_bit);
651 pn = fn;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700652 fn = dir ?
653 rcu_dereference_protected(fn->right,
654 lockdep_is_held(&table->tb6_lock)) :
655 rcu_dereference_protected(fn->left,
656 lockdep_is_held(&table->tb6_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 } while (fn);
658
Matti Vaittinen14df0152011-11-16 21:18:02 +0000659 if (!allow_create) {
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000660 /* We should not create new node because
661 * NLM_F_REPLACE was specified without NLM_F_CREATE
662 * I assume it is safe to require NLM_F_CREATE when
663 * REPLACE flag is used! Later we may want to remove the
664 * check for replace_required, because according
665 * to netlink specification, NLM_F_CREATE
666 * MUST be specified if new route is created.
667 * That would keep IPv6 consistent with IPv4
668 */
Matti Vaittinen14df0152011-11-16 21:18:02 +0000669 if (replace_required) {
David Ahernd5d531c2017-05-21 10:12:05 -0600670 NL_SET_ERR_MSG(extack,
671 "Can not replace route - no match found");
Joe Perchesf3213832012-05-15 14:11:53 +0000672 pr_warn("Can't replace route, no match found\n");
Matti Vaittinen14df0152011-11-16 21:18:02 +0000673 return ERR_PTR(-ENOENT);
674 }
Joe Perchesf3213832012-05-15 14:11:53 +0000675 pr_warn("NLM_F_CREATE should be set when creating new route\n");
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000676 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /*
678 * We walked to the bottom of tree.
679 * Create new leaf node without children.
680 */
681
Wei Wang81eb8442017-10-06 12:06:11 -0700682 ln = node_alloc(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
David S. Miller507c9b12011-12-03 17:50:45 -0500684 if (!ln)
Lin Ming188c5172012-09-25 15:17:07 +0000685 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 ln->fn_bit = plen;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700687 RCU_INIT_POINTER(ln->parent, pn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689 if (dir)
Wei Wang66f5d6c2017-10-06 12:06:10 -0700690 rcu_assign_pointer(pn->right, ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 else
Wei Wang66f5d6c2017-10-06 12:06:10 -0700692 rcu_assign_pointer(pn->left, ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
694 return ln;
695
696
697insert_above:
698 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900699 * split since we don't have a common prefix anymore or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 * we have a less significant route.
701 * we've to insert an intermediate node on the list
702 * this new node will point to the one we need to create
703 * and the current
704 */
705
Wei Wang66f5d6c2017-10-06 12:06:10 -0700706 pn = rcu_dereference_protected(fn->parent,
707 lockdep_is_held(&table->tb6_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
709 /* find 1st bit in difference between the 2 addrs.
710
YOSHIFUJI Hideaki971f3592005-11-08 09:37:56 -0800711 See comment in __ipv6_addr_diff: bit may be an invalid value,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 but if it is >= plen, the value is ignored in any case.
713 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900714
fan.du9225b232013-07-22 14:21:09 +0800715 bit = __ipv6_addr_diff(addr, &key->addr, sizeof(*addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900717 /*
718 * (intermediate)[in]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 * / \
720 * (new leaf node)[ln] (old node)[fn]
721 */
722 if (plen > bit) {
Wei Wang81eb8442017-10-06 12:06:11 -0700723 in = node_alloc(net);
724 ln = node_alloc(net);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900725
David S. Miller507c9b12011-12-03 17:50:45 -0500726 if (!in || !ln) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 if (in)
Wei Wang81eb8442017-10-06 12:06:11 -0700728 node_free_immediate(net, in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 if (ln)
Wei Wang81eb8442017-10-06 12:06:11 -0700730 node_free_immediate(net, ln);
Lin Ming188c5172012-09-25 15:17:07 +0000731 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
733
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900734 /*
735 * new intermediate node.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 * RTN_RTINFO will
737 * be off since that an address that chooses one of
738 * the branches would not match less specific routes
739 * in the other branch
740 */
741
742 in->fn_bit = bit;
743
Wei Wang66f5d6c2017-10-06 12:06:10 -0700744 RCU_INIT_POINTER(in->parent, pn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 in->leaf = fn->leaf;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700746 atomic_inc(&rcu_dereference_protected(in->leaf,
747 lockdep_is_held(&table->tb6_lock))->rt6i_ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 /* update parent pointer */
750 if (dir)
Wei Wang66f5d6c2017-10-06 12:06:10 -0700751 rcu_assign_pointer(pn->right, in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 else
Wei Wang66f5d6c2017-10-06 12:06:10 -0700753 rcu_assign_pointer(pn->left, in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755 ln->fn_bit = plen;
756
Wei Wang66f5d6c2017-10-06 12:06:10 -0700757 RCU_INIT_POINTER(ln->parent, in);
758 rcu_assign_pointer(fn->parent, in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 if (addr_bit_set(addr, bit)) {
Wei Wang66f5d6c2017-10-06 12:06:10 -0700761 rcu_assign_pointer(in->right, ln);
762 rcu_assign_pointer(in->left, fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 } else {
Wei Wang66f5d6c2017-10-06 12:06:10 -0700764 rcu_assign_pointer(in->left, ln);
765 rcu_assign_pointer(in->right, fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 }
767 } else { /* plen <= bit */
768
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900769 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 * (new leaf node)[ln]
771 * / \
772 * (old node)[fn] NULL
773 */
774
Wei Wang81eb8442017-10-06 12:06:11 -0700775 ln = node_alloc(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
David S. Miller507c9b12011-12-03 17:50:45 -0500777 if (!ln)
Lin Ming188c5172012-09-25 15:17:07 +0000778 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 ln->fn_bit = plen;
781
Wei Wang66f5d6c2017-10-06 12:06:10 -0700782 RCU_INIT_POINTER(ln->parent, pn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 if (addr_bit_set(&key->addr, plen))
Wei Wang66f5d6c2017-10-06 12:06:10 -0700785 RCU_INIT_POINTER(ln->right, fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 else
Wei Wang66f5d6c2017-10-06 12:06:10 -0700787 RCU_INIT_POINTER(ln->left, fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Wei Wang66f5d6c2017-10-06 12:06:10 -0700789 rcu_assign_pointer(fn->parent, ln);
790
791 if (dir)
792 rcu_assign_pointer(pn->right, ln);
793 else
794 rcu_assign_pointer(pn->left, ln);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 }
796 return ln;
797}
798
Florian Westphale715b6d2015-01-05 23:57:44 +0100799static void fib6_copy_metrics(u32 *mp, const struct mx6_config *mxc)
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100800{
Florian Westphale715b6d2015-01-05 23:57:44 +0100801 int i;
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100802
Florian Westphale715b6d2015-01-05 23:57:44 +0100803 for (i = 0; i < RTAX_MAX; i++) {
804 if (test_bit(i, mxc->mx_valid))
805 mp[i] = mxc->mx[i];
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100806 }
Florian Westphale715b6d2015-01-05 23:57:44 +0100807}
808
809static int fib6_commit_metrics(struct dst_entry *dst, struct mx6_config *mxc)
810{
811 if (!mxc->mx)
812 return 0;
813
814 if (dst->flags & DST_HOST) {
815 u32 *mp = dst_metrics_write_ptr(dst);
816
817 if (unlikely(!mp))
818 return -ENOMEM;
819
820 fib6_copy_metrics(mp, mxc);
821 } else {
822 dst_init_metrics(dst, mxc->mx, false);
823
824 /* We've stolen mx now. */
825 mxc->mx = NULL;
826 }
827
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100828 return 0;
829}
830
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +0100831static void fib6_purge_rt(struct rt6_info *rt, struct fib6_node *fn,
832 struct net *net)
833{
Wei Wang66f5d6c2017-10-06 12:06:10 -0700834 struct fib6_table *table = rt->rt6i_table;
835
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +0100836 if (atomic_read(&rt->rt6i_ref) != 1) {
837 /* This route is used as dummy address holder in some split
838 * nodes. It is not leaked, but it still holds other resources,
839 * which must be released in time. So, scan ascendant nodes
840 * and replace dummy references to this route with references
841 * to still alive ones.
842 */
843 while (fn) {
Wei Wang66f5d6c2017-10-06 12:06:10 -0700844 struct rt6_info *leaf = rcu_dereference_protected(fn->leaf,
845 lockdep_is_held(&table->tb6_lock));
846 struct rt6_info *new_leaf;
847 if (!(fn->fn_flags & RTN_RTINFO) && leaf == rt) {
848 new_leaf = fib6_find_prefix(net, table, fn);
849 atomic_inc(&new_leaf->rt6i_ref);
850 rcu_assign_pointer(fn->leaf, new_leaf);
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +0100851 rt6_release(rt);
852 }
Wei Wang66f5d6c2017-10-06 12:06:10 -0700853 fn = rcu_dereference_protected(fn->parent,
854 lockdep_is_held(&table->tb6_lock));
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +0100855 }
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +0100856 }
857}
858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859/*
860 * Insert routing information in a node.
861 */
862
863static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
David Ahern6c31e5a2017-10-27 17:37:13 -0700864 struct nl_info *info, struct mx6_config *mxc,
865 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
Wei Wang66f5d6c2017-10-06 12:06:10 -0700867 struct rt6_info *leaf = rcu_dereference_protected(fn->leaf,
868 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 struct rt6_info *iter = NULL;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700870 struct rt6_info __rcu **ins;
871 struct rt6_info __rcu **fallback_ins = NULL;
David S. Miller507c9b12011-12-03 17:50:45 -0500872 int replace = (info->nlh &&
873 (info->nlh->nlmsg_flags & NLM_F_REPLACE));
874 int add = (!info->nlh ||
875 (info->nlh->nlmsg_flags & NLM_F_CREATE));
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000876 int found = 0;
Hannes Frederic Sowa307f2fb2013-07-12 23:46:33 +0200877 bool rt_can_ecmp = rt6_qualify_for_ecmp(rt);
Guillaume Nault73483c12016-09-07 17:21:40 +0200878 u16 nlflags = NLM_F_EXCL;
Michal Kubečeke5fd3872014-03-27 13:04:08 +0100879 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
David Ahern1f5e29c2017-01-31 16:51:37 -0800881 if (info->nlh && (info->nlh->nlmsg_flags & NLM_F_APPEND))
882 nlflags |= NLM_F_APPEND;
883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 ins = &fn->leaf;
885
Wei Wang66f5d6c2017-10-06 12:06:10 -0700886 for (iter = leaf; iter;
David Miller071fb372017-11-28 15:40:15 -0500887 iter = rcu_dereference_protected(iter->rt6_next,
Wei Wang66f5d6c2017-10-06 12:06:10 -0700888 lockdep_is_held(&rt->rt6i_table->tb6_lock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 /*
890 * Search for duplicates
891 */
892
893 if (iter->rt6i_metric == rt->rt6i_metric) {
894 /*
895 * Same priority level
896 */
David S. Miller507c9b12011-12-03 17:50:45 -0500897 if (info->nlh &&
898 (info->nlh->nlmsg_flags & NLM_F_EXCL))
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000899 return -EEXIST;
Guillaume Nault73483c12016-09-07 17:21:40 +0200900
901 nlflags &= ~NLM_F_EXCL;
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000902 if (replace) {
Michal Kubeček27596472015-05-18 20:54:00 +0200903 if (rt_can_ecmp == rt6_qualify_for_ecmp(iter)) {
904 found++;
905 break;
906 }
907 if (rt_can_ecmp)
908 fallback_ins = fallback_ins ?: ins;
909 goto next_iter;
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000910 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
David Ahernf06b7542017-07-05 14:41:46 -0600912 if (rt6_duplicate_nexthop(iter, rt)) {
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000913 if (rt->rt6i_nsiblings)
914 rt->rt6i_nsiblings = 0;
David S. Miller507c9b12011-12-03 17:50:45 -0500915 if (!(iter->rt6i_flags & RTF_EXPIRES))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 return -EEXIST;
Gao feng1716a962012-04-06 00:13:10 +0000917 if (!(rt->rt6i_flags & RTF_EXPIRES))
918 rt6_clean_expires(iter);
919 else
920 rt6_set_expires(iter, rt->dst.expires);
Martin KaFai Lau45e4fd22015-05-22 20:56:00 -0700921 iter->rt6i_pmtu = rt->rt6i_pmtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 return -EEXIST;
923 }
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000924 /* If we have the same destination and the same metric,
925 * but not the same gateway, then the route we try to
926 * add is sibling to this route, increment our counter
927 * of siblings, and later we will add our route to the
928 * list.
929 * Only static routes (which don't have flag
930 * RTF_EXPIRES) are used for ECMPv6.
931 *
932 * To avoid long list, we only had siblings if the
933 * route have a gateway.
934 */
Hannes Frederic Sowa307f2fb2013-07-12 23:46:33 +0200935 if (rt_can_ecmp &&
936 rt6_qualify_for_ecmp(iter))
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000937 rt->rt6i_nsiblings++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 }
939
940 if (iter->rt6i_metric > rt->rt6i_metric)
941 break;
942
Michal Kubeček27596472015-05-18 20:54:00 +0200943next_iter:
David Miller071fb372017-11-28 15:40:15 -0500944 ins = &iter->rt6_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
946
Michal Kubeček27596472015-05-18 20:54:00 +0200947 if (fallback_ins && !found) {
948 /* No ECMP-able route found, replace first non-ECMP one */
949 ins = fallback_ins;
Wei Wang66f5d6c2017-10-06 12:06:10 -0700950 iter = rcu_dereference_protected(*ins,
951 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Michal Kubeček27596472015-05-18 20:54:00 +0200952 found++;
953 }
954
David S. Millerf11e6652007-03-24 20:36:25 -0700955 /* Reset round-robin state, if necessary */
956 if (ins == &fn->leaf)
957 fn->rr_ptr = NULL;
958
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000959 /* Link this route to others same route. */
960 if (rt->rt6i_nsiblings) {
961 unsigned int rt6i_nsiblings;
962 struct rt6_info *sibling, *temp_sibling;
963
964 /* Find the first route that have the same metric */
Wei Wang66f5d6c2017-10-06 12:06:10 -0700965 sibling = leaf;
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000966 while (sibling) {
Hannes Frederic Sowa307f2fb2013-07-12 23:46:33 +0200967 if (sibling->rt6i_metric == rt->rt6i_metric &&
968 rt6_qualify_for_ecmp(sibling)) {
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000969 list_add_tail(&rt->rt6i_siblings,
970 &sibling->rt6i_siblings);
971 break;
972 }
David Miller071fb372017-11-28 15:40:15 -0500973 sibling = rcu_dereference_protected(sibling->rt6_next,
Wei Wang66f5d6c2017-10-06 12:06:10 -0700974 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000975 }
976 /* For each sibling in the list, increment the counter of
977 * siblings. BUG() if counters does not match, list of siblings
978 * is broken!
979 */
980 rt6i_nsiblings = 0;
981 list_for_each_entry_safe(sibling, temp_sibling,
982 &rt->rt6i_siblings, rt6i_siblings) {
983 sibling->rt6i_nsiblings++;
984 BUG_ON(sibling->rt6i_nsiblings != rt->rt6i_nsiblings);
985 rt6i_nsiblings++;
986 }
987 BUG_ON(rt6i_nsiblings != rt->rt6i_nsiblings);
Ido Schimmeld7dedee2018-01-09 16:40:25 +0200988 rt6_multipath_rebalance(temp_sibling);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +0000989 }
990
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 /*
992 * insert node
993 */
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000994 if (!replace) {
995 if (!add)
Joe Perchesf3213832012-05-15 14:11:53 +0000996 pr_warn("NLM_F_CREATE should be set when creating new route\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Matti Vaittinen4a287eb2011-11-14 00:15:14 +0000998add:
Guillaume Nault73483c12016-09-07 17:21:40 +0200999 nlflags |= NLM_F_CREATE;
Florian Westphale715b6d2015-01-05 23:57:44 +01001000 err = fib6_commit_metrics(&rt->dst, mxc);
1001 if (err)
1002 return err;
1003
David Miller071fb372017-11-28 15:40:15 -05001004 rcu_assign_pointer(rt->rt6_next, iter);
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001005 atomic_inc(&rt->rt6i_ref);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001006 rcu_assign_pointer(rt->rt6i_node, fn);
1007 rcu_assign_pointer(*ins, rt);
Ido Schimmeldf77fe42017-08-03 13:28:17 +02001008 call_fib6_entry_notifiers(info->nl_net, FIB_EVENT_ENTRY_ADD,
David Ahern6c31e5a2017-10-27 17:37:13 -07001009 rt, extack);
David Ahern3b1137f2017-02-02 12:37:10 -08001010 if (!info->skip_notify)
1011 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001012 info->nl_net->ipv6.rt6_stats->fib_rt_entries++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
David S. Miller507c9b12011-12-03 17:50:45 -05001014 if (!(fn->fn_flags & RTN_RTINFO)) {
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001015 info->nl_net->ipv6.rt6_stats->fib_route_nodes++;
1016 fn->fn_flags |= RTN_RTINFO;
1017 }
1018
1019 } else {
Michal Kubeček27596472015-05-18 20:54:00 +02001020 int nsiblings;
1021
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001022 if (!found) {
1023 if (add)
1024 goto add;
Joe Perchesf3213832012-05-15 14:11:53 +00001025 pr_warn("NLM_F_REPLACE set, but no existing node found!\n");
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001026 return -ENOENT;
1027 }
Florian Westphale715b6d2015-01-05 23:57:44 +01001028
1029 err = fib6_commit_metrics(&rt->dst, mxc);
1030 if (err)
1031 return err;
1032
Wei Wang66f5d6c2017-10-06 12:06:10 -07001033 atomic_inc(&rt->rt6i_ref);
Wei Wang4e587ea2017-08-25 15:03:10 -07001034 rcu_assign_pointer(rt->rt6i_node, fn);
David Miller071fb372017-11-28 15:40:15 -05001035 rt->rt6_next = iter->rt6_next;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001036 rcu_assign_pointer(*ins, rt);
Ido Schimmeldf77fe42017-08-03 13:28:17 +02001037 call_fib6_entry_notifiers(info->nl_net, FIB_EVENT_ENTRY_REPLACE,
David Ahern6c31e5a2017-10-27 17:37:13 -07001038 rt, extack);
David Ahern3b1137f2017-02-02 12:37:10 -08001039 if (!info->skip_notify)
1040 inet6_rt_notify(RTM_NEWROUTE, rt, info, NLM_F_REPLACE);
David S. Miller507c9b12011-12-03 17:50:45 -05001041 if (!(fn->fn_flags & RTN_RTINFO)) {
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001042 info->nl_net->ipv6.rt6_stats->fib_route_nodes++;
1043 fn->fn_flags |= RTN_RTINFO;
1044 }
Michal Kubeček27596472015-05-18 20:54:00 +02001045 nsiblings = iter->rt6i_nsiblings;
Ido Schimmel7483cea2017-08-03 13:28:22 +02001046 iter->rt6i_node = NULL;
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +01001047 fib6_purge_rt(iter, fn, info->nl_net);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001048 if (rcu_access_pointer(fn->rr_ptr) == iter)
Wei Wang383143f2017-08-16 11:18:09 -07001049 fn->rr_ptr = NULL;
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +01001050 rt6_release(iter);
Michal Kubeček27596472015-05-18 20:54:00 +02001051
1052 if (nsiblings) {
1053 /* Replacing an ECMP route, remove all siblings */
David Miller071fb372017-11-28 15:40:15 -05001054 ins = &rt->rt6_next;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001055 iter = rcu_dereference_protected(*ins,
1056 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Michal Kubeček27596472015-05-18 20:54:00 +02001057 while (iter) {
Sabrina Dubroca67e19402017-03-13 13:28:09 +01001058 if (iter->rt6i_metric > rt->rt6i_metric)
1059 break;
Michal Kubeček27596472015-05-18 20:54:00 +02001060 if (rt6_qualify_for_ecmp(iter)) {
David Miller071fb372017-11-28 15:40:15 -05001061 *ins = iter->rt6_next;
Ido Schimmel7483cea2017-08-03 13:28:22 +02001062 iter->rt6i_node = NULL;
Michal Kubeček27596472015-05-18 20:54:00 +02001063 fib6_purge_rt(iter, fn, info->nl_net);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001064 if (rcu_access_pointer(fn->rr_ptr) == iter)
Wei Wang383143f2017-08-16 11:18:09 -07001065 fn->rr_ptr = NULL;
Michal Kubeček27596472015-05-18 20:54:00 +02001066 rt6_release(iter);
1067 nsiblings--;
Wei Wang81eb8442017-10-06 12:06:11 -07001068 info->nl_net->ipv6.rt6_stats->fib_rt_entries--;
Michal Kubeček27596472015-05-18 20:54:00 +02001069 } else {
David Miller071fb372017-11-28 15:40:15 -05001070 ins = &iter->rt6_next;
Michal Kubeček27596472015-05-18 20:54:00 +02001071 }
Wei Wang66f5d6c2017-10-06 12:06:10 -07001072 iter = rcu_dereference_protected(*ins,
1073 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Michal Kubeček27596472015-05-18 20:54:00 +02001074 }
1075 WARN_ON(nsiblings != 0);
1076 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 }
1078
1079 return 0;
1080}
1081
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001082static void fib6_start_gc(struct net *net, struct rt6_info *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083{
Stephen Hemminger417f28b2008-07-22 14:33:45 -07001084 if (!timer_pending(&net->ipv6.ip6_fib_timer) &&
David S. Miller507c9b12011-12-03 17:50:45 -05001085 (rt->rt6i_flags & (RTF_EXPIRES | RTF_CACHE)))
Stephen Hemminger417f28b2008-07-22 14:33:45 -07001086 mod_timer(&net->ipv6.ip6_fib_timer,
Stephen Hemminger847499c2008-07-21 13:21:35 -07001087 jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088}
1089
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001090void fib6_force_start_gc(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091{
Stephen Hemminger417f28b2008-07-22 14:33:45 -07001092 if (!timer_pending(&net->ipv6.ip6_fib_timer))
1093 mod_timer(&net->ipv6.ip6_fib_timer,
Stephen Hemminger847499c2008-07-21 13:21:35 -07001094 jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095}
1096
Ido Schimmel4a8e56e2018-01-07 12:45:13 +02001097static void __fib6_update_sernum_upto_root(struct rt6_info *rt,
1098 int sernum)
Wei Wangbbd63f02017-10-06 12:06:07 -07001099{
1100 struct fib6_node *fn = rcu_dereference_protected(rt->rt6i_node,
1101 lockdep_is_held(&rt->rt6i_table->tb6_lock));
1102
1103 /* paired with smp_rmb() in rt6_get_cookie_safe() */
1104 smp_wmb();
1105 while (fn) {
1106 fn->fn_sernum = sernum;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001107 fn = rcu_dereference_protected(fn->parent,
1108 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Wei Wangbbd63f02017-10-06 12:06:07 -07001109 }
1110}
1111
Ido Schimmel4a8e56e2018-01-07 12:45:13 +02001112void fib6_update_sernum_upto_root(struct net *net, struct rt6_info *rt)
1113{
1114 __fib6_update_sernum_upto_root(rt, fib6_new_sernum(net));
1115}
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117/*
1118 * Add routing information to the routing tree.
1119 * <destination addr>/<source addr>
1120 * with source addr info in sub-trees
Wei Wang66f5d6c2017-10-06 12:06:10 -07001121 * Need to own table->tb6_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 */
1123
Florian Westphale715b6d2015-01-05 23:57:44 +01001124int fib6_add(struct fib6_node *root, struct rt6_info *rt,
David Ahern333c4302017-05-21 10:12:04 -06001125 struct nl_info *info, struct mx6_config *mxc,
1126 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127{
Wei Wang66f5d6c2017-10-06 12:06:10 -07001128 struct fib6_table *table = rt->rt6i_table;
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001129 struct fib6_node *fn, *pn = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 int err = -ENOMEM;
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001131 int allow_create = 1;
1132 int replace_required = 0;
Hannes Frederic Sowa812918c2014-10-06 19:58:37 +02001133 int sernum = fib6_new_sernum(info->nl_net);
David S. Miller507c9b12011-12-03 17:50:45 -05001134
Wei Wanga4c2fd72017-06-17 10:42:42 -07001135 if (WARN_ON_ONCE(!atomic_read(&rt->dst.__refcnt)))
Martin KaFai Lau8e3d5be2015-09-15 14:30:08 -07001136 return -EINVAL;
Wei Wang2b760fc2017-10-06 12:06:03 -07001137 if (WARN_ON_ONCE(rt->rt6i_flags & RTF_CACHE))
1138 return -EINVAL;
Martin KaFai Lau8e3d5be2015-09-15 14:30:08 -07001139
David S. Miller507c9b12011-12-03 17:50:45 -05001140 if (info->nlh) {
1141 if (!(info->nlh->nlmsg_flags & NLM_F_CREATE))
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001142 allow_create = 0;
David S. Miller507c9b12011-12-03 17:50:45 -05001143 if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001144 replace_required = 1;
1145 }
1146 if (!allow_create && !replace_required)
Joe Perchesf3213832012-05-15 14:11:53 +00001147 pr_warn("RTM_NEWROUTE with no NLM_F_CREATE or NLM_F_REPLACE\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Wei Wang81eb8442017-10-06 12:06:11 -07001149 fn = fib6_add_1(info->nl_net, table, root,
Wei Wang66f5d6c2017-10-06 12:06:10 -07001150 &rt->rt6i_dst.addr, rt->rt6i_dst.plen,
fan.du9225b232013-07-22 14:21:09 +08001151 offsetof(struct rt6_info, rt6i_dst), allow_create,
Wei Wangbbd63f02017-10-06 12:06:07 -07001152 replace_required, extack);
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001153 if (IS_ERR(fn)) {
1154 err = PTR_ERR(fn);
Daniel Borkmannae7b4e12013-09-07 15:13:20 +02001155 fn = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 goto out;
Lin Ming188c5172012-09-25 15:17:07 +00001157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001159 pn = fn;
1160
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161#ifdef CONFIG_IPV6_SUBTREES
1162 if (rt->rt6i_src.plen) {
1163 struct fib6_node *sn;
1164
Wei Wang66f5d6c2017-10-06 12:06:10 -07001165 if (!rcu_access_pointer(fn->subtree)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 struct fib6_node *sfn;
1167
1168 /*
1169 * Create subtree.
1170 *
1171 * fn[main tree]
1172 * |
1173 * sfn[subtree root]
1174 * \
1175 * sn[new leaf node]
1176 */
1177
1178 /* Create subtree root node */
Wei Wang81eb8442017-10-06 12:06:11 -07001179 sfn = node_alloc(info->nl_net);
David S. Miller507c9b12011-12-03 17:50:45 -05001180 if (!sfn)
Wei Wang348a4002017-08-18 17:14:49 -07001181 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001183 atomic_inc(&info->nl_net->ipv6.ip6_null_entry->rt6i_ref);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001184 rcu_assign_pointer(sfn->leaf,
1185 info->nl_net->ipv6.ip6_null_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 sfn->fn_flags = RTN_ROOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
1188 /* Now add the first leaf node to new subtree */
1189
Wei Wang81eb8442017-10-06 12:06:11 -07001190 sn = fib6_add_1(info->nl_net, table, sfn,
1191 &rt->rt6i_src.addr, rt->rt6i_src.plen,
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001192 offsetof(struct rt6_info, rt6i_src),
Wei Wangbbd63f02017-10-06 12:06:07 -07001193 allow_create, replace_required, extack);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
Wei Yongjunf950c0e2012-09-20 18:29:56 +00001195 if (IS_ERR(sn)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 /* If it is failed, discard just allocated
Wei Wang348a4002017-08-18 17:14:49 -07001197 root, and then (in failure) stale node
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 in main tree.
1199 */
Wei Wang81eb8442017-10-06 12:06:11 -07001200 node_free_immediate(info->nl_net, sfn);
Lin Ming188c5172012-09-25 15:17:07 +00001201 err = PTR_ERR(sn);
Wei Wang348a4002017-08-18 17:14:49 -07001202 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 }
1204
1205 /* Now link new subtree to main tree */
Wei Wang66f5d6c2017-10-06 12:06:10 -07001206 rcu_assign_pointer(sfn->parent, fn);
1207 rcu_assign_pointer(fn->subtree, sfn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 } else {
Wei Wang81eb8442017-10-06 12:06:11 -07001209 sn = fib6_add_1(info->nl_net, table, FIB6_SUBTREE(fn),
1210 &rt->rt6i_src.addr, rt->rt6i_src.plen,
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001211 offsetof(struct rt6_info, rt6i_src),
Wei Wangbbd63f02017-10-06 12:06:07 -07001212 allow_create, replace_required, extack);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
Matti Vaittinen4a287eb2011-11-14 00:15:14 +00001214 if (IS_ERR(sn)) {
1215 err = PTR_ERR(sn);
Wei Wang348a4002017-08-18 17:14:49 -07001216 goto failure;
Lin Ming188c5172012-09-25 15:17:07 +00001217 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 }
1219
Wei Wang66f5d6c2017-10-06 12:06:10 -07001220 if (!rcu_access_pointer(fn->leaf)) {
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001221 atomic_inc(&rt->rt6i_ref);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001222 rcu_assign_pointer(fn->leaf, rt);
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 fn = sn;
1225 }
1226#endif
1227
David Ahern6c31e5a2017-10-27 17:37:13 -07001228 err = fib6_add_rt2node(fn, rt, info, mxc, extack);
Wei Wangbbd63f02017-10-06 12:06:07 -07001229 if (!err) {
Ido Schimmel4a8e56e2018-01-07 12:45:13 +02001230 __fib6_update_sernum_upto_root(rt, sernum);
Daniel Lezcano63152fc2008-03-03 23:31:11 -08001231 fib6_start_gc(info->nl_net, rt);
Wei Wangbbd63f02017-10-06 12:06:07 -07001232 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
1234out:
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001235 if (err) {
1236#ifdef CONFIG_IPV6_SUBTREES
1237 /*
1238 * If fib6_add_1 has cleared the old leaf pointer in the
1239 * super-tree leaf node we have to find a new one for it.
1240 */
Wei Wang7bbfe002018-01-03 14:11:59 -08001241 if (pn != fn) {
1242 struct rt6_info *pn_leaf =
1243 rcu_dereference_protected(pn->leaf,
1244 lockdep_is_held(&table->tb6_lock));
1245 if (pn_leaf == rt) {
1246 pn_leaf = NULL;
1247 RCU_INIT_POINTER(pn->leaf, NULL);
1248 atomic_dec(&rt->rt6i_ref);
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001249 }
Wei Wang7bbfe002018-01-03 14:11:59 -08001250 if (!pn_leaf && !(pn->fn_flags & RTN_RTINFO)) {
1251 pn_leaf = fib6_find_prefix(info->nl_net, table,
1252 pn);
1253#if RT6_DEBUG >= 2
1254 if (!pn_leaf) {
1255 WARN_ON(!pn_leaf);
1256 pn_leaf =
1257 info->nl_net->ipv6.ip6_null_entry;
1258 }
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001259#endif
Wei Wang7bbfe002018-01-03 14:11:59 -08001260 atomic_inc(&pn_leaf->rt6i_ref);
1261 rcu_assign_pointer(pn->leaf, pn_leaf);
1262 }
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001263 }
1264#endif
Wei Wang348a4002017-08-18 17:14:49 -07001265 goto failure;
YOSHIFUJI Hideaki66729e12006-08-23 17:20:34 -07001266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 return err;
1268
Wei Wang348a4002017-08-18 17:14:49 -07001269failure:
1270 /* fn->leaf could be NULL if fn is an intermediate node and we
1271 * failed to add the new route to it in both subtree creation
1272 * failure and fib6_add_rt2node() failure case.
1273 * In both cases, fib6_repair_tree() should be called to fix
1274 * fn->leaf.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 if (fn && !(fn->fn_flags & (RTN_RTINFO|RTN_ROOT)))
Wei Wang66f5d6c2017-10-06 12:06:10 -07001277 fib6_repair_tree(info->nl_net, table, fn);
Wei Wang1cfb71e2017-06-17 10:42:33 -07001278 /* Always release dst as dst->__refcnt is guaranteed
1279 * to be taken before entering this function
1280 */
Wei Wang587fea72017-06-17 10:42:36 -07001281 dst_release_immediate(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283}
1284
1285/*
1286 * Routing tree lookup
1287 *
1288 */
1289
1290struct lookup_args {
David S. Miller507c9b12011-12-03 17:50:45 -05001291 int offset; /* key offset on rt6_info */
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001292 const struct in6_addr *addr; /* search key */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293};
1294
Wang Yufen437de072014-03-28 12:07:04 +08001295static struct fib6_node *fib6_lookup_1(struct fib6_node *root,
1296 struct lookup_args *args)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297{
1298 struct fib6_node *fn;
Al Viroe69a4ad2006-11-14 20:56:00 -08001299 __be32 dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
YOSHIFUJI Hideaki825e2882006-08-23 17:21:29 -07001301 if (unlikely(args->offset == 0))
1302 return NULL;
1303
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 /*
1305 * Descend on a tree
1306 */
1307
1308 fn = root;
1309
1310 for (;;) {
1311 struct fib6_node *next;
1312
1313 dir = addr_bit_set(args->addr, fn->fn_bit);
1314
Wei Wang66f5d6c2017-10-06 12:06:10 -07001315 next = dir ? rcu_dereference(fn->right) :
1316 rcu_dereference(fn->left);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
1318 if (next) {
1319 fn = next;
1320 continue;
1321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 break;
1323 }
1324
David S. Miller507c9b12011-12-03 17:50:45 -05001325 while (fn) {
Wei Wang66f5d6c2017-10-06 12:06:10 -07001326 struct fib6_node *subtree = FIB6_SUBTREE(fn);
1327
1328 if (subtree || fn->fn_flags & RTN_RTINFO) {
1329 struct rt6_info *leaf = rcu_dereference(fn->leaf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 struct rt6key *key;
1331
Wei Wang8d1040e2017-10-06 12:06:08 -07001332 if (!leaf)
1333 goto backtrack;
1334
1335 key = (struct rt6key *) ((u8 *)leaf + args->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
YOSHIFUJI Hideaki3fc5e042006-08-23 17:21:12 -07001337 if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) {
1338#ifdef CONFIG_IPV6_SUBTREES
Wei Wang66f5d6c2017-10-06 12:06:10 -07001339 if (subtree) {
Hannes Frederic Sowa3e3be272013-08-07 02:34:31 +02001340 struct fib6_node *sfn;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001341 sfn = fib6_lookup_1(subtree, args + 1);
Hannes Frederic Sowa3e3be272013-08-07 02:34:31 +02001342 if (!sfn)
1343 goto backtrack;
1344 fn = sfn;
1345 }
YOSHIFUJI Hideaki3fc5e042006-08-23 17:21:12 -07001346#endif
Hannes Frederic Sowa3e3be272013-08-07 02:34:31 +02001347 if (fn->fn_flags & RTN_RTINFO)
YOSHIFUJI Hideaki3fc5e042006-08-23 17:21:12 -07001348 return fn;
1349 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 }
Hannes Frederic Sowa3e3be272013-08-07 02:34:31 +02001351backtrack:
YOSHIFUJI Hideaki3fc5e042006-08-23 17:21:12 -07001352 if (fn->fn_flags & RTN_ROOT)
1353 break;
1354
Wei Wang66f5d6c2017-10-06 12:06:10 -07001355 fn = rcu_dereference(fn->parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 }
1357
1358 return NULL;
1359}
1360
Wei Wang66f5d6c2017-10-06 12:06:10 -07001361/* called with rcu_read_lock() held
1362 */
Wang Yufen437de072014-03-28 12:07:04 +08001363struct fib6_node *fib6_lookup(struct fib6_node *root, const struct in6_addr *daddr,
1364 const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 struct fib6_node *fn;
YOSHIFUJI Hideaki825e2882006-08-23 17:21:29 -07001367 struct lookup_args args[] = {
1368 {
1369 .offset = offsetof(struct rt6_info, rt6i_dst),
1370 .addr = daddr,
1371 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372#ifdef CONFIG_IPV6_SUBTREES
YOSHIFUJI Hideaki825e2882006-08-23 17:21:29 -07001373 {
1374 .offset = offsetof(struct rt6_info, rt6i_src),
1375 .addr = saddr,
1376 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377#endif
YOSHIFUJI Hideaki825e2882006-08-23 17:21:29 -07001378 {
1379 .offset = 0, /* sentinel */
1380 }
1381 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
YOSHIFUJI Hideakifefc2a62006-08-23 17:21:50 -07001383 fn = fib6_lookup_1(root, daddr ? args : args + 1);
David S. Miller507c9b12011-12-03 17:50:45 -05001384 if (!fn || fn->fn_flags & RTN_TL_ROOT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 fn = root;
1386
1387 return fn;
1388}
1389
1390/*
1391 * Get node with specified destination prefix (and source prefix,
1392 * if subtrees are used)
Wei Wang38fbeee2017-10-06 12:06:02 -07001393 * exact_match == true means we try to find fn with exact match of
1394 * the passed in prefix addr
1395 * exact_match == false means we try to find fn with longest prefix
1396 * match of the passed in prefix addr. This is useful for finding fn
1397 * for cached route as it will be stored in the exception table under
1398 * the node with longest prefix length.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 */
1400
1401
Wang Yufen437de072014-03-28 12:07:04 +08001402static struct fib6_node *fib6_locate_1(struct fib6_node *root,
1403 const struct in6_addr *addr,
Wei Wang38fbeee2017-10-06 12:06:02 -07001404 int plen, int offset,
1405 bool exact_match)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406{
Wei Wang38fbeee2017-10-06 12:06:02 -07001407 struct fib6_node *fn, *prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409 for (fn = root; fn ; ) {
Wei Wang66f5d6c2017-10-06 12:06:10 -07001410 struct rt6_info *leaf = rcu_dereference(fn->leaf);
Wei Wang8d1040e2017-10-06 12:06:08 -07001411 struct rt6key *key;
1412
1413 /* This node is being deleted */
1414 if (!leaf) {
1415 if (plen <= fn->fn_bit)
1416 goto out;
1417 else
1418 goto next;
1419 }
1420
1421 key = (struct rt6key *)((u8 *)leaf + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
1423 /*
1424 * Prefix match
1425 */
1426 if (plen < fn->fn_bit ||
1427 !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit))
Wei Wang38fbeee2017-10-06 12:06:02 -07001428 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430 if (plen == fn->fn_bit)
1431 return fn;
1432
Wei Wang38fbeee2017-10-06 12:06:02 -07001433 prev = fn;
1434
Wei Wang8d1040e2017-10-06 12:06:08 -07001435next:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 /*
1437 * We have more bits to go
1438 */
1439 if (addr_bit_set(addr, fn->fn_bit))
Wei Wang66f5d6c2017-10-06 12:06:10 -07001440 fn = rcu_dereference(fn->right);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 else
Wei Wang66f5d6c2017-10-06 12:06:10 -07001442 fn = rcu_dereference(fn->left);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 }
Wei Wang38fbeee2017-10-06 12:06:02 -07001444out:
1445 if (exact_match)
1446 return NULL;
1447 else
1448 return prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449}
1450
Wang Yufen437de072014-03-28 12:07:04 +08001451struct fib6_node *fib6_locate(struct fib6_node *root,
1452 const struct in6_addr *daddr, int dst_len,
Wei Wang38fbeee2017-10-06 12:06:02 -07001453 const struct in6_addr *saddr, int src_len,
1454 bool exact_match)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455{
1456 struct fib6_node *fn;
1457
1458 fn = fib6_locate_1(root, daddr, dst_len,
Wei Wang38fbeee2017-10-06 12:06:02 -07001459 offsetof(struct rt6_info, rt6i_dst),
1460 exact_match);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
1462#ifdef CONFIG_IPV6_SUBTREES
1463 if (src_len) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001464 WARN_ON(saddr == NULL);
Wei Wang0e801932017-10-13 15:01:08 -07001465 if (fn) {
1466 struct fib6_node *subtree = FIB6_SUBTREE(fn);
1467
1468 if (subtree) {
1469 fn = fib6_locate_1(subtree, saddr, src_len,
Wei Wang38fbeee2017-10-06 12:06:02 -07001470 offsetof(struct rt6_info, rt6i_src),
1471 exact_match);
Wei Wang0e801932017-10-13 15:01:08 -07001472 }
1473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 }
1475#endif
1476
David S. Miller507c9b12011-12-03 17:50:45 -05001477 if (fn && fn->fn_flags & RTN_RTINFO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 return fn;
1479
1480 return NULL;
1481}
1482
1483
1484/*
1485 * Deletion
1486 *
1487 */
1488
Wei Wang66f5d6c2017-10-06 12:06:10 -07001489static struct rt6_info *fib6_find_prefix(struct net *net,
1490 struct fib6_table *table,
1491 struct fib6_node *fn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492{
Wei Wang66f5d6c2017-10-06 12:06:10 -07001493 struct fib6_node *child_left, *child_right;
1494
David S. Miller507c9b12011-12-03 17:50:45 -05001495 if (fn->fn_flags & RTN_ROOT)
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001496 return net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
David S. Miller507c9b12011-12-03 17:50:45 -05001498 while (fn) {
Wei Wang66f5d6c2017-10-06 12:06:10 -07001499 child_left = rcu_dereference_protected(fn->left,
1500 lockdep_is_held(&table->tb6_lock));
1501 child_right = rcu_dereference_protected(fn->right,
1502 lockdep_is_held(&table->tb6_lock));
1503 if (child_left)
1504 return rcu_dereference_protected(child_left->leaf,
1505 lockdep_is_held(&table->tb6_lock));
1506 if (child_right)
1507 return rcu_dereference_protected(child_right->leaf,
1508 lockdep_is_held(&table->tb6_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509
YOSHIFUJI Hideaki7fc33162006-08-23 17:22:24 -07001510 fn = FIB6_SUBTREE(fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 }
1512 return NULL;
1513}
1514
1515/*
1516 * Called to trim the tree of intermediate nodes when possible. "fn"
1517 * is the node we want to try and remove.
Wei Wang66f5d6c2017-10-06 12:06:10 -07001518 * Need to own table->tb6_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 */
1520
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001521static struct fib6_node *fib6_repair_tree(struct net *net,
Wei Wang66f5d6c2017-10-06 12:06:10 -07001522 struct fib6_table *table,
1523 struct fib6_node *fn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
1525 int children;
1526 int nstate;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001527 struct fib6_node *child;
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001528 struct fib6_walker *w;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 int iter = 0;
1530
1531 for (;;) {
Wei Wang66f5d6c2017-10-06 12:06:10 -07001532 struct fib6_node *fn_r = rcu_dereference_protected(fn->right,
1533 lockdep_is_held(&table->tb6_lock));
1534 struct fib6_node *fn_l = rcu_dereference_protected(fn->left,
1535 lockdep_is_held(&table->tb6_lock));
1536 struct fib6_node *pn = rcu_dereference_protected(fn->parent,
1537 lockdep_is_held(&table->tb6_lock));
1538 struct fib6_node *pn_r = rcu_dereference_protected(pn->right,
1539 lockdep_is_held(&table->tb6_lock));
1540 struct fib6_node *pn_l = rcu_dereference_protected(pn->left,
1541 lockdep_is_held(&table->tb6_lock));
1542 struct rt6_info *fn_leaf = rcu_dereference_protected(fn->leaf,
1543 lockdep_is_held(&table->tb6_lock));
1544 struct rt6_info *pn_leaf = rcu_dereference_protected(pn->leaf,
1545 lockdep_is_held(&table->tb6_lock));
1546 struct rt6_info *new_fn_leaf;
1547
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 RT6_TRACE("fixing tree: plen=%d iter=%d\n", fn->fn_bit, iter);
1549 iter++;
1550
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001551 WARN_ON(fn->fn_flags & RTN_RTINFO);
1552 WARN_ON(fn->fn_flags & RTN_TL_ROOT);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001553 WARN_ON(fn_leaf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
1555 children = 0;
1556 child = NULL;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001557 if (fn_r)
1558 child = fn_r, children |= 1;
1559 if (fn_l)
1560 child = fn_l, children |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
YOSHIFUJI Hideaki7fc33162006-08-23 17:22:24 -07001562 if (children == 3 || FIB6_SUBTREE(fn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563#ifdef CONFIG_IPV6_SUBTREES
1564 /* Subtree root (i.e. fn) may have one child */
David S. Miller507c9b12011-12-03 17:50:45 -05001565 || (children && fn->fn_flags & RTN_ROOT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566#endif
1567 ) {
Wei Wang66f5d6c2017-10-06 12:06:10 -07001568 new_fn_leaf = fib6_find_prefix(net, table, fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569#if RT6_DEBUG >= 2
Wei Wang66f5d6c2017-10-06 12:06:10 -07001570 if (!new_fn_leaf) {
1571 WARN_ON(!new_fn_leaf);
1572 new_fn_leaf = net->ipv6.ip6_null_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 }
1574#endif
Wei Wang66f5d6c2017-10-06 12:06:10 -07001575 atomic_inc(&new_fn_leaf->rt6i_ref);
1576 rcu_assign_pointer(fn->leaf, new_fn_leaf);
1577 return pn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 }
1579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580#ifdef CONFIG_IPV6_SUBTREES
YOSHIFUJI Hideaki7fc33162006-08-23 17:22:24 -07001581 if (FIB6_SUBTREE(pn) == fn) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001582 WARN_ON(!(fn->fn_flags & RTN_ROOT));
Wei Wang66f5d6c2017-10-06 12:06:10 -07001583 RCU_INIT_POINTER(pn->subtree, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 nstate = FWS_L;
1585 } else {
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001586 WARN_ON(fn->fn_flags & RTN_ROOT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587#endif
Wei Wang66f5d6c2017-10-06 12:06:10 -07001588 if (pn_r == fn)
1589 rcu_assign_pointer(pn->right, child);
1590 else if (pn_l == fn)
1591 rcu_assign_pointer(pn->left, child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592#if RT6_DEBUG >= 2
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001593 else
1594 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595#endif
1596 if (child)
Wei Wang66f5d6c2017-10-06 12:06:10 -07001597 rcu_assign_pointer(child->parent, pn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 nstate = FWS_R;
1599#ifdef CONFIG_IPV6_SUBTREES
1600 }
1601#endif
1602
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001603 read_lock(&net->ipv6.fib6_walker_lock);
1604 FOR_WALKERS(net, w) {
David S. Miller507c9b12011-12-03 17:50:45 -05001605 if (!child) {
Wei Wang2b760fc2017-10-06 12:06:03 -07001606 if (w->node == fn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 RT6_TRACE("W %p adjusted by delnode 1, s=%d/%d\n", w, w->state, nstate);
1608 w->node = pn;
1609 w->state = nstate;
1610 }
1611 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 if (w->node == fn) {
1613 w->node = child;
1614 if (children&2) {
1615 RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state);
Wang Yufen8db46f12014-03-28 12:07:02 +08001616 w->state = w->state >= FWS_R ? FWS_U : FWS_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 } else {
1618 RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state);
Wang Yufen8db46f12014-03-28 12:07:02 +08001619 w->state = w->state >= FWS_C ? FWS_U : FWS_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 }
1621 }
1622 }
1623 }
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001624 read_unlock(&net->ipv6.fib6_walker_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
Wei Wang81eb8442017-10-06 12:06:11 -07001626 node_free(net, fn);
David S. Miller507c9b12011-12-03 17:50:45 -05001627 if (pn->fn_flags & RTN_RTINFO || FIB6_SUBTREE(pn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 return pn;
1629
Wei Wang66f5d6c2017-10-06 12:06:10 -07001630 RCU_INIT_POINTER(pn->leaf, NULL);
1631 rt6_release(pn_leaf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 fn = pn;
1633 }
1634}
1635
Wei Wang66f5d6c2017-10-06 12:06:10 -07001636static void fib6_del_route(struct fib6_table *table, struct fib6_node *fn,
1637 struct rt6_info __rcu **rtp, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638{
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001639 struct fib6_walker *w;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001640 struct rt6_info *rt = rcu_dereference_protected(*rtp,
1641 lockdep_is_held(&table->tb6_lock));
Benjamin Theryc5728722008-03-03 23:34:17 -08001642 struct net *net = info->nl_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
1644 RT6_TRACE("fib6_del_route\n");
1645
Wei Wang2b760fc2017-10-06 12:06:03 -07001646 WARN_ON_ONCE(rt->rt6i_flags & RTF_CACHE);
1647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 /* Unlink it */
David Miller071fb372017-11-28 15:40:15 -05001649 *rtp = rt->rt6_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 rt->rt6i_node = NULL;
Benjamin Theryc5728722008-03-03 23:34:17 -08001651 net->ipv6.rt6_stats->fib_rt_entries--;
1652 net->ipv6.rt6_stats->fib_discarded_routes++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Wei Wang2b760fc2017-10-06 12:06:03 -07001654 /* Flush all cached dst in exception table */
1655 rt6_flush_exceptions(rt);
1656
David S. Millerf11e6652007-03-24 20:36:25 -07001657 /* Reset round-robin state, if necessary */
Wei Wang66f5d6c2017-10-06 12:06:10 -07001658 if (rcu_access_pointer(fn->rr_ptr) == rt)
David S. Millerf11e6652007-03-24 20:36:25 -07001659 fn->rr_ptr = NULL;
1660
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00001661 /* Remove this entry from other siblings */
1662 if (rt->rt6i_nsiblings) {
1663 struct rt6_info *sibling, *next_sibling;
1664
1665 list_for_each_entry_safe(sibling, next_sibling,
1666 &rt->rt6i_siblings, rt6i_siblings)
1667 sibling->rt6i_nsiblings--;
1668 rt->rt6i_nsiblings = 0;
1669 list_del_init(&rt->rt6i_siblings);
Ido Schimmeld7dedee2018-01-09 16:40:25 +02001670 rt6_multipath_rebalance(next_sibling);
Nicolas Dichtel51ebd312012-10-22 03:42:09 +00001671 }
1672
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 /* Adjust walkers */
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001674 read_lock(&net->ipv6.fib6_walker_lock);
1675 FOR_WALKERS(net, w) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 if (w->state == FWS_C && w->leaf == rt) {
1677 RT6_TRACE("walker %p adjusted by delroute\n", w);
David Miller071fb372017-11-28 15:40:15 -05001678 w->leaf = rcu_dereference_protected(rt->rt6_next,
Wei Wang66f5d6c2017-10-06 12:06:10 -07001679 lockdep_is_held(&table->tb6_lock));
David S. Miller507c9b12011-12-03 17:50:45 -05001680 if (!w->leaf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 w->state = FWS_U;
1682 }
1683 }
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001684 read_unlock(&net->ipv6.fib6_walker_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 /* If it was last route, expunge its radix tree node */
Wei Wang66f5d6c2017-10-06 12:06:10 -07001687 if (!rcu_access_pointer(fn->leaf)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 fn->fn_flags &= ~RTN_RTINFO;
Benjamin Theryc5728722008-03-03 23:34:17 -08001689 net->ipv6.rt6_stats->fib_route_nodes--;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001690 fn = fib6_repair_tree(net, table, fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 }
1692
Hannes Frederic Sowa6e9e16e62015-01-26 15:11:17 +01001693 fib6_purge_rt(rt, fn, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
David Ahern6c31e5a2017-10-27 17:37:13 -07001695 call_fib6_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, rt, NULL);
David Ahern16a16cd2017-02-02 12:37:11 -08001696 if (!info->skip_notify)
1697 inet6_rt_notify(RTM_DELROUTE, rt, info, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 rt6_release(rt);
1699}
1700
Wei Wang66f5d6c2017-10-06 12:06:10 -07001701/* Need to own table->tb6_lock */
Thomas Graf86872cb2006-08-22 00:01:08 -07001702int fib6_del(struct rt6_info *rt, struct nl_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703{
Wei Wang4e587ea2017-08-25 15:03:10 -07001704 struct fib6_node *fn = rcu_dereference_protected(rt->rt6i_node,
1705 lockdep_is_held(&rt->rt6i_table->tb6_lock));
Wei Wang66f5d6c2017-10-06 12:06:10 -07001706 struct fib6_table *table = rt->rt6i_table;
Daniel Lezcano8ed67782008-03-04 13:48:30 -08001707 struct net *net = info->nl_net;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001708 struct rt6_info __rcu **rtp;
1709 struct rt6_info __rcu **rtp_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710
1711#if RT6_DEBUG >= 2
Wang Yufen8db46f12014-03-28 12:07:02 +08001712 if (rt->dst.obsolete > 0) {
Ian Morris53b24b82015-03-29 14:00:05 +01001713 WARN_ON(fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 return -ENOENT;
1715 }
1716#endif
David S. Miller507c9b12011-12-03 17:50:45 -05001717 if (!fn || rt == net->ipv6.ip6_null_entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 return -ENOENT;
1719
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001720 WARN_ON(!(fn->fn_flags & RTN_RTINFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721
Wei Wang2b760fc2017-10-06 12:06:03 -07001722 /* remove cached dst from exception table */
1723 if (rt->rt6i_flags & RTF_CACHE)
1724 return rt6_remove_exception_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
1726 /*
1727 * Walk the leaf entries looking for ourself
1728 */
1729
Wei Wang66f5d6c2017-10-06 12:06:10 -07001730 for (rtp = &fn->leaf; *rtp; rtp = rtp_next) {
1731 struct rt6_info *cur = rcu_dereference_protected(*rtp,
1732 lockdep_is_held(&table->tb6_lock));
1733 if (rt == cur) {
1734 fib6_del_route(table, fn, rtp, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 return 0;
1736 }
David Miller071fb372017-11-28 15:40:15 -05001737 rtp_next = &cur->rt6_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 }
1739 return -ENOENT;
1740}
1741
1742/*
1743 * Tree traversal function.
1744 *
1745 * Certainly, it is not interrupt safe.
1746 * However, it is internally reenterable wrt itself and fib6_add/fib6_del.
1747 * It means, that we can modify tree during walking
1748 * and use this function for garbage collection, clone pruning,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001749 * cleaning tree when a device goes down etc. etc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 *
1751 * It guarantees that every node will be traversed,
1752 * and that it will be traversed only once.
1753 *
1754 * Callback function w->func may return:
1755 * 0 -> continue walking.
1756 * positive value -> walking is suspended (used by tree dumps,
1757 * and probably by gc, if it will be split to several slices)
1758 * negative value -> terminate walking.
1759 *
1760 * The function itself returns:
1761 * 0 -> walk is complete.
1762 * >0 -> walk is incomplete (i.e. suspended)
1763 * <0 -> walk is terminated by an error.
Wei Wang66f5d6c2017-10-06 12:06:10 -07001764 *
1765 * This function is called with tb6_lock held.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 */
1767
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001768static int fib6_walk_continue(struct fib6_walker *w)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769{
Wei Wang66f5d6c2017-10-06 12:06:10 -07001770 struct fib6_node *fn, *pn, *left, *right;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
Wei Wang2b760fc2017-10-06 12:06:03 -07001772 /* w->root should always be table->tb6_root */
1773 WARN_ON_ONCE(!(w->root->fn_flags & RTN_TL_ROOT));
1774
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 for (;;) {
1776 fn = w->node;
David S. Miller507c9b12011-12-03 17:50:45 -05001777 if (!fn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 return 0;
1779
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 switch (w->state) {
1781#ifdef CONFIG_IPV6_SUBTREES
1782 case FWS_S:
YOSHIFUJI Hideaki7fc33162006-08-23 17:22:24 -07001783 if (FIB6_SUBTREE(fn)) {
1784 w->node = FIB6_SUBTREE(fn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 continue;
1786 }
1787 w->state = FWS_L;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001788#endif
Gustavo A. R. Silva275757e62017-10-16 16:36:52 -05001789 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 case FWS_L:
Wei Wang66f5d6c2017-10-06 12:06:10 -07001791 left = rcu_dereference_protected(fn->left, 1);
1792 if (left) {
1793 w->node = left;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 w->state = FWS_INIT;
1795 continue;
1796 }
1797 w->state = FWS_R;
Gustavo A. R. Silva275757e62017-10-16 16:36:52 -05001798 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 case FWS_R:
Wei Wang66f5d6c2017-10-06 12:06:10 -07001800 right = rcu_dereference_protected(fn->right, 1);
1801 if (right) {
1802 w->node = right;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 w->state = FWS_INIT;
1804 continue;
1805 }
1806 w->state = FWS_C;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001807 w->leaf = rcu_dereference_protected(fn->leaf, 1);
Gustavo A. R. Silva275757e62017-10-16 16:36:52 -05001808 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 case FWS_C:
David S. Miller507c9b12011-12-03 17:50:45 -05001810 if (w->leaf && fn->fn_flags & RTN_RTINFO) {
Patrick McHardy2bec5a32010-02-08 05:19:03 +00001811 int err;
1812
Eric Dumazetfa809e22012-06-25 15:37:19 -07001813 if (w->skip) {
1814 w->skip--;
Kumar Sundararajan1c265852014-04-24 09:48:53 -04001815 goto skip;
Patrick McHardy2bec5a32010-02-08 05:19:03 +00001816 }
1817
1818 err = w->func(w);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 if (err)
1820 return err;
Patrick McHardy2bec5a32010-02-08 05:19:03 +00001821
1822 w->count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 continue;
1824 }
Kumar Sundararajan1c265852014-04-24 09:48:53 -04001825skip:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 w->state = FWS_U;
Gustavo A. R. Silva275757e62017-10-16 16:36:52 -05001827 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 case FWS_U:
1829 if (fn == w->root)
1830 return 0;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001831 pn = rcu_dereference_protected(fn->parent, 1);
1832 left = rcu_dereference_protected(pn->left, 1);
1833 right = rcu_dereference_protected(pn->right, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 w->node = pn;
1835#ifdef CONFIG_IPV6_SUBTREES
YOSHIFUJI Hideaki7fc33162006-08-23 17:22:24 -07001836 if (FIB6_SUBTREE(pn) == fn) {
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001837 WARN_ON(!(fn->fn_flags & RTN_ROOT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 w->state = FWS_L;
1839 continue;
1840 }
1841#endif
Wei Wang66f5d6c2017-10-06 12:06:10 -07001842 if (left == fn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 w->state = FWS_R;
1844 continue;
1845 }
Wei Wang66f5d6c2017-10-06 12:06:10 -07001846 if (right == fn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 w->state = FWS_C;
Wei Wang66f5d6c2017-10-06 12:06:10 -07001848 w->leaf = rcu_dereference_protected(w->node->leaf, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 continue;
1850 }
1851#if RT6_DEBUG >= 2
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001852 WARN_ON(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853#endif
1854 }
1855 }
1856}
1857
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001858static int fib6_walk(struct net *net, struct fib6_walker *w)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
1860 int res;
1861
1862 w->state = FWS_INIT;
1863 w->node = w->root;
1864
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001865 fib6_walker_link(net, w);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 res = fib6_walk_continue(w);
1867 if (res <= 0)
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001868 fib6_walker_unlink(net, w);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 return res;
1870}
1871
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001872static int fib6_clean_node(struct fib6_walker *w)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873{
1874 int res;
1875 struct rt6_info *rt;
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001876 struct fib6_cleaner *c = container_of(w, struct fib6_cleaner, w);
Benjamin Theryec7d43c2008-03-03 23:31:57 -08001877 struct nl_info info = {
1878 .nl_net = c->net,
1879 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +02001881 if (c->sernum != FIB6_NO_SERNUM_CHANGE &&
1882 w->node->fn_sernum != c->sernum)
1883 w->node->fn_sernum = c->sernum;
1884
1885 if (!c->func) {
1886 WARN_ON_ONCE(c->sernum == FIB6_NO_SERNUM_CHANGE);
1887 w->leaf = NULL;
1888 return 0;
1889 }
1890
Wei Wang66f5d6c2017-10-06 12:06:10 -07001891 for_each_fib6_walker_rt(w) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 res = c->func(rt, c->arg);
Ido Schimmelb5cb5a72018-01-07 12:45:12 +02001893 if (res == -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 w->leaf = rt;
Denis V. Lunev528c4ce2007-12-13 09:45:12 -08001895 res = fib6_del(rt, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 if (res) {
1897#if RT6_DEBUG >= 2
Joe Perches91df42b2012-05-15 14:11:54 +00001898 pr_debug("%s: del failed: rt=%p@%p err=%d\n",
Wei Wang4e587ea2017-08-25 15:03:10 -07001899 __func__, rt,
1900 rcu_access_pointer(rt->rt6i_node),
1901 res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902#endif
1903 continue;
1904 }
1905 return 0;
Ido Schimmelb5cb5a72018-01-07 12:45:12 +02001906 } else if (res == -2) {
1907 if (WARN_ON(!rt->rt6i_nsiblings))
1908 continue;
1909 rt = list_last_entry(&rt->rt6i_siblings,
1910 struct rt6_info, rt6i_siblings);
1911 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 }
Ilpo Järvinen547b7922008-07-25 21:43:18 -07001913 WARN_ON(res != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 }
1915 w->leaf = rt;
1916 return 0;
1917}
1918
1919/*
1920 * Convenient frontend to tree walker.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001921 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 * func is called on each route.
Ido Schimmelb5cb5a72018-01-07 12:45:12 +02001923 * It may return -2 -> skip multipath route.
1924 * -1 -> delete this route.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 * 0 -> continue walking
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 */
1927
Benjamin Theryec7d43c2008-03-03 23:31:57 -08001928static void fib6_clean_tree(struct net *net, struct fib6_node *root,
Adrian Bunk8ce11e62006-08-07 21:50:48 -07001929 int (*func)(struct rt6_info *, void *arg),
Wei Wang2b760fc2017-10-06 12:06:03 -07001930 int sernum, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931{
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02001932 struct fib6_cleaner c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
1934 c.w.root = root;
1935 c.w.func = fib6_clean_node;
Patrick McHardy2bec5a32010-02-08 05:19:03 +00001936 c.w.count = 0;
1937 c.w.skip = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 c.func = func;
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +02001939 c.sernum = sernum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 c.arg = arg;
Benjamin Theryec7d43c2008-03-03 23:31:57 -08001941 c.net = net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942
Michal Kubeček9a03cd82016-03-08 14:44:35 +01001943 fib6_walk(net, &c.w);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944}
1945
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +02001946static void __fib6_clean_all(struct net *net,
1947 int (*func)(struct rt6_info *, void *),
1948 int sernum, void *arg)
Thomas Grafc71099a2006-08-04 23:20:06 -07001949{
Thomas Grafc71099a2006-08-04 23:20:06 -07001950 struct fib6_table *table;
Daniel Lezcano58f09b72008-03-03 23:25:27 -08001951 struct hlist_head *head;
Patrick McHardy1b43af52006-08-10 23:11:17 -07001952 unsigned int h;
Thomas Grafc71099a2006-08-04 23:20:06 -07001953
Patrick McHardy1b43af52006-08-10 23:11:17 -07001954 rcu_read_lock();
Neil Hormana33bc5c2009-07-30 18:52:15 -07001955 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
Daniel Lezcanof3db4852008-03-03 23:27:06 -08001956 head = &net->ipv6.fib_table_hash[h];
Sasha Levinb67bfe02013-02-27 17:06:00 -08001957 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
Wei Wang66f5d6c2017-10-06 12:06:10 -07001958 spin_lock_bh(&table->tb6_lock);
Benjamin Theryec7d43c2008-03-03 23:31:57 -08001959 fib6_clean_tree(net, &table->tb6_root,
Wei Wang2b760fc2017-10-06 12:06:03 -07001960 func, sernum, arg);
Wei Wang66f5d6c2017-10-06 12:06:10 -07001961 spin_unlock_bh(&table->tb6_lock);
Thomas Grafc71099a2006-08-04 23:20:06 -07001962 }
1963 }
Patrick McHardy1b43af52006-08-10 23:11:17 -07001964 rcu_read_unlock();
Thomas Grafc71099a2006-08-04 23:20:06 -07001965}
1966
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +02001967void fib6_clean_all(struct net *net, int (*func)(struct rt6_info *, void *),
1968 void *arg)
1969{
1970 __fib6_clean_all(net, func, FIB6_NO_SERNUM_CHANGE, arg);
1971}
1972
Hannes Frederic Sowa705f1c82014-09-28 00:46:06 +02001973static void fib6_flush_trees(struct net *net)
1974{
Hannes Frederic Sowa812918c2014-10-06 19:58:37 +02001975 int new_sernum = fib6_new_sernum(net);
Hannes Frederic Sowa705f1c82014-09-28 00:46:06 +02001976
Hannes Frederic Sowa327571c2014-10-06 19:58:38 +02001977 __fib6_clean_all(net, NULL, new_sernum, NULL);
Hannes Frederic Sowa705f1c82014-09-28 00:46:06 +02001978}
1979
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980/*
1981 * Garbage collection
1982 */
1983
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984static int fib6_age(struct rt6_info *rt, void *arg)
1985{
Michal Kubeček3570df92016-03-08 14:44:25 +01001986 struct fib6_gc_args *gc_args = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 unsigned long now = jiffies;
1988
1989 /*
1990 * check addrconf expiration here.
1991 * Routes are expired even if they are in use.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 */
1993
David S. Millerd1918542011-12-28 20:19:20 -05001994 if (rt->rt6i_flags & RTF_EXPIRES && rt->dst.expires) {
1995 if (time_after(now, rt->dst.expires)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 RT6_TRACE("expiring %p\n", rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 return -1;
1998 }
Michal Kubeček3570df92016-03-08 14:44:25 +01001999 gc_args->more++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 }
2001
Wei Wangc757faa2017-10-06 12:06:01 -07002002 /* Also age clones in the exception table.
2003 * Note, that clones are aged out
2004 * only if they are not in use now.
2005 */
2006 rt6_age_exceptions(rt, gc_args, now);
2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 return 0;
2009}
2010
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02002011void fib6_run_gc(unsigned long expires, struct net *net, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012{
Michal Kubeček3570df92016-03-08 14:44:25 +01002013 struct fib6_gc_args gc_args;
Michal Kubeček49a18d82013-08-01 10:04:24 +02002014 unsigned long now;
2015
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02002016 if (force) {
Michal Kubeček3dc94f92016-03-08 14:44:45 +01002017 spin_lock_bh(&net->ipv6.fib6_gc_lock);
2018 } else if (!spin_trylock_bh(&net->ipv6.fib6_gc_lock)) {
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02002019 mod_timer(&net->ipv6.ip6_fib_timer, jiffies + HZ);
2020 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 }
Michal Kubeček2ac3ac82013-08-01 10:04:14 +02002022 gc_args.timeout = expires ? (int)expires :
2023 net->ipv6.sysctl.ip6_rt_gc_interval;
Wei Wangdb916642017-06-17 10:42:37 -07002024 gc_args.more = 0;
Daniel Lezcanof3db4852008-03-03 23:27:06 -08002025
Michal Kubeček3570df92016-03-08 14:44:25 +01002026 fib6_clean_all(net, fib6_age, &gc_args);
Michal Kubeček49a18d82013-08-01 10:04:24 +02002027 now = jiffies;
2028 net->ipv6.ip6_rt_last_gc = now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029
2030 if (gc_args.more)
Stephen Hemmingerc8a45222008-07-22 14:34:09 -07002031 mod_timer(&net->ipv6.ip6_fib_timer,
Michal Kubeček49a18d82013-08-01 10:04:24 +02002032 round_jiffies(now
Stephen Hemmingerc8a45222008-07-22 14:34:09 -07002033 + net->ipv6.sysctl.ip6_rt_gc_interval));
Stephen Hemminger417f28b2008-07-22 14:33:45 -07002034 else
2035 del_timer(&net->ipv6.ip6_fib_timer);
Michal Kubeček3dc94f92016-03-08 14:44:45 +01002036 spin_unlock_bh(&net->ipv6.fib6_gc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037}
2038
Kees Cook86cb30e2017-10-17 20:21:24 -07002039static void fib6_gc_timer_cb(struct timer_list *t)
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08002040{
Kees Cook86cb30e2017-10-17 20:21:24 -07002041 struct net *arg = from_timer(arg, t, ipv6.ip6_fib_timer);
2042
2043 fib6_run_gc(0, arg, true);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08002044}
2045
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002046static int __net_init fib6_net_init(struct net *net)
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002047{
Eric Dumazet10da66f2010-10-13 08:22:03 +00002048 size_t size = sizeof(struct hlist_head) * FIB6_TABLE_HASHSZ;
Ido Schimmel16ab6d72017-08-03 13:28:16 +02002049 int err;
2050
2051 err = fib6_notifier_init(net);
2052 if (err)
2053 return err;
Eric Dumazet10da66f2010-10-13 08:22:03 +00002054
Michal Kubeček3dc94f92016-03-08 14:44:45 +01002055 spin_lock_init(&net->ipv6.fib6_gc_lock);
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002056 rwlock_init(&net->ipv6.fib6_walker_lock);
2057 INIT_LIST_HEAD(&net->ipv6.fib6_walkers);
Kees Cook86cb30e2017-10-17 20:21:24 -07002058 timer_setup(&net->ipv6.ip6_fib_timer, fib6_gc_timer_cb, 0);
Daniel Lezcano63152fc2008-03-03 23:31:11 -08002059
Benjamin Theryc5728722008-03-03 23:34:17 -08002060 net->ipv6.rt6_stats = kzalloc(sizeof(*net->ipv6.rt6_stats), GFP_KERNEL);
2061 if (!net->ipv6.rt6_stats)
2062 goto out_timer;
2063
Eric Dumazet10da66f2010-10-13 08:22:03 +00002064 /* Avoid false sharing : Use at least a full cache line */
2065 size = max_t(size_t, size, L1_CACHE_BYTES);
2066
2067 net->ipv6.fib_table_hash = kzalloc(size, GFP_KERNEL);
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002068 if (!net->ipv6.fib_table_hash)
Benjamin Theryc5728722008-03-03 23:34:17 -08002069 goto out_rt6_stats;
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002070
2071 net->ipv6.fib6_main_tbl = kzalloc(sizeof(*net->ipv6.fib6_main_tbl),
2072 GFP_KERNEL);
2073 if (!net->ipv6.fib6_main_tbl)
2074 goto out_fib_table_hash;
2075
2076 net->ipv6.fib6_main_tbl->tb6_id = RT6_TABLE_MAIN;
Wei Wang66f5d6c2017-10-06 12:06:10 -07002077 rcu_assign_pointer(net->ipv6.fib6_main_tbl->tb6_root.leaf,
2078 net->ipv6.ip6_null_entry);
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002079 net->ipv6.fib6_main_tbl->tb6_root.fn_flags =
2080 RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
David S. Miller8e773272012-06-11 00:01:52 -07002081 inet_peer_base_init(&net->ipv6.fib6_main_tbl->tb6_peers);
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002082
2083#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2084 net->ipv6.fib6_local_tbl = kzalloc(sizeof(*net->ipv6.fib6_local_tbl),
2085 GFP_KERNEL);
2086 if (!net->ipv6.fib6_local_tbl)
2087 goto out_fib6_main_tbl;
2088 net->ipv6.fib6_local_tbl->tb6_id = RT6_TABLE_LOCAL;
Wei Wang66f5d6c2017-10-06 12:06:10 -07002089 rcu_assign_pointer(net->ipv6.fib6_local_tbl->tb6_root.leaf,
2090 net->ipv6.ip6_null_entry);
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002091 net->ipv6.fib6_local_tbl->tb6_root.fn_flags =
2092 RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
David S. Miller8e773272012-06-11 00:01:52 -07002093 inet_peer_base_init(&net->ipv6.fib6_local_tbl->tb6_peers);
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002094#endif
2095 fib6_tables_init(net);
2096
Stephen Hemminger417f28b2008-07-22 14:33:45 -07002097 return 0;
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002098
2099#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2100out_fib6_main_tbl:
2101 kfree(net->ipv6.fib6_main_tbl);
2102#endif
2103out_fib_table_hash:
2104 kfree(net->ipv6.fib_table_hash);
Benjamin Theryc5728722008-03-03 23:34:17 -08002105out_rt6_stats:
2106 kfree(net->ipv6.rt6_stats);
Daniel Lezcano63152fc2008-03-03 23:31:11 -08002107out_timer:
Ido Schimmel16ab6d72017-08-03 13:28:16 +02002108 fib6_notifier_exit(net);
Stephen Hemminger417f28b2008-07-22 14:33:45 -07002109 return -ENOMEM;
Wang Yufen8db46f12014-03-28 12:07:02 +08002110}
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002111
2112static void fib6_net_exit(struct net *net)
2113{
Sabrina Dubrocaba1cc082017-09-08 10:26:19 +02002114 unsigned int i;
2115
Stephen Hemminger417f28b2008-07-22 14:33:45 -07002116 del_timer_sync(&net->ipv6.ip6_fib_timer);
2117
Eric Dumazet32a805b2017-09-08 15:48:47 -07002118 for (i = 0; i < FIB6_TABLE_HASHSZ; i++) {
Sabrina Dubrocaba1cc082017-09-08 10:26:19 +02002119 struct hlist_head *head = &net->ipv6.fib_table_hash[i];
2120 struct hlist_node *tmp;
2121 struct fib6_table *tb;
2122
2123 hlist_for_each_entry_safe(tb, tmp, head, tb6_hlist) {
2124 hlist_del(&tb->tb6_hlist);
2125 fib6_free_table(tb);
2126 }
2127 }
2128
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002129 kfree(net->ipv6.fib_table_hash);
Benjamin Theryc5728722008-03-03 23:34:17 -08002130 kfree(net->ipv6.rt6_stats);
Ido Schimmel16ab6d72017-08-03 13:28:16 +02002131 fib6_notifier_exit(net);
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002132}
2133
2134static struct pernet_operations fib6_net_ops = {
2135 .init = fib6_net_init,
2136 .exit = fib6_net_exit,
2137};
2138
Daniel Lezcanod63bddb2007-12-07 00:40:34 -08002139int __init fib6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140{
Daniel Lezcanoe0b855902008-03-03 23:24:31 -08002141 int ret = -ENOMEM;
Daniel Lezcano63152fc2008-03-03 23:31:11 -08002142
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 fib6_node_kmem = kmem_cache_create("fib6_nodes",
2144 sizeof(struct fib6_node),
Daniel Lezcanof845ab62007-12-07 00:45:16 -08002145 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +09002146 NULL);
Daniel Lezcanof845ab62007-12-07 00:45:16 -08002147 if (!fib6_node_kmem)
Daniel Lezcanoe0b855902008-03-03 23:24:31 -08002148 goto out;
2149
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002150 ret = register_pernet_subsys(&fib6_net_ops);
2151 if (ret)
Benjamin Theryc5728722008-03-03 23:34:17 -08002152 goto out_kmem_cache_create;
David S. Millere8803b62012-06-16 01:12:19 -07002153
Florian Westphal16feebc2017-12-02 21:44:08 +01002154 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE, NULL,
2155 inet6_dump_fib, 0);
David S. Millere8803b62012-06-16 01:12:19 -07002156 if (ret)
2157 goto out_unregister_subsys;
Hannes Frederic Sowa705f1c82014-09-28 00:46:06 +02002158
2159 __fib6_flush_trees = fib6_flush_trees;
Daniel Lezcanod63bddb2007-12-07 00:40:34 -08002160out:
2161 return ret;
2162
David S. Millere8803b62012-06-16 01:12:19 -07002163out_unregister_subsys:
2164 unregister_pernet_subsys(&fib6_net_ops);
Daniel Lezcanod63bddb2007-12-07 00:40:34 -08002165out_kmem_cache_create:
2166 kmem_cache_destroy(fib6_node_kmem);
2167 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168}
2169
2170void fib6_gc_cleanup(void)
2171{
Daniel Lezcano58f09b72008-03-03 23:25:27 -08002172 unregister_pernet_subsys(&fib6_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 kmem_cache_destroy(fib6_node_kmem);
2174}
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002175
2176#ifdef CONFIG_PROC_FS
2177
2178struct ipv6_route_iter {
2179 struct seq_net_private p;
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02002180 struct fib6_walker w;
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002181 loff_t skip;
2182 struct fib6_table *tbl;
Hannes Frederic Sowa42b18702014-10-06 19:58:35 +02002183 int sernum;
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002184};
2185
2186static int ipv6_route_seq_show(struct seq_file *seq, void *v)
2187{
2188 struct rt6_info *rt = v;
2189 struct ipv6_route_iter *iter = seq->private;
2190
2191 seq_printf(seq, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2192
2193#ifdef CONFIG_IPV6_SUBTREES
2194 seq_printf(seq, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2195#else
2196 seq_puts(seq, "00000000000000000000000000000000 00 ");
2197#endif
2198 if (rt->rt6i_flags & RTF_GATEWAY)
2199 seq_printf(seq, "%pi6", &rt->rt6i_gateway);
2200 else
2201 seq_puts(seq, "00000000000000000000000000000000");
2202
2203 seq_printf(seq, " %08x %08x %08x %08x %8s\n",
2204 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2205 rt->dst.__use, rt->rt6i_flags,
2206 rt->dst.dev ? rt->dst.dev->name : "");
2207 iter->w.leaf = NULL;
2208 return 0;
2209}
2210
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02002211static int ipv6_route_yield(struct fib6_walker *w)
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002212{
2213 struct ipv6_route_iter *iter = w->args;
2214
2215 if (!iter->skip)
2216 return 1;
2217
2218 do {
Wei Wang66f5d6c2017-10-06 12:06:10 -07002219 iter->w.leaf = rcu_dereference_protected(
David Miller071fb372017-11-28 15:40:15 -05002220 iter->w.leaf->rt6_next,
Wei Wang66f5d6c2017-10-06 12:06:10 -07002221 lockdep_is_held(&iter->tbl->tb6_lock));
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002222 iter->skip--;
2223 if (!iter->skip && iter->w.leaf)
2224 return 1;
2225 } while (iter->w.leaf);
2226
2227 return 0;
2228}
2229
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002230static void ipv6_route_seq_setup_walk(struct ipv6_route_iter *iter,
2231 struct net *net)
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002232{
2233 memset(&iter->w, 0, sizeof(iter->w));
2234 iter->w.func = ipv6_route_yield;
2235 iter->w.root = &iter->tbl->tb6_root;
2236 iter->w.state = FWS_INIT;
2237 iter->w.node = iter->w.root;
2238 iter->w.args = iter;
Hannes Frederic Sowa0a67d3e2013-09-21 16:56:10 +02002239 iter->sernum = iter->w.root->fn_sernum;
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002240 INIT_LIST_HEAD(&iter->w.lh);
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002241 fib6_walker_link(net, &iter->w);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002242}
2243
2244static struct fib6_table *ipv6_route_seq_next_table(struct fib6_table *tbl,
2245 struct net *net)
2246{
2247 unsigned int h;
2248 struct hlist_node *node;
2249
2250 if (tbl) {
2251 h = (tbl->tb6_id & (FIB6_TABLE_HASHSZ - 1)) + 1;
2252 node = rcu_dereference_bh(hlist_next_rcu(&tbl->tb6_hlist));
2253 } else {
2254 h = 0;
2255 node = NULL;
2256 }
2257
2258 while (!node && h < FIB6_TABLE_HASHSZ) {
2259 node = rcu_dereference_bh(
2260 hlist_first_rcu(&net->ipv6.fib_table_hash[h++]));
2261 }
2262 return hlist_entry_safe(node, struct fib6_table, tb6_hlist);
2263}
2264
Hannes Frederic Sowa0a67d3e2013-09-21 16:56:10 +02002265static void ipv6_route_check_sernum(struct ipv6_route_iter *iter)
2266{
2267 if (iter->sernum != iter->w.root->fn_sernum) {
2268 iter->sernum = iter->w.root->fn_sernum;
2269 iter->w.state = FWS_INIT;
2270 iter->w.node = iter->w.root;
2271 WARN_ON(iter->w.skip);
2272 iter->w.skip = iter->w.count;
2273 }
2274}
2275
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002276static void *ipv6_route_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2277{
2278 int r;
2279 struct rt6_info *n;
2280 struct net *net = seq_file_net(seq);
2281 struct ipv6_route_iter *iter = seq->private;
2282
2283 if (!v)
2284 goto iter_table;
2285
David Miller071fb372017-11-28 15:40:15 -05002286 n = rcu_dereference_bh(((struct rt6_info *)v)->rt6_next);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002287 if (n) {
2288 ++*pos;
2289 return n;
2290 }
2291
2292iter_table:
Hannes Frederic Sowa0a67d3e2013-09-21 16:56:10 +02002293 ipv6_route_check_sernum(iter);
Wei Wang66f5d6c2017-10-06 12:06:10 -07002294 spin_lock_bh(&iter->tbl->tb6_lock);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002295 r = fib6_walk_continue(&iter->w);
Wei Wang66f5d6c2017-10-06 12:06:10 -07002296 spin_unlock_bh(&iter->tbl->tb6_lock);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002297 if (r > 0) {
2298 if (v)
2299 ++*pos;
2300 return iter->w.leaf;
2301 } else if (r < 0) {
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002302 fib6_walker_unlink(net, &iter->w);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002303 return NULL;
2304 }
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002305 fib6_walker_unlink(net, &iter->w);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002306
2307 iter->tbl = ipv6_route_seq_next_table(iter->tbl, net);
2308 if (!iter->tbl)
2309 return NULL;
2310
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002311 ipv6_route_seq_setup_walk(iter, net);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002312 goto iter_table;
2313}
2314
2315static void *ipv6_route_seq_start(struct seq_file *seq, loff_t *pos)
2316 __acquires(RCU_BH)
2317{
2318 struct net *net = seq_file_net(seq);
2319 struct ipv6_route_iter *iter = seq->private;
2320
2321 rcu_read_lock_bh();
2322 iter->tbl = ipv6_route_seq_next_table(NULL, net);
2323 iter->skip = *pos;
2324
2325 if (iter->tbl) {
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002326 ipv6_route_seq_setup_walk(iter, net);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002327 return ipv6_route_seq_next(seq, NULL, pos);
2328 } else {
2329 return NULL;
2330 }
2331}
2332
2333static bool ipv6_route_iter_active(struct ipv6_route_iter *iter)
2334{
Hannes Frederic Sowa94b2cfe2014-10-06 19:58:34 +02002335 struct fib6_walker *w = &iter->w;
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002336 return w->node && !(w->state == FWS_U && w->node == w->root);
2337}
2338
2339static void ipv6_route_seq_stop(struct seq_file *seq, void *v)
2340 __releases(RCU_BH)
2341{
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002342 struct net *net = seq_file_net(seq);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002343 struct ipv6_route_iter *iter = seq->private;
2344
2345 if (ipv6_route_iter_active(iter))
Michal Kubeček9a03cd82016-03-08 14:44:35 +01002346 fib6_walker_unlink(net, &iter->w);
Hannes Frederic Sowa8d2ca1d2013-09-21 16:55:59 +02002347
2348 rcu_read_unlock_bh();
2349}
2350
2351static const struct seq_operations ipv6_route_seq_ops = {
2352 .start = ipv6_route_seq_start,
2353 .next = ipv6_route_seq_next,
2354 .stop = ipv6_route_seq_stop,
2355 .show = ipv6_route_seq_show
2356};
2357
2358int ipv6_route_open(struct inode *inode, struct file *file)
2359{
2360 return seq_open_net(inode, file, &ipv6_route_seq_ops,
2361 sizeof(struct ipv6_route_iter));
2362}
2363
2364#endif /* CONFIG_PROC_FS */