Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Linux INET6 implementation
4 : : * Forwarding Information Database
5 : : *
6 : : * Authors:
7 : : * Pedro Roque <roque@di.fc.ul.pt>
8 : : *
9 : : * Changes:
10 : : * Yuji SEKIYA @USAGI: Support default route on router node;
11 : : * remove ip6_null_entry from the top of
12 : : * routing table.
13 : : * Ville Nuorvala: Fixed routing subtrees.
14 : : */
15 : :
16 : : #define pr_fmt(fmt) "IPv6: " fmt
17 : :
18 : : #include <linux/errno.h>
19 : : #include <linux/types.h>
20 : : #include <linux/net.h>
21 : : #include <linux/route.h>
22 : : #include <linux/netdevice.h>
23 : : #include <linux/in6.h>
24 : : #include <linux/init.h>
25 : : #include <linux/list.h>
26 : : #include <linux/slab.h>
27 : :
28 : : #include <net/ip.h>
29 : : #include <net/ipv6.h>
30 : : #include <net/ndisc.h>
31 : : #include <net/addrconf.h>
32 : : #include <net/lwtunnel.h>
33 : : #include <net/fib_notifier.h>
34 : :
35 : : #include <net/ip6_fib.h>
36 : : #include <net/ip6_route.h>
37 : :
38 : : static struct kmem_cache *fib6_node_kmem __read_mostly;
39 : :
40 : : struct fib6_cleaner {
41 : : struct fib6_walker w;
42 : : struct net *net;
43 : : int (*func)(struct fib6_info *, void *arg);
44 : : int sernum;
45 : : void *arg;
46 : : bool skip_notify;
47 : : };
48 : :
49 : : #ifdef CONFIG_IPV6_SUBTREES
50 : : #define FWS_INIT FWS_S
51 : : #else
52 : : #define FWS_INIT FWS_L
53 : : #endif
54 : :
55 : : static struct fib6_info *fib6_find_prefix(struct net *net,
56 : : struct fib6_table *table,
57 : : struct fib6_node *fn);
58 : : static struct fib6_node *fib6_repair_tree(struct net *net,
59 : : struct fib6_table *table,
60 : : struct fib6_node *fn);
61 : : static int fib6_walk(struct net *net, struct fib6_walker *w);
62 : : static int fib6_walk_continue(struct fib6_walker *w);
63 : :
64 : : /*
65 : : * A routing update causes an increase of the serial number on the
66 : : * affected subtree. This allows for cached routes to be asynchronously
67 : : * tested when modifications are made to the destination cache as a
68 : : * result of redirects, path MTU changes, etc.
69 : : */
70 : :
71 : : static void fib6_gc_timer_cb(struct timer_list *t);
72 : :
73 : : #define FOR_WALKERS(net, w) \
74 : : list_for_each_entry(w, &(net)->ipv6.fib6_walkers, lh)
75 : :
76 : 4576 : static void fib6_walker_link(struct net *net, struct fib6_walker *w)
77 : : {
78 : 4576 : write_lock_bh(&net->ipv6.fib6_walker_lock);
79 : 4576 : list_add(&w->lh, &net->ipv6.fib6_walkers);
80 : 4576 : write_unlock_bh(&net->ipv6.fib6_walker_lock);
81 : 4576 : }
82 : :
83 : 4576 : static void fib6_walker_unlink(struct net *net, struct fib6_walker *w)
84 : : {
85 : 4576 : write_lock_bh(&net->ipv6.fib6_walker_lock);
86 : : list_del(&w->lh);
87 : 4576 : write_unlock_bh(&net->ipv6.fib6_walker_lock);
88 : 4576 : }
89 : :
90 : 3519 : static int fib6_new_sernum(struct net *net)
91 : : {
92 : : int new, old;
93 : :
94 : : do {
95 : 3519 : old = atomic_read(&net->ipv6.fib6_sernum);
96 [ + - ]: 3519 : new = old < INT_MAX ? old + 1 : 1;
97 : 3519 : } while (atomic_cmpxchg(&net->ipv6.fib6_sernum,
98 [ - + ]: 3519 : old, new) != old);
99 : 3519 : return new;
100 : : }
101 : :
102 : : enum {
103 : : FIB6_NO_SERNUM_CHANGE = 0,
104 : : };
105 : :
106 : 0 : void fib6_update_sernum(struct net *net, struct fib6_info *f6i)
107 : : {
108 : : struct fib6_node *fn;
109 : :
110 : 0 : fn = rcu_dereference_protected(f6i->fib6_node,
111 : : lockdep_is_held(&f6i->fib6_table->tb6_lock));
112 [ # # ]: 0 : if (fn)
113 : 0 : fn->fn_sernum = fib6_new_sernum(net);
114 : 0 : }
115 : :
116 : : /*
117 : : * Auxiliary address test functions for the radix tree.
118 : : *
119 : : * These assume a 32bit processor (although it will work on
120 : : * 64bit processors)
121 : : */
122 : :
123 : : /*
124 : : * test bit
125 : : */
126 : : #if defined(__LITTLE_ENDIAN)
127 : : # define BITOP_BE32_SWIZZLE (0x1F & ~7)
128 : : #else
129 : : # define BITOP_BE32_SWIZZLE 0
130 : : #endif
131 : :
132 : : static __be32 addr_bit_set(const void *token, int fn_bit)
133 : : {
134 : : const __be32 *addr = token;
135 : : /*
136 : : * Here,
137 : : * 1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)
138 : : * is optimized version of
139 : : * htonl(1 << ((~fn_bit)&0x1F))
140 : : * See include/asm-generic/bitops/le.h.
141 : : */
142 : 28106 : return (__force __be32)(1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)) &
143 : 14053 : addr[fn_bit >> 5];
144 : : }
145 : :
146 : 2506 : struct fib6_info *fib6_info_alloc(gfp_t gfp_flags, bool with_fib6_nh)
147 : : {
148 : : struct fib6_info *f6i;
149 : : size_t sz = sizeof(*f6i);
150 : :
151 [ + - ]: 2506 : if (with_fib6_nh)
152 : : sz += sizeof(struct fib6_nh);
153 : :
154 : 2506 : f6i = kzalloc(sz, gfp_flags);
155 [ + - ]: 2506 : if (!f6i)
156 : : return NULL;
157 : :
158 : : /* fib6_siblings is a union with nh_list, so this initializes both */
159 : 2506 : INIT_LIST_HEAD(&f6i->fib6_siblings);
160 : : refcount_set(&f6i->fib6_ref, 1);
161 : :
162 : 2506 : return f6i;
163 : : }
164 : :
165 : 1264 : void fib6_info_destroy_rcu(struct rcu_head *head)
166 : : {
167 : 1264 : struct fib6_info *f6i = container_of(head, struct fib6_info, rcu);
168 : :
169 [ - + ]: 1264 : WARN_ON(f6i->fib6_node);
170 : :
171 [ - + ]: 1264 : if (f6i->nh)
172 : 0 : nexthop_put(f6i->nh);
173 : : else
174 : 1264 : fib6_nh_release(f6i->fib6_nh);
175 : :
176 : 1264 : ip_fib_metrics_put(f6i->fib6_metrics);
177 : 1264 : kfree(f6i);
178 : 1264 : }
179 : : EXPORT_SYMBOL_GPL(fib6_info_destroy_rcu);
180 : :
181 : 1471 : static struct fib6_node *node_alloc(struct net *net)
182 : : {
183 : : struct fib6_node *fn;
184 : :
185 : 1471 : fn = kmem_cache_zalloc(fib6_node_kmem, GFP_ATOMIC);
186 [ + - ]: 1471 : if (fn)
187 : 1471 : net->ipv6.rt6_stats->fib_nodes++;
188 : :
189 : 1471 : return fn;
190 : : }
191 : :
192 : : static void node_free_immediate(struct net *net, struct fib6_node *fn)
193 : : {
194 : 0 : kmem_cache_free(fib6_node_kmem, fn);
195 : 0 : net->ipv6.rt6_stats->fib_nodes--;
196 : : }
197 : :
198 : 229 : static void node_free_rcu(struct rcu_head *head)
199 : : {
200 : 229 : struct fib6_node *fn = container_of(head, struct fib6_node, rcu);
201 : :
202 : 229 : kmem_cache_free(fib6_node_kmem, fn);
203 : 229 : }
204 : :
205 : : static void node_free(struct net *net, struct fib6_node *fn)
206 : : {
207 : 229 : call_rcu(&fn->rcu, node_free_rcu);
208 : 229 : net->ipv6.rt6_stats->fib_nodes--;
209 : : }
210 : :
211 : : static void fib6_free_table(struct fib6_table *table)
212 : : {
213 : 0 : inetpeer_invalidate_tree(&table->tb6_peers);
214 : 0 : kfree(table);
215 : : }
216 : :
217 : : static void fib6_link_table(struct net *net, struct fib6_table *tb)
218 : : {
219 : : unsigned int h;
220 : :
221 : : /*
222 : : * Initialize table lock at a single place to give lockdep a key,
223 : : * tables aren't visible prior to being linked to the list.
224 : : */
225 : 414 : spin_lock_init(&tb->tb6_lock);
226 : 414 : h = tb->tb6_id & (FIB6_TABLE_HASHSZ - 1);
227 : :
228 : : /*
229 : : * No protection necessary, this is the only list mutatation
230 : : * operation, tables never disappear once they exist.
231 : : */
232 : 414 : hlist_add_head_rcu(&tb->tb6_hlist, &net->ipv6.fib_table_hash[h]);
233 : : }
234 : :
235 : : #ifdef CONFIG_IPV6_MULTIPLE_TABLES
236 : :
237 : 0 : static struct fib6_table *fib6_alloc_table(struct net *net, u32 id)
238 : : {
239 : : struct fib6_table *table;
240 : :
241 : 0 : table = kzalloc(sizeof(*table), GFP_ATOMIC);
242 [ # # ]: 0 : if (table) {
243 : 0 : table->tb6_id = id;
244 : 0 : rcu_assign_pointer(table->tb6_root.leaf,
245 : : net->ipv6.fib6_null_entry);
246 : 0 : table->tb6_root.fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
247 : 0 : inet_peer_base_init(&table->tb6_peers);
248 : : }
249 : :
250 : 0 : return table;
251 : : }
252 : :
253 : 2299 : struct fib6_table *fib6_new_table(struct net *net, u32 id)
254 : : {
255 : : struct fib6_table *tb;
256 : :
257 [ - + ]: 2299 : if (id == 0)
258 : : id = RT6_TABLE_MAIN;
259 : 2299 : tb = fib6_get_table(net, id);
260 [ - + ]: 2299 : if (tb)
261 : : return tb;
262 : :
263 : 0 : tb = fib6_alloc_table(net, id);
264 [ # # ]: 0 : if (tb)
265 : : fib6_link_table(net, tb);
266 : :
267 : 0 : return tb;
268 : : }
269 : : EXPORT_SYMBOL_GPL(fib6_new_table);
270 : :
271 : 2506 : struct fib6_table *fib6_get_table(struct net *net, u32 id)
272 : : {
273 : : struct fib6_table *tb;
274 : : struct hlist_head *head;
275 : : unsigned int h;
276 : :
277 [ - + ]: 2506 : if (id == 0)
278 : : id = RT6_TABLE_MAIN;
279 : 2506 : h = id & (FIB6_TABLE_HASHSZ - 1);
280 : : rcu_read_lock();
281 : 2506 : head = &net->ipv6.fib_table_hash[h];
282 [ + - # # : 2506 : hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
+ - ]
283 [ + - ]: 2506 : if (tb->tb6_id == id) {
284 : : rcu_read_unlock();
285 : 2506 : return tb;
286 : : }
287 : : }
288 : : rcu_read_unlock();
289 : :
290 : 0 : return NULL;
291 : : }
292 : : EXPORT_SYMBOL_GPL(fib6_get_table);
293 : :
294 : 207 : static void __net_init fib6_tables_init(struct net *net)
295 : : {
296 : 207 : fib6_link_table(net, net->ipv6.fib6_main_tbl);
297 : 207 : fib6_link_table(net, net->ipv6.fib6_local_tbl);
298 : 207 : }
299 : : #else
300 : :
301 : : struct fib6_table *fib6_new_table(struct net *net, u32 id)
302 : : {
303 : : return fib6_get_table(net, id);
304 : : }
305 : :
306 : : struct fib6_table *fib6_get_table(struct net *net, u32 id)
307 : : {
308 : : return net->ipv6.fib6_main_tbl;
309 : : }
310 : :
311 : : struct dst_entry *fib6_rule_lookup(struct net *net, struct flowi6 *fl6,
312 : : const struct sk_buff *skb,
313 : : int flags, pol_lookup_t lookup)
314 : : {
315 : : struct rt6_info *rt;
316 : :
317 : : rt = lookup(net, net->ipv6.fib6_main_tbl, fl6, skb, flags);
318 : : if (rt->dst.error == -EAGAIN) {
319 : : ip6_rt_put_flags(rt, flags);
320 : : rt = net->ipv6.ip6_null_entry;
321 : : if (!(flags & RT6_LOOKUP_F_DST_NOREF))
322 : : dst_hold(&rt->dst);
323 : : }
324 : :
325 : : return &rt->dst;
326 : : }
327 : :
328 : : /* called with rcu lock held; no reference taken on fib6_info */
329 : : int fib6_lookup(struct net *net, int oif, struct flowi6 *fl6,
330 : : struct fib6_result *res, int flags)
331 : : {
332 : : return fib6_table_lookup(net, net->ipv6.fib6_main_tbl, oif, fl6,
333 : : res, flags);
334 : : }
335 : :
336 : : static void __net_init fib6_tables_init(struct net *net)
337 : : {
338 : : fib6_link_table(net, net->ipv6.fib6_main_tbl);
339 : : }
340 : :
341 : : #endif
342 : :
343 : 0 : unsigned int fib6_tables_seq_read(struct net *net)
344 : : {
345 : : unsigned int h, fib_seq = 0;
346 : :
347 : : rcu_read_lock();
348 [ # # ]: 0 : for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
349 : 0 : struct hlist_head *head = &net->ipv6.fib_table_hash[h];
350 : : struct fib6_table *tb;
351 : :
352 [ # # # # : 0 : hlist_for_each_entry_rcu(tb, head, tb6_hlist)
# # ]
353 : 0 : fib_seq += tb->fib_seq;
354 : : }
355 : : rcu_read_unlock();
356 : :
357 : 0 : return fib_seq;
358 : : }
359 : :
360 : 0 : static int call_fib6_entry_notifier(struct notifier_block *nb, struct net *net,
361 : : enum fib_event_type event_type,
362 : : struct fib6_info *rt)
363 : : {
364 : 0 : struct fib6_entry_notifier_info info = {
365 : : .rt = rt,
366 : : };
367 : :
368 : 0 : return call_fib6_notifier(nb, net, event_type, &info.info);
369 : : }
370 : :
371 : 1471 : int call_fib6_entry_notifiers(struct net *net,
372 : : enum fib_event_type event_type,
373 : : struct fib6_info *rt,
374 : : struct netlink_ext_ack *extack)
375 : : {
376 : 1471 : struct fib6_entry_notifier_info info = {
377 : : .info.extack = extack,
378 : : .rt = rt,
379 : : };
380 : :
381 : 1471 : rt->fib6_table->fib_seq++;
382 : 1471 : return call_fib6_notifiers(net, event_type, &info.info);
383 : : }
384 : :
385 : 0 : int call_fib6_multipath_entry_notifiers(struct net *net,
386 : : enum fib_event_type event_type,
387 : : struct fib6_info *rt,
388 : : unsigned int nsiblings,
389 : : struct netlink_ext_ack *extack)
390 : : {
391 : 0 : struct fib6_entry_notifier_info info = {
392 : : .info.extack = extack,
393 : : .rt = rt,
394 : : .nsiblings = nsiblings,
395 : : };
396 : :
397 : 0 : rt->fib6_table->fib_seq++;
398 : 0 : return call_fib6_notifiers(net, event_type, &info.info);
399 : : }
400 : :
401 : : struct fib6_dump_arg {
402 : : struct net *net;
403 : : struct notifier_block *nb;
404 : : };
405 : :
406 : 0 : static void fib6_rt_dump(struct fib6_info *rt, struct fib6_dump_arg *arg)
407 : : {
408 [ # # ]: 0 : if (rt == arg->net->ipv6.fib6_null_entry)
409 : 0 : return;
410 : 0 : call_fib6_entry_notifier(arg->nb, arg->net, FIB_EVENT_ENTRY_ADD, rt);
411 : : }
412 : :
413 : 0 : static int fib6_node_dump(struct fib6_walker *w)
414 : : {
415 : : struct fib6_info *rt;
416 : :
417 [ # # ]: 0 : for_each_fib6_walker_rt(w)
418 : 0 : fib6_rt_dump(rt, w->args);
419 : 0 : w->leaf = NULL;
420 : 0 : return 0;
421 : : }
422 : :
423 : 0 : static void fib6_table_dump(struct net *net, struct fib6_table *tb,
424 : : struct fib6_walker *w)
425 : : {
426 : 0 : w->root = &tb->tb6_root;
427 : : spin_lock_bh(&tb->tb6_lock);
428 : 0 : fib6_walk(net, w);
429 : : spin_unlock_bh(&tb->tb6_lock);
430 : 0 : }
431 : :
432 : : /* Called with rcu_read_lock() */
433 : 0 : int fib6_tables_dump(struct net *net, struct notifier_block *nb)
434 : : {
435 : : struct fib6_dump_arg arg;
436 : : struct fib6_walker *w;
437 : : unsigned int h;
438 : :
439 : 0 : w = kzalloc(sizeof(*w), GFP_ATOMIC);
440 [ # # ]: 0 : if (!w)
441 : : return -ENOMEM;
442 : :
443 : 0 : w->func = fib6_node_dump;
444 : 0 : arg.net = net;
445 : 0 : arg.nb = nb;
446 : 0 : w->args = &arg;
447 : :
448 [ # # ]: 0 : for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
449 : 0 : struct hlist_head *head = &net->ipv6.fib_table_hash[h];
450 : : struct fib6_table *tb;
451 : :
452 [ # # # # : 0 : hlist_for_each_entry_rcu(tb, head, tb6_hlist)
# # ]
453 : 0 : fib6_table_dump(net, tb, w);
454 : : }
455 : :
456 : 0 : kfree(w);
457 : :
458 : 0 : return 0;
459 : : }
460 : :
461 : 1035 : static int fib6_dump_node(struct fib6_walker *w)
462 : : {
463 : : int res;
464 : : struct fib6_info *rt;
465 : :
466 [ + + ]: 2070 : for_each_fib6_walker_rt(w) {
467 : 1035 : res = rt6_dump_route(rt, w->args, w->skip_in_node);
468 [ - + ]: 1035 : if (res >= 0) {
469 : : /* Frame is full, suspend walking */
470 : 0 : w->leaf = rt;
471 : :
472 : : /* We'll restart from this node, so if some routes were
473 : : * already dumped, skip them next time.
474 : : */
475 : 0 : w->skip_in_node += res;
476 : :
477 : 0 : return 1;
478 : : }
479 : 1035 : w->skip_in_node = 0;
480 : :
481 : : /* Multipath routes are dumped in one route with the
482 : : * RTA_MULTIPATH attribute. Jump 'rt' to point to the
483 : : * last sibling of this route (no need to dump the
484 : : * sibling routes again)
485 : : */
486 [ - + ]: 1035 : if (rt->fib6_nsiblings)
487 : 0 : rt = list_last_entry(&rt->fib6_siblings,
488 : : struct fib6_info,
489 : : fib6_siblings);
490 : : }
491 : 1035 : w->leaf = NULL;
492 : 1035 : return 0;
493 : : }
494 : :
495 : 207 : static void fib6_dump_end(struct netlink_callback *cb)
496 : : {
497 : 207 : struct net *net = sock_net(cb->skb->sk);
498 : 207 : struct fib6_walker *w = (void *)cb->args[2];
499 : :
500 [ + - ]: 207 : if (w) {
501 [ - + ]: 207 : if (cb->args[4]) {
502 : 0 : cb->args[4] = 0;
503 : 0 : fib6_walker_unlink(net, w);
504 : : }
505 : 207 : cb->args[2] = 0;
506 : 207 : kfree(w);
507 : : }
508 : 207 : cb->done = (void *)cb->args[3];
509 : 207 : cb->args[1] = 3;
510 : 207 : }
511 : :
512 : 0 : static int fib6_dump_done(struct netlink_callback *cb)
513 : : {
514 : 0 : fib6_dump_end(cb);
515 [ # # ]: 0 : return cb->done ? cb->done(cb) : 0;
516 : : }
517 : :
518 : 414 : static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb,
519 : : struct netlink_callback *cb)
520 : : {
521 : 414 : struct net *net = sock_net(skb->sk);
522 : : struct fib6_walker *w;
523 : : int res;
524 : :
525 : 414 : w = (void *)cb->args[2];
526 : 414 : w->root = &table->tb6_root;
527 : :
528 [ + - ]: 414 : if (cb->args[4] == 0) {
529 : 414 : w->count = 0;
530 : 414 : w->skip = 0;
531 : 414 : w->skip_in_node = 0;
532 : :
533 : : spin_lock_bh(&table->tb6_lock);
534 : 414 : res = fib6_walk(net, w);
535 : : spin_unlock_bh(&table->tb6_lock);
536 [ - + ]: 414 : if (res > 0) {
537 : 0 : cb->args[4] = 1;
538 : 0 : cb->args[5] = w->root->fn_sernum;
539 : : }
540 : : } else {
541 [ # # ]: 0 : if (cb->args[5] != w->root->fn_sernum) {
542 : : /* Begin at the root if the tree changed */
543 : 0 : cb->args[5] = w->root->fn_sernum;
544 : 0 : w->state = FWS_INIT;
545 : 0 : w->node = w->root;
546 : 0 : w->skip = w->count;
547 : 0 : w->skip_in_node = 0;
548 : : } else
549 : 0 : w->skip = 0;
550 : :
551 : : spin_lock_bh(&table->tb6_lock);
552 : 0 : res = fib6_walk_continue(w);
553 : : spin_unlock_bh(&table->tb6_lock);
554 [ # # ]: 0 : if (res <= 0) {
555 : 0 : fib6_walker_unlink(net, w);
556 : 0 : cb->args[4] = 0;
557 : : }
558 : : }
559 : :
560 : 414 : return res;
561 : : }
562 : :
563 : 414 : static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
564 : : {
565 : 414 : struct rt6_rtnl_dump_arg arg = { .filter.dump_exceptions = true,
566 : : .filter.dump_routes = true };
567 : 414 : const struct nlmsghdr *nlh = cb->nlh;
568 : 414 : struct net *net = sock_net(skb->sk);
569 : : unsigned int h, s_h;
570 : : unsigned int e = 0, s_e;
571 : : struct fib6_walker *w;
572 : : struct fib6_table *tb;
573 : : struct hlist_head *head;
574 : : int res = 0;
575 : :
576 [ - + ]: 414 : if (cb->strict_check) {
577 : : int err;
578 : :
579 : 0 : err = ip_valid_fib_dump_req(net, nlh, &arg.filter, cb);
580 [ # # ]: 0 : if (err < 0)
581 : : return err;
582 [ + - ]: 414 : } else if (nlmsg_len(nlh) >= sizeof(struct rtmsg)) {
583 : : struct rtmsg *rtm = nlmsg_data(nlh);
584 : :
585 [ - + ]: 414 : if (rtm->rtm_flags & RTM_F_PREFIX)
586 : 0 : arg.filter.flags = RTM_F_PREFIX;
587 : : }
588 : :
589 : 414 : w = (void *)cb->args[2];
590 [ + + ]: 414 : if (!w) {
591 : : /* New dump:
592 : : *
593 : : * 1. hook callback destructor.
594 : : */
595 : 207 : cb->args[3] = (long)cb->done;
596 : 207 : cb->done = fib6_dump_done;
597 : :
598 : : /*
599 : : * 2. allocate and initialize walker.
600 : : */
601 : 207 : w = kzalloc(sizeof(*w), GFP_ATOMIC);
602 [ + - ]: 207 : if (!w)
603 : : return -ENOMEM;
604 : 207 : w->func = fib6_dump_node;
605 : 207 : cb->args[2] = (long)w;
606 : : }
607 : :
608 : 414 : arg.skb = skb;
609 : 414 : arg.cb = cb;
610 : 414 : arg.net = net;
611 : 414 : w->args = &arg;
612 : :
613 [ - + ]: 414 : if (arg.filter.table_id) {
614 : 0 : tb = fib6_get_table(net, arg.filter.table_id);
615 [ # # ]: 0 : if (!tb) {
616 [ # # ]: 0 : if (rtnl_msg_family(cb->nlh) != PF_INET6)
617 : : goto out;
618 : :
619 [ # # ]: 0 : NL_SET_ERR_MSG_MOD(cb->extack, "FIB table does not exist");
620 : : return -ENOENT;
621 : : }
622 : :
623 [ # # ]: 0 : if (!cb->args[0]) {
624 : 0 : res = fib6_dump_table(tb, skb, cb);
625 [ # # ]: 0 : if (!res)
626 : 0 : cb->args[0] = 1;
627 : : }
628 : : goto out;
629 : : }
630 : :
631 : 414 : s_h = cb->args[0];
632 : 414 : s_e = cb->args[1];
633 : :
634 : : rcu_read_lock();
635 [ + + ]: 53406 : for (h = s_h; h < FIB6_TABLE_HASHSZ; h++, s_e = 0) {
636 : : e = 0;
637 : 52992 : head = &net->ipv6.fib_table_hash[h];
638 [ + + - + : 53406 : hlist_for_each_entry_rcu(tb, head, tb6_hlist) {
+ + ]
639 [ + - ]: 414 : if (e < s_e)
640 : : goto next;
641 : 414 : res = fib6_dump_table(tb, skb, cb);
642 [ + - ]: 414 : if (res != 0)
643 : : goto out_unlock;
644 : : next:
645 : 414 : e++;
646 : : }
647 : : }
648 : : out_unlock:
649 : : rcu_read_unlock();
650 : 414 : cb->args[1] = e;
651 : 414 : cb->args[0] = h;
652 : : out:
653 [ + - ]: 414 : res = res < 0 ? res : skb->len;
654 [ + + ]: 414 : if (res <= 0)
655 : 207 : fib6_dump_end(cb);
656 : 414 : return res;
657 : : }
658 : :
659 : 0 : void fib6_metric_set(struct fib6_info *f6i, int metric, u32 val)
660 : : {
661 [ # # ]: 0 : if (!f6i)
662 : : return;
663 : :
664 [ # # ]: 0 : if (f6i->fib6_metrics == &dst_default_metrics) {
665 : 0 : struct dst_metrics *p = kzalloc(sizeof(*p), GFP_ATOMIC);
666 : :
667 [ # # ]: 0 : if (!p)
668 : : return;
669 : :
670 : : refcount_set(&p->refcnt, 1);
671 : 0 : f6i->fib6_metrics = p;
672 : : }
673 : :
674 : 0 : f6i->fib6_metrics->metrics[metric - 1] = val;
675 : : }
676 : :
677 : : /*
678 : : * Routing Table
679 : : *
680 : : * return the appropriate node for a routing tree "add" operation
681 : : * by either creating and inserting or by returning an existing
682 : : * node.
683 : : */
684 : :
685 : 1667 : static struct fib6_node *fib6_add_1(struct net *net,
686 : : struct fib6_table *table,
687 : : struct fib6_node *root,
688 : : struct in6_addr *addr, int plen,
689 : : int offset, int allow_create,
690 : : int replace_required,
691 : : struct netlink_ext_ack *extack)
692 : : {
693 : : struct fib6_node *fn, *in, *ln;
694 : : struct fib6_node *pn = NULL;
695 : : struct rt6key *key;
696 : : int bit;
697 : : __be32 dir = 0;
698 : :
699 : : RT6_TRACE("fib6_add_1\n");
700 : :
701 : : /* insert node in tree */
702 : :
703 : : fn = root;
704 : :
705 : : do {
706 : 2299 : struct fib6_info *leaf = rcu_dereference_protected(fn->leaf,
707 : : lockdep_is_held(&table->tb6_lock));
708 : 2299 : key = (struct rt6key *)((u8 *)leaf + offset);
709 : :
710 : : /*
711 : : * Prefix match
712 : : */
713 [ + - + + ]: 4598 : if (plen < fn->fn_bit ||
714 : 2299 : !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) {
715 [ - + ]: 218 : if (!allow_create) {
716 [ # # ]: 0 : if (replace_required) {
717 [ # # ]: 0 : NL_SET_ERR_MSG(extack,
718 : : "Can not replace route - no match found");
719 : 0 : pr_warn("Can't replace route, no match found\n");
720 : 0 : return ERR_PTR(-ENOENT);
721 : : }
722 : 0 : pr_warn("NLM_F_CREATE should be set when creating new route\n");
723 : : }
724 : : goto insert_above;
725 : : }
726 : :
727 : : /*
728 : : * Exact match ?
729 : : */
730 : :
731 [ + + ]: 2081 : if (plen == fn->fn_bit) {
732 : : /* clean up an intermediate node */
733 [ - + ]: 414 : if (!(fn->fn_flags & RTN_RTINFO)) {
734 : : RCU_INIT_POINTER(fn->leaf, NULL);
735 : 0 : fib6_info_release(leaf);
736 : : /* remove null_entry in the root node */
737 [ - + # # ]: 414 : } else if (fn->fn_flags & RTN_TL_ROOT &&
738 : 0 : rcu_access_pointer(fn->leaf) ==
739 : 0 : net->ipv6.fib6_null_entry) {
740 : : RCU_INIT_POINTER(fn->leaf, NULL);
741 : : }
742 : :
743 : 414 : return fn;
744 : : }
745 : :
746 : : /*
747 : : * We have more bits to go
748 : : */
749 : :
750 : : /* Try to walk down on tree. */
751 : : dir = addr_bit_set(addr, fn->fn_bit);
752 : : pn = fn;
753 : : fn = dir ?
754 : 1253 : rcu_dereference_protected(fn->right,
755 [ + + ]: 1667 : lockdep_is_held(&table->tb6_lock)) :
756 : 414 : rcu_dereference_protected(fn->left,
757 : : lockdep_is_held(&table->tb6_lock));
758 [ + + ]: 1667 : } while (fn);
759 : :
760 [ - + ]: 1035 : if (!allow_create) {
761 : : /* We should not create new node because
762 : : * NLM_F_REPLACE was specified without NLM_F_CREATE
763 : : * I assume it is safe to require NLM_F_CREATE when
764 : : * REPLACE flag is used! Later we may want to remove the
765 : : * check for replace_required, because according
766 : : * to netlink specification, NLM_F_CREATE
767 : : * MUST be specified if new route is created.
768 : : * That would keep IPv6 consistent with IPv4
769 : : */
770 [ # # ]: 0 : if (replace_required) {
771 [ # # ]: 0 : NL_SET_ERR_MSG(extack,
772 : : "Can not replace route - no match found");
773 : 0 : pr_warn("Can't replace route, no match found\n");
774 : 0 : return ERR_PTR(-ENOENT);
775 : : }
776 : 0 : pr_warn("NLM_F_CREATE should be set when creating new route\n");
777 : : }
778 : : /*
779 : : * We walked to the bottom of tree.
780 : : * Create new leaf node without children.
781 : : */
782 : :
783 : 1035 : ln = node_alloc(net);
784 : :
785 [ + - ]: 1035 : if (!ln)
786 : : return ERR_PTR(-ENOMEM);
787 : 1035 : ln->fn_bit = plen;
788 : 1035 : RCU_INIT_POINTER(ln->parent, pn);
789 : :
790 [ + + ]: 1035 : if (dir)
791 : 621 : rcu_assign_pointer(pn->right, ln);
792 : : else
793 : 414 : rcu_assign_pointer(pn->left, ln);
794 : :
795 : 1035 : return ln;
796 : :
797 : :
798 : : insert_above:
799 : : /*
800 : : * split since we don't have a common prefix anymore or
801 : : * we have a less significant route.
802 : : * we've to insert an intermediate node on the list
803 : : * this new node will point to the one we need to create
804 : : * and the current
805 : : */
806 : :
807 : 218 : pn = rcu_dereference_protected(fn->parent,
808 : : lockdep_is_held(&table->tb6_lock));
809 : :
810 : : /* find 1st bit in difference between the 2 addrs.
811 : :
812 : : See comment in __ipv6_addr_diff: bit may be an invalid value,
813 : : but if it is >= plen, the value is ignored in any case.
814 : : */
815 : :
816 : 218 : bit = __ipv6_addr_diff(addr, &key->addr, sizeof(*addr));
817 : :
818 : : /*
819 : : * (intermediate)[in]
820 : : * / \
821 : : * (new leaf node)[ln] (old node)[fn]
822 : : */
823 [ + - ]: 218 : if (plen > bit) {
824 : 218 : in = node_alloc(net);
825 : 218 : ln = node_alloc(net);
826 : :
827 [ - + ]: 218 : if (!in || !ln) {
828 [ # # ]: 0 : if (in)
829 : : node_free_immediate(net, in);
830 [ # # ]: 0 : if (ln)
831 : : node_free_immediate(net, ln);
832 : : return ERR_PTR(-ENOMEM);
833 : : }
834 : :
835 : : /*
836 : : * new intermediate node.
837 : : * RTN_RTINFO will
838 : : * be off since that an address that chooses one of
839 : : * the branches would not match less specific routes
840 : : * in the other branch
841 : : */
842 : :
843 : 218 : in->fn_bit = bit;
844 : :
845 : 218 : RCU_INIT_POINTER(in->parent, pn);
846 : 218 : in->leaf = fn->leaf;
847 : : fib6_info_hold(rcu_dereference_protected(in->leaf,
848 : : lockdep_is_held(&table->tb6_lock)));
849 : :
850 : : /* update parent pointer */
851 [ + - ]: 218 : if (dir)
852 : 218 : rcu_assign_pointer(pn->right, in);
853 : : else
854 : 0 : rcu_assign_pointer(pn->left, in);
855 : :
856 : 218 : ln->fn_bit = plen;
857 : :
858 : 218 : RCU_INIT_POINTER(ln->parent, in);
859 : 218 : rcu_assign_pointer(fn->parent, in);
860 : :
861 [ - + ]: 218 : if (addr_bit_set(addr, bit)) {
862 : 0 : rcu_assign_pointer(in->right, ln);
863 : 0 : rcu_assign_pointer(in->left, fn);
864 : : } else {
865 : 218 : rcu_assign_pointer(in->left, ln);
866 : 218 : rcu_assign_pointer(in->right, fn);
867 : : }
868 : : } else { /* plen <= bit */
869 : :
870 : : /*
871 : : * (new leaf node)[ln]
872 : : * / \
873 : : * (old node)[fn] NULL
874 : : */
875 : :
876 : 0 : ln = node_alloc(net);
877 : :
878 [ # # ]: 0 : if (!ln)
879 : : return ERR_PTR(-ENOMEM);
880 : :
881 : 0 : ln->fn_bit = plen;
882 : :
883 : 0 : RCU_INIT_POINTER(ln->parent, pn);
884 : :
885 [ # # ]: 0 : if (addr_bit_set(&key->addr, plen))
886 : 0 : RCU_INIT_POINTER(ln->right, fn);
887 : : else
888 : 0 : RCU_INIT_POINTER(ln->left, fn);
889 : :
890 : 0 : rcu_assign_pointer(fn->parent, ln);
891 : :
892 [ # # ]: 0 : if (dir)
893 : 0 : rcu_assign_pointer(pn->right, ln);
894 : : else
895 : 0 : rcu_assign_pointer(pn->left, ln);
896 : : }
897 : 218 : return ln;
898 : : }
899 : :
900 : 218 : static void __fib6_drop_pcpu_from(struct fib6_nh *fib6_nh,
901 : : const struct fib6_info *match,
902 : : const struct fib6_table *table)
903 : : {
904 : : int cpu;
905 : :
906 [ + - ]: 218 : if (!fib6_nh->rt6i_pcpu)
907 : 218 : return;
908 : :
909 : : /* release the reference to this fib entry from
910 : : * all of its cached pcpu routes
911 : : */
912 [ + + ]: 1090 : for_each_possible_cpu(cpu) {
913 : : struct rt6_info **ppcpu_rt;
914 : : struct rt6_info *pcpu_rt;
915 : :
916 : 872 : ppcpu_rt = per_cpu_ptr(fib6_nh->rt6i_pcpu, cpu);
917 : 872 : pcpu_rt = *ppcpu_rt;
918 : :
919 : : /* only dropping the 'from' reference if the cached route
920 : : * is using 'match'. The cached pcpu_rt->from only changes
921 : : * from a fib6_info to NULL (ip6_dst_destroy); it can never
922 : : * change from one fib6_info reference to another
923 : : */
924 [ - + # # ]: 872 : if (pcpu_rt && rcu_access_pointer(pcpu_rt->from) == match) {
925 : : struct fib6_info *from;
926 : :
927 : 0 : from = xchg((__force struct fib6_info **)&pcpu_rt->from, NULL);
928 : 0 : fib6_info_release(from);
929 : : }
930 : : }
931 : : }
932 : :
933 : : struct fib6_nh_pcpu_arg {
934 : : struct fib6_info *from;
935 : : const struct fib6_table *table;
936 : : };
937 : :
938 : 0 : static int fib6_nh_drop_pcpu_from(struct fib6_nh *nh, void *_arg)
939 : : {
940 : : struct fib6_nh_pcpu_arg *arg = _arg;
941 : :
942 : 0 : __fib6_drop_pcpu_from(nh, arg->from, arg->table);
943 : 0 : return 0;
944 : : }
945 : :
946 : 218 : static void fib6_drop_pcpu_from(struct fib6_info *f6i,
947 : : const struct fib6_table *table)
948 : : {
949 : : /* Make sure rt6_make_pcpu_route() wont add other percpu routes
950 : : * while we are cleaning them here.
951 : : */
952 : 218 : f6i->fib6_destroying = 1;
953 : 218 : mb(); /* paired with the cmpxchg() in rt6_make_pcpu_route() */
954 : :
955 [ - + ]: 218 : if (f6i->nh) {
956 : 0 : struct fib6_nh_pcpu_arg arg = {
957 : : .from = f6i,
958 : : .table = table
959 : : };
960 : :
961 : 0 : nexthop_for_each_fib6_nh(f6i->nh, fib6_nh_drop_pcpu_from,
962 : : &arg);
963 : : } else {
964 : : struct fib6_nh *fib6_nh;
965 : :
966 : 218 : fib6_nh = f6i->fib6_nh;
967 : 218 : __fib6_drop_pcpu_from(fib6_nh, f6i, table);
968 : : }
969 : 218 : }
970 : :
971 : 218 : static void fib6_purge_rt(struct fib6_info *rt, struct fib6_node *fn,
972 : : struct net *net)
973 : : {
974 : 218 : struct fib6_table *table = rt->fib6_table;
975 : :
976 : 218 : fib6_drop_pcpu_from(rt, table);
977 : :
978 [ - + # # ]: 218 : if (rt->nh && !list_empty(&rt->nh_list))
979 : : list_del_init(&rt->nh_list);
980 : :
981 [ + - ]: 218 : if (refcount_read(&rt->fib6_ref) != 1) {
982 : : /* This route is used as dummy address holder in some split
983 : : * nodes. It is not leaked, but it still holds other resources,
984 : : * which must be released in time. So, scan ascendant nodes
985 : : * and replace dummy references to this route with references
986 : : * to still alive ones.
987 : : */
988 [ + + ]: 436 : while (fn) {
989 : 218 : struct fib6_info *leaf = rcu_dereference_protected(fn->leaf,
990 : : lockdep_is_held(&table->tb6_lock));
991 : : struct fib6_info *new_leaf;
992 [ - + # # ]: 218 : if (!(fn->fn_flags & RTN_RTINFO) && leaf == rt) {
993 : : new_leaf = fib6_find_prefix(net, table, fn);
994 : : fib6_info_hold(new_leaf);
995 : :
996 : 0 : rcu_assign_pointer(fn->leaf, new_leaf);
997 : 0 : fib6_info_release(rt);
998 : : }
999 : 218 : fn = rcu_dereference_protected(fn->parent,
1000 : : lockdep_is_held(&table->tb6_lock));
1001 : : }
1002 : : }
1003 : 218 : }
1004 : :
1005 : : /*
1006 : : * Insert routing information in a node.
1007 : : */
1008 : :
1009 : 1667 : static int fib6_add_rt2node(struct fib6_node *fn, struct fib6_info *rt,
1010 : : struct nl_info *info,
1011 : : struct netlink_ext_ack *extack)
1012 : : {
1013 : 1667 : struct fib6_info *leaf = rcu_dereference_protected(fn->leaf,
1014 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1015 : : struct fib6_info *iter = NULL;
1016 : : struct fib6_info __rcu **ins;
1017 : : struct fib6_info __rcu **fallback_ins = NULL;
1018 [ - + # # ]: 1667 : int replace = (info->nlh &&
1019 : 0 : (info->nlh->nlmsg_flags & NLM_F_REPLACE));
1020 [ - + # # ]: 1667 : int add = (!info->nlh ||
1021 : 0 : (info->nlh->nlmsg_flags & NLM_F_CREATE));
1022 : : int found = 0;
1023 : : bool rt_can_ecmp = rt6_qualify_for_ecmp(rt);
1024 : : u16 nlflags = NLM_F_EXCL;
1025 : : int err;
1026 : :
1027 [ - + # # ]: 1667 : if (info->nlh && (info->nlh->nlmsg_flags & NLM_F_APPEND))
1028 : : nlflags |= NLM_F_APPEND;
1029 : :
1030 : 1667 : ins = &fn->leaf;
1031 : :
1032 [ + + ]: 3334 : for (iter = leaf; iter;
1033 : 0 : iter = rcu_dereference_protected(iter->fib6_next,
1034 : : lockdep_is_held(&rt->fib6_table->tb6_lock))) {
1035 : : /*
1036 : : * Search for duplicates
1037 : : */
1038 : :
1039 [ + - ]: 414 : if (iter->fib6_metric == rt->fib6_metric) {
1040 : : /*
1041 : : * Same priority level
1042 : : */
1043 [ - + # # ]: 414 : if (info->nlh &&
1044 : 0 : (info->nlh->nlmsg_flags & NLM_F_EXCL))
1045 : : return -EEXIST;
1046 : :
1047 : 414 : nlflags &= ~NLM_F_EXCL;
1048 [ - + ]: 414 : if (replace) {
1049 [ # # ]: 0 : if (rt_can_ecmp == rt6_qualify_for_ecmp(iter)) {
1050 : : found++;
1051 : : break;
1052 : : }
1053 [ # # ]: 0 : fallback_ins = fallback_ins ?: ins;
1054 : 0 : goto next_iter;
1055 : : }
1056 : :
1057 [ + - ]: 414 : if (rt6_duplicate_nexthop(iter, rt)) {
1058 [ - + ]: 414 : if (rt->fib6_nsiblings)
1059 : 0 : rt->fib6_nsiblings = 0;
1060 [ - + ]: 414 : if (!(iter->fib6_flags & RTF_EXPIRES))
1061 : : return -EEXIST;
1062 [ # # ]: 0 : if (!(rt->fib6_flags & RTF_EXPIRES))
1063 : : fib6_clean_expires(iter);
1064 : : else
1065 : 0 : fib6_set_expires(iter, rt->expires);
1066 : :
1067 [ # # ]: 0 : if (rt->fib6_pmtu)
1068 : 0 : fib6_metric_set(iter, RTAX_MTU,
1069 : : rt->fib6_pmtu);
1070 : : return -EEXIST;
1071 : : }
1072 : : /* If we have the same destination and the same metric,
1073 : : * but not the same gateway, then the route we try to
1074 : : * add is sibling to this route, increment our counter
1075 : : * of siblings, and later we will add our route to the
1076 : : * list.
1077 : : * Only static routes (which don't have flag
1078 : : * RTF_EXPIRES) are used for ECMPv6.
1079 : : *
1080 : : * To avoid long list, we only had siblings if the
1081 : : * route have a gateway.
1082 : : */
1083 [ # # # # ]: 0 : if (rt_can_ecmp &&
1084 : : rt6_qualify_for_ecmp(iter))
1085 : 0 : rt->fib6_nsiblings++;
1086 : : }
1087 : :
1088 [ # # ]: 0 : if (iter->fib6_metric > rt->fib6_metric)
1089 : : break;
1090 : :
1091 : : next_iter:
1092 : 0 : ins = &iter->fib6_next;
1093 : : }
1094 : :
1095 [ - + ]: 1253 : if (fallback_ins && !found) {
1096 : : /* No matching route with same ecmp-able-ness found, replace
1097 : : * first matching route
1098 : : */
1099 : 0 : ins = fallback_ins;
1100 : 0 : iter = rcu_dereference_protected(*ins,
1101 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1102 : 0 : found++;
1103 : : }
1104 : :
1105 : : /* Reset round-robin state, if necessary */
1106 [ + - ]: 1253 : if (ins == &fn->leaf)
1107 : 1253 : fn->rr_ptr = NULL;
1108 : :
1109 : : /* Link this route to others same route. */
1110 [ - + ]: 1253 : if (rt->fib6_nsiblings) {
1111 : : unsigned int fib6_nsiblings;
1112 : : struct fib6_info *sibling, *temp_sibling;
1113 : :
1114 : : /* Find the first route that have the same metric */
1115 : : sibling = leaf;
1116 [ # # ]: 0 : while (sibling) {
1117 [ # # # # ]: 0 : if (sibling->fib6_metric == rt->fib6_metric &&
1118 : : rt6_qualify_for_ecmp(sibling)) {
1119 : 0 : list_add_tail(&rt->fib6_siblings,
1120 : : &sibling->fib6_siblings);
1121 : : break;
1122 : : }
1123 : 0 : sibling = rcu_dereference_protected(sibling->fib6_next,
1124 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1125 : : }
1126 : : /* For each sibling in the list, increment the counter of
1127 : : * siblings. BUG() if counters does not match, list of siblings
1128 : : * is broken!
1129 : : */
1130 : : fib6_nsiblings = 0;
1131 [ # # ]: 0 : list_for_each_entry_safe(sibling, temp_sibling,
1132 : : &rt->fib6_siblings, fib6_siblings) {
1133 : 0 : sibling->fib6_nsiblings++;
1134 [ # # ]: 0 : BUG_ON(sibling->fib6_nsiblings != rt->fib6_nsiblings);
1135 : 0 : fib6_nsiblings++;
1136 : : }
1137 [ # # ]: 0 : BUG_ON(fib6_nsiblings != rt->fib6_nsiblings);
1138 : 0 : rt6_multipath_rebalance(temp_sibling);
1139 : : }
1140 : :
1141 : : /*
1142 : : * insert node
1143 : : */
1144 [ + - ]: 1253 : if (!replace) {
1145 [ - + ]: 1253 : if (!add)
1146 : 0 : pr_warn("NLM_F_CREATE should be set when creating new route\n");
1147 : :
1148 : : add:
1149 : 1253 : nlflags |= NLM_F_CREATE;
1150 : :
1151 [ + - ]: 1253 : if (!info->skip_notify_kernel) {
1152 : 1253 : err = call_fib6_entry_notifiers(info->nl_net,
1153 : : FIB_EVENT_ENTRY_ADD,
1154 : : rt, extack);
1155 [ - + ]: 1253 : if (err) {
1156 : : struct fib6_info *sibling, *next_sibling;
1157 : :
1158 : : /* If the route has siblings, then it first
1159 : : * needs to be unlinked from them.
1160 : : */
1161 [ # # ]: 0 : if (!rt->fib6_nsiblings)
1162 : : return err;
1163 : :
1164 [ # # ]: 0 : list_for_each_entry_safe(sibling, next_sibling,
1165 : : &rt->fib6_siblings,
1166 : : fib6_siblings)
1167 : 0 : sibling->fib6_nsiblings--;
1168 : 0 : rt->fib6_nsiblings = 0;
1169 : 0 : list_del_init(&rt->fib6_siblings);
1170 : 0 : rt6_multipath_rebalance(next_sibling);
1171 : 0 : return err;
1172 : : }
1173 : : }
1174 : :
1175 : 1253 : rcu_assign_pointer(rt->fib6_next, iter);
1176 : : fib6_info_hold(rt);
1177 : 1253 : rcu_assign_pointer(rt->fib6_node, fn);
1178 : 1253 : rcu_assign_pointer(*ins, rt);
1179 [ + - ]: 1253 : if (!info->skip_notify)
1180 : 1253 : inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
1181 : 1253 : info->nl_net->ipv6.rt6_stats->fib_rt_entries++;
1182 : :
1183 [ + - ]: 1253 : if (!(fn->fn_flags & RTN_RTINFO)) {
1184 : 1253 : info->nl_net->ipv6.rt6_stats->fib_route_nodes++;
1185 : 1253 : fn->fn_flags |= RTN_RTINFO;
1186 : : }
1187 : :
1188 : : } else {
1189 : : int nsiblings;
1190 : :
1191 [ # # ]: 0 : if (!found) {
1192 [ # # ]: 0 : if (add)
1193 : : goto add;
1194 : 0 : pr_warn("NLM_F_REPLACE set, but no existing node found!\n");
1195 : 0 : return -ENOENT;
1196 : : }
1197 : :
1198 [ # # ]: 0 : if (!info->skip_notify_kernel) {
1199 : 0 : err = call_fib6_entry_notifiers(info->nl_net,
1200 : : FIB_EVENT_ENTRY_REPLACE,
1201 : : rt, extack);
1202 [ # # ]: 0 : if (err)
1203 : : return err;
1204 : : }
1205 : :
1206 : : fib6_info_hold(rt);
1207 : 0 : rcu_assign_pointer(rt->fib6_node, fn);
1208 : 0 : rt->fib6_next = iter->fib6_next;
1209 : 0 : rcu_assign_pointer(*ins, rt);
1210 [ # # ]: 0 : if (!info->skip_notify)
1211 : 0 : inet6_rt_notify(RTM_NEWROUTE, rt, info, NLM_F_REPLACE);
1212 [ # # ]: 0 : if (!(fn->fn_flags & RTN_RTINFO)) {
1213 : 0 : info->nl_net->ipv6.rt6_stats->fib_route_nodes++;
1214 : 0 : fn->fn_flags |= RTN_RTINFO;
1215 : : }
1216 : 0 : nsiblings = iter->fib6_nsiblings;
1217 : 0 : iter->fib6_node = NULL;
1218 : 0 : fib6_purge_rt(iter, fn, info->nl_net);
1219 [ # # ]: 0 : if (rcu_access_pointer(fn->rr_ptr) == iter)
1220 : 0 : fn->rr_ptr = NULL;
1221 : 0 : fib6_info_release(iter);
1222 : :
1223 [ # # ]: 0 : if (nsiblings) {
1224 : : /* Replacing an ECMP route, remove all siblings */
1225 : 0 : ins = &rt->fib6_next;
1226 : 0 : iter = rcu_dereference_protected(*ins,
1227 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1228 [ # # ]: 0 : while (iter) {
1229 [ # # ]: 0 : if (iter->fib6_metric > rt->fib6_metric)
1230 : : break;
1231 [ # # ]: 0 : if (rt6_qualify_for_ecmp(iter)) {
1232 : 0 : *ins = iter->fib6_next;
1233 : 0 : iter->fib6_node = NULL;
1234 : 0 : fib6_purge_rt(iter, fn, info->nl_net);
1235 [ # # ]: 0 : if (rcu_access_pointer(fn->rr_ptr) == iter)
1236 : 0 : fn->rr_ptr = NULL;
1237 : 0 : fib6_info_release(iter);
1238 : 0 : nsiblings--;
1239 : 0 : info->nl_net->ipv6.rt6_stats->fib_rt_entries--;
1240 : : } else {
1241 : 0 : ins = &iter->fib6_next;
1242 : : }
1243 : 0 : iter = rcu_dereference_protected(*ins,
1244 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1245 : : }
1246 [ # # ]: 0 : WARN_ON(nsiblings != 0);
1247 : : }
1248 : : }
1249 : :
1250 : : return 0;
1251 : : }
1252 : :
1253 : 1253 : static void fib6_start_gc(struct net *net, struct fib6_info *rt)
1254 : : {
1255 [ + - - + ]: 2506 : if (!timer_pending(&net->ipv6.ip6_fib_timer) &&
1256 : 1253 : (rt->fib6_flags & RTF_EXPIRES))
1257 : 0 : mod_timer(&net->ipv6.ip6_fib_timer,
1258 : 0 : jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
1259 : 1253 : }
1260 : :
1261 : 0 : void fib6_force_start_gc(struct net *net)
1262 : : {
1263 [ # # ]: 0 : if (!timer_pending(&net->ipv6.ip6_fib_timer))
1264 : 0 : mod_timer(&net->ipv6.ip6_fib_timer,
1265 : 0 : jiffies + net->ipv6.sysctl.ip6_rt_gc_interval);
1266 : 0 : }
1267 : :
1268 : : static void __fib6_update_sernum_upto_root(struct fib6_info *rt,
1269 : : int sernum)
1270 : : {
1271 : 2473 : struct fib6_node *fn = rcu_dereference_protected(rt->fib6_node,
1272 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1273 : :
1274 : : /* paired with smp_rmb() in rt6_get_cookie_safe() */
1275 : 2473 : smp_wmb();
1276 [ + + + + ]: 7637 : while (fn) {
1277 : 5164 : fn->fn_sernum = sernum;
1278 : 5164 : fn = rcu_dereference_protected(fn->parent,
1279 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1280 : : }
1281 : : }
1282 : :
1283 : 1220 : void fib6_update_sernum_upto_root(struct net *net, struct fib6_info *rt)
1284 : : {
1285 : 1220 : __fib6_update_sernum_upto_root(rt, fib6_new_sernum(net));
1286 : 1220 : }
1287 : :
1288 : : /* allow ipv4 to update sernum via ipv6_stub */
1289 : 0 : void fib6_update_sernum_stub(struct net *net, struct fib6_info *f6i)
1290 : : {
1291 : 0 : spin_lock_bh(&f6i->fib6_table->tb6_lock);
1292 : 0 : fib6_update_sernum_upto_root(net, f6i);
1293 : 0 : spin_unlock_bh(&f6i->fib6_table->tb6_lock);
1294 : 0 : }
1295 : :
1296 : : /*
1297 : : * Add routing information to the routing tree.
1298 : : * <destination addr>/<source addr>
1299 : : * with source addr info in sub-trees
1300 : : * Need to own table->tb6_lock
1301 : : */
1302 : :
1303 : 1667 : int fib6_add(struct fib6_node *root, struct fib6_info *rt,
1304 : : struct nl_info *info, struct netlink_ext_ack *extack)
1305 : : {
1306 : 1667 : struct fib6_table *table = rt->fib6_table;
1307 : : struct fib6_node *fn, *pn = NULL;
1308 : : int err = -ENOMEM;
1309 : : int allow_create = 1;
1310 : : int replace_required = 0;
1311 : 1667 : int sernum = fib6_new_sernum(info->nl_net);
1312 : :
1313 [ - + ]: 1667 : if (info->nlh) {
1314 [ # # ]: 0 : if (!(info->nlh->nlmsg_flags & NLM_F_CREATE))
1315 : : allow_create = 0;
1316 [ # # ]: 0 : if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
1317 : : replace_required = 1;
1318 : : }
1319 [ - + ]: 1667 : if (!allow_create && !replace_required)
1320 : 0 : pr_warn("RTM_NEWROUTE with no NLM_F_CREATE or NLM_F_REPLACE\n");
1321 : :
1322 : 1667 : fn = fib6_add_1(info->nl_net, table, root,
1323 : : &rt->fib6_dst.addr, rt->fib6_dst.plen,
1324 : : offsetof(struct fib6_info, fib6_dst), allow_create,
1325 : : replace_required, extack);
1326 [ - + ]: 1667 : if (IS_ERR(fn)) {
1327 : : err = PTR_ERR(fn);
1328 : : fn = NULL;
1329 : 0 : goto out;
1330 : : }
1331 : :
1332 : : pn = fn;
1333 : :
1334 : : #ifdef CONFIG_IPV6_SUBTREES
1335 [ - + ]: 1667 : if (rt->fib6_src.plen) {
1336 : : struct fib6_node *sn;
1337 : :
1338 [ # # ]: 0 : if (!rcu_access_pointer(fn->subtree)) {
1339 : : struct fib6_node *sfn;
1340 : :
1341 : : /*
1342 : : * Create subtree.
1343 : : *
1344 : : * fn[main tree]
1345 : : * |
1346 : : * sfn[subtree root]
1347 : : * \
1348 : : * sn[new leaf node]
1349 : : */
1350 : :
1351 : : /* Create subtree root node */
1352 : 0 : sfn = node_alloc(info->nl_net);
1353 [ # # ]: 0 : if (!sfn)
1354 : : goto failure;
1355 : :
1356 : 0 : fib6_info_hold(info->nl_net->ipv6.fib6_null_entry);
1357 : 0 : rcu_assign_pointer(sfn->leaf,
1358 : : info->nl_net->ipv6.fib6_null_entry);
1359 : 0 : sfn->fn_flags = RTN_ROOT;
1360 : :
1361 : : /* Now add the first leaf node to new subtree */
1362 : :
1363 : 0 : sn = fib6_add_1(info->nl_net, table, sfn,
1364 : : &rt->fib6_src.addr, rt->fib6_src.plen,
1365 : : offsetof(struct fib6_info, fib6_src),
1366 : : allow_create, replace_required, extack);
1367 : :
1368 [ # # ]: 0 : if (IS_ERR(sn)) {
1369 : : /* If it is failed, discard just allocated
1370 : : root, and then (in failure) stale node
1371 : : in main tree.
1372 : : */
1373 : 0 : node_free_immediate(info->nl_net, sfn);
1374 : : err = PTR_ERR(sn);
1375 : 0 : goto failure;
1376 : : }
1377 : :
1378 : : /* Now link new subtree to main tree */
1379 : 0 : rcu_assign_pointer(sfn->parent, fn);
1380 : 0 : rcu_assign_pointer(fn->subtree, sfn);
1381 : : } else {
1382 : 0 : sn = fib6_add_1(info->nl_net, table, FIB6_SUBTREE(fn),
1383 : : &rt->fib6_src.addr, rt->fib6_src.plen,
1384 : : offsetof(struct fib6_info, fib6_src),
1385 : : allow_create, replace_required, extack);
1386 : :
1387 [ # # ]: 0 : if (IS_ERR(sn)) {
1388 : : err = PTR_ERR(sn);
1389 : 0 : goto failure;
1390 : : }
1391 : : }
1392 : :
1393 [ # # ]: 0 : if (!rcu_access_pointer(fn->leaf)) {
1394 [ # # ]: 0 : if (fn->fn_flags & RTN_TL_ROOT) {
1395 : : /* put back null_entry for root node */
1396 : 0 : rcu_assign_pointer(fn->leaf,
1397 : : info->nl_net->ipv6.fib6_null_entry);
1398 : : } else {
1399 : : fib6_info_hold(rt);
1400 : 0 : rcu_assign_pointer(fn->leaf, rt);
1401 : : }
1402 : : }
1403 : : fn = sn;
1404 : : }
1405 : : #endif
1406 : :
1407 : 1667 : err = fib6_add_rt2node(fn, rt, info, extack);
1408 [ + + ]: 1667 : if (!err) {
1409 [ - + ]: 1253 : if (rt->nh)
1410 : 0 : list_add(&rt->nh_list, &rt->nh->f6i_list);
1411 : : __fib6_update_sernum_upto_root(rt, sernum);
1412 : 1253 : fib6_start_gc(info->nl_net, rt);
1413 : : }
1414 : :
1415 : : out:
1416 [ + + ]: 1667 : if (err) {
1417 : : #ifdef CONFIG_IPV6_SUBTREES
1418 : : /*
1419 : : * If fib6_add_1 has cleared the old leaf pointer in the
1420 : : * super-tree leaf node we have to find a new one for it.
1421 : : */
1422 [ - + ]: 414 : if (pn != fn) {
1423 : : struct fib6_info *pn_leaf =
1424 : 0 : rcu_dereference_protected(pn->leaf,
1425 : : lockdep_is_held(&table->tb6_lock));
1426 [ # # ]: 0 : if (pn_leaf == rt) {
1427 : : pn_leaf = NULL;
1428 : : RCU_INIT_POINTER(pn->leaf, NULL);
1429 : 0 : fib6_info_release(rt);
1430 : : }
1431 [ # # # # ]: 0 : if (!pn_leaf && !(pn->fn_flags & RTN_RTINFO)) {
1432 : 0 : pn_leaf = fib6_find_prefix(info->nl_net, table,
1433 : : pn);
1434 : : #if RT6_DEBUG >= 2
1435 [ # # ]: 0 : if (!pn_leaf) {
1436 [ # # ]: 0 : WARN_ON(!pn_leaf);
1437 : 0 : pn_leaf =
1438 : 0 : info->nl_net->ipv6.fib6_null_entry;
1439 : : }
1440 : : #endif
1441 : : fib6_info_hold(pn_leaf);
1442 : 0 : rcu_assign_pointer(pn->leaf, pn_leaf);
1443 : : }
1444 : : }
1445 : : #endif
1446 : : goto failure;
1447 : : }
1448 : : return err;
1449 : :
1450 : : failure:
1451 : : /* fn->leaf could be NULL and fib6_repair_tree() needs to be called if:
1452 : : * 1. fn is an intermediate node and we failed to add the new
1453 : : * route to it in both subtree creation failure and fib6_add_rt2node()
1454 : : * failure case.
1455 : : * 2. fn is the root node in the table and we fail to add the first
1456 : : * default route to it.
1457 : : */
1458 [ + - + - ]: 828 : if (fn &&
1459 [ - + ]: 828 : (!(fn->fn_flags & (RTN_RTINFO|RTN_ROOT)) ||
1460 [ # # ]: 414 : (fn->fn_flags & RTN_TL_ROOT &&
1461 : 0 : !rcu_access_pointer(fn->leaf))))
1462 : 0 : fib6_repair_tree(info->nl_net, table, fn);
1463 : 414 : return err;
1464 : : }
1465 : :
1466 : : /*
1467 : : * Routing tree lookup
1468 : : *
1469 : : */
1470 : :
1471 : : struct lookup_args {
1472 : : int offset; /* key offset on fib6_info */
1473 : : const struct in6_addr *addr; /* search key */
1474 : : };
1475 : :
1476 : 5092 : static struct fib6_node *fib6_node_lookup_1(struct fib6_node *root,
1477 : : struct lookup_args *args)
1478 : : {
1479 : : struct fib6_node *fn;
1480 : : __be32 dir;
1481 : :
1482 [ + - ]: 5092 : if (unlikely(args->offset == 0))
1483 : : return NULL;
1484 : :
1485 : : /*
1486 : : * Descend on a tree
1487 : : */
1488 : :
1489 : : fn = root;
1490 : :
1491 : : for (;;) {
1492 : : struct fib6_node *next;
1493 : :
1494 : 11961 : dir = addr_bit_set(args->addr, fn->fn_bit);
1495 : :
1496 [ + + ]: 17174 : next = dir ? rcu_dereference(fn->right) :
1497 : 6748 : rcu_dereference(fn->left);
1498 : :
1499 [ + + ]: 11961 : if (next) {
1500 : : fn = next;
1501 : 6869 : continue;
1502 : : }
1503 : : break;
1504 : 6869 : }
1505 : :
1506 [ + - ]: 8404 : while (fn) {
1507 : 8404 : struct fib6_node *subtree = FIB6_SUBTREE(fn);
1508 : :
1509 [ + - + - ]: 8404 : if (subtree || fn->fn_flags & RTN_RTINFO) {
1510 : 8404 : struct fib6_info *leaf = rcu_dereference(fn->leaf);
1511 : : struct rt6key *key;
1512 : :
1513 [ + - ]: 8404 : if (!leaf)
1514 : : goto backtrack;
1515 : :
1516 : 8404 : key = (struct rt6key *) ((u8 *)leaf + args->offset);
1517 : :
1518 [ + + ]: 8404 : if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) {
1519 : : #ifdef CONFIG_IPV6_SUBTREES
1520 [ - + ]: 5092 : if (subtree) {
1521 : : struct fib6_node *sfn;
1522 : 0 : sfn = fib6_node_lookup_1(subtree,
1523 : : args + 1);
1524 [ # # ]: 0 : if (!sfn)
1525 : : goto backtrack;
1526 : : fn = sfn;
1527 : : }
1528 : : #endif
1529 [ + - ]: 5092 : if (fn->fn_flags & RTN_RTINFO)
1530 : 5092 : return fn;
1531 : : }
1532 : : }
1533 : : backtrack:
1534 [ + - ]: 3312 : if (fn->fn_flags & RTN_ROOT)
1535 : : break;
1536 : :
1537 : 3312 : fn = rcu_dereference(fn->parent);
1538 : : }
1539 : :
1540 : : return NULL;
1541 : : }
1542 : :
1543 : : /* called with rcu_read_lock() held
1544 : : */
1545 : 5092 : struct fib6_node *fib6_node_lookup(struct fib6_node *root,
1546 : : const struct in6_addr *daddr,
1547 : : const struct in6_addr *saddr)
1548 : : {
1549 : : struct fib6_node *fn;
1550 : 5092 : struct lookup_args args[] = {
1551 : : {
1552 : : .offset = offsetof(struct fib6_info, fib6_dst),
1553 : : .addr = daddr,
1554 : : },
1555 : : #ifdef CONFIG_IPV6_SUBTREES
1556 : : {
1557 : : .offset = offsetof(struct fib6_info, fib6_src),
1558 : : .addr = saddr,
1559 : : },
1560 : : #endif
1561 : : {
1562 : : .offset = 0, /* sentinel */
1563 : : }
1564 : : };
1565 : :
1566 [ - + ]: 5092 : fn = fib6_node_lookup_1(root, daddr ? args : args + 1);
1567 [ + - + + ]: 5092 : if (!fn || fn->fn_flags & RTN_TL_ROOT)
1568 : : fn = root;
1569 : :
1570 : 5092 : return fn;
1571 : : }
1572 : :
1573 : : /*
1574 : : * Get node with specified destination prefix (and source prefix,
1575 : : * if subtrees are used)
1576 : : * exact_match == true means we try to find fn with exact match of
1577 : : * the passed in prefix addr
1578 : : * exact_match == false means we try to find fn with longest prefix
1579 : : * match of the passed in prefix addr. This is useful for finding fn
1580 : : * for cached route as it will be stored in the exception table under
1581 : : * the node with longest prefix length.
1582 : : */
1583 : :
1584 : :
1585 : 207 : static struct fib6_node *fib6_locate_1(struct fib6_node *root,
1586 : : const struct in6_addr *addr,
1587 : : int plen, int offset,
1588 : : bool exact_match)
1589 : : {
1590 : : struct fib6_node *fn, *prev = NULL;
1591 : :
1592 [ + - ]: 621 : for (fn = root; fn ; ) {
1593 : 414 : struct fib6_info *leaf = rcu_dereference(fn->leaf);
1594 : : struct rt6key *key;
1595 : :
1596 : : /* This node is being deleted */
1597 [ - + ]: 414 : if (!leaf) {
1598 [ # # ]: 0 : if (plen <= fn->fn_bit)
1599 : : goto out;
1600 : : else
1601 : : goto next;
1602 : : }
1603 : :
1604 : 414 : key = (struct rt6key *)((u8 *)leaf + offset);
1605 : :
1606 : : /*
1607 : : * Prefix match
1608 : : */
1609 [ + - + - ]: 828 : if (plen < fn->fn_bit ||
1610 : 414 : !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit))
1611 : : goto out;
1612 : :
1613 [ + + ]: 414 : if (plen == fn->fn_bit)
1614 : 207 : return fn;
1615 : :
1616 [ + - ]: 207 : if (fn->fn_flags & RTN_RTINFO)
1617 : : prev = fn;
1618 : :
1619 : : next:
1620 : : /*
1621 : : * We have more bits to go
1622 : : */
1623 [ + - ]: 414 : if (addr_bit_set(addr, fn->fn_bit))
1624 : 207 : fn = rcu_dereference(fn->right);
1625 : : else
1626 : 0 : fn = rcu_dereference(fn->left);
1627 : : }
1628 : : out:
1629 [ # # ]: 0 : if (exact_match)
1630 : : return NULL;
1631 : : else
1632 : 0 : return prev;
1633 : : }
1634 : :
1635 : 207 : struct fib6_node *fib6_locate(struct fib6_node *root,
1636 : : const struct in6_addr *daddr, int dst_len,
1637 : : const struct in6_addr *saddr, int src_len,
1638 : : bool exact_match)
1639 : : {
1640 : : struct fib6_node *fn;
1641 : :
1642 : 207 : fn = fib6_locate_1(root, daddr, dst_len,
1643 : : offsetof(struct fib6_info, fib6_dst),
1644 : : exact_match);
1645 : :
1646 : : #ifdef CONFIG_IPV6_SUBTREES
1647 [ - + ]: 207 : if (src_len) {
1648 [ # # ]: 0 : WARN_ON(saddr == NULL);
1649 [ # # ]: 0 : if (fn) {
1650 : 0 : struct fib6_node *subtree = FIB6_SUBTREE(fn);
1651 : :
1652 [ # # ]: 0 : if (subtree) {
1653 : 0 : fn = fib6_locate_1(subtree, saddr, src_len,
1654 : : offsetof(struct fib6_info, fib6_src),
1655 : : exact_match);
1656 : : }
1657 : : }
1658 : : }
1659 : : #endif
1660 : :
1661 [ + - + - ]: 207 : if (fn && fn->fn_flags & RTN_RTINFO)
1662 : 207 : return fn;
1663 : :
1664 : : return NULL;
1665 : : }
1666 : :
1667 : :
1668 : : /*
1669 : : * Deletion
1670 : : *
1671 : : */
1672 : :
1673 : : static struct fib6_info *fib6_find_prefix(struct net *net,
1674 : : struct fib6_table *table,
1675 : : struct fib6_node *fn)
1676 : : {
1677 : : struct fib6_node *child_left, *child_right;
1678 : :
1679 [ # # # # : 0 : if (fn->fn_flags & RTN_ROOT)
# # ]
1680 : 0 : return net->ipv6.fib6_null_entry;
1681 : :
1682 [ # # # # : 0 : while (fn) {
# # ]
1683 : 0 : child_left = rcu_dereference_protected(fn->left,
1684 : : lockdep_is_held(&table->tb6_lock));
1685 : 0 : child_right = rcu_dereference_protected(fn->right,
1686 : : lockdep_is_held(&table->tb6_lock));
1687 [ # # # # : 0 : if (child_left)
# # ]
1688 : 0 : return rcu_dereference_protected(child_left->leaf,
1689 : : lockdep_is_held(&table->tb6_lock));
1690 [ # # # # : 0 : if (child_right)
# # ]
1691 : 0 : return rcu_dereference_protected(child_right->leaf,
1692 : : lockdep_is_held(&table->tb6_lock));
1693 : :
1694 : 0 : fn = FIB6_SUBTREE(fn);
1695 : : }
1696 : : return NULL;
1697 : : }
1698 : :
1699 : : /*
1700 : : * Called to trim the tree of intermediate nodes when possible. "fn"
1701 : : * is the node we want to try and remove.
1702 : : * Need to own table->tb6_lock
1703 : : */
1704 : :
1705 : 218 : static struct fib6_node *fib6_repair_tree(struct net *net,
1706 : : struct fib6_table *table,
1707 : : struct fib6_node *fn)
1708 : : {
1709 : : int children;
1710 : : int nstate;
1711 : : struct fib6_node *child;
1712 : : struct fib6_walker *w;
1713 : : int iter = 0;
1714 : :
1715 : : /* Set fn->leaf to null_entry for root node. */
1716 [ + - ]: 218 : if (fn->fn_flags & RTN_TL_ROOT) {
1717 : 0 : rcu_assign_pointer(fn->leaf, net->ipv6.fib6_null_entry);
1718 : 0 : return fn;
1719 : : }
1720 : :
1721 : : for (;;) {
1722 : 229 : struct fib6_node *fn_r = rcu_dereference_protected(fn->right,
1723 : : lockdep_is_held(&table->tb6_lock));
1724 : 229 : struct fib6_node *fn_l = rcu_dereference_protected(fn->left,
1725 : : lockdep_is_held(&table->tb6_lock));
1726 : 229 : struct fib6_node *pn = rcu_dereference_protected(fn->parent,
1727 : : lockdep_is_held(&table->tb6_lock));
1728 : 229 : struct fib6_node *pn_r = rcu_dereference_protected(pn->right,
1729 : : lockdep_is_held(&table->tb6_lock));
1730 : 229 : struct fib6_node *pn_l = rcu_dereference_protected(pn->left,
1731 : : lockdep_is_held(&table->tb6_lock));
1732 : 229 : struct fib6_info *fn_leaf = rcu_dereference_protected(fn->leaf,
1733 : : lockdep_is_held(&table->tb6_lock));
1734 : 229 : struct fib6_info *pn_leaf = rcu_dereference_protected(pn->leaf,
1735 : : lockdep_is_held(&table->tb6_lock));
1736 : : struct fib6_info *new_fn_leaf;
1737 : :
1738 : : RT6_TRACE("fixing tree: plen=%d iter=%d\n", fn->fn_bit, iter);
1739 : : iter++;
1740 : :
1741 [ - + ]: 229 : WARN_ON(fn->fn_flags & RTN_RTINFO);
1742 [ - + ]: 229 : WARN_ON(fn->fn_flags & RTN_TL_ROOT);
1743 [ - + ]: 229 : WARN_ON(fn_leaf);
1744 : :
1745 : : children = 0;
1746 : : child = NULL;
1747 [ + + ]: 229 : if (fn_r)
1748 : : child = fn_r, children |= 1;
1749 [ - + ]: 229 : if (fn_l)
1750 : 0 : child = fn_l, children |= 2;
1751 : :
1752 [ + - + - ]: 229 : if (children == 3 || FIB6_SUBTREE(fn)
1753 : : #ifdef CONFIG_IPV6_SUBTREES
1754 : : /* Subtree root (i.e. fn) may have one child */
1755 [ + + - + ]: 229 : || (children && fn->fn_flags & RTN_ROOT)
1756 : : #endif
1757 : : ) {
1758 : : new_fn_leaf = fib6_find_prefix(net, table, fn);
1759 : : #if RT6_DEBUG >= 2
1760 [ # # ]: 0 : if (!new_fn_leaf) {
1761 [ # # ]: 0 : WARN_ON(!new_fn_leaf);
1762 : 0 : new_fn_leaf = net->ipv6.fib6_null_entry;
1763 : : }
1764 : : #endif
1765 : : fib6_info_hold(new_fn_leaf);
1766 : 0 : rcu_assign_pointer(fn->leaf, new_fn_leaf);
1767 : 0 : return pn;
1768 : : }
1769 : :
1770 : : #ifdef CONFIG_IPV6_SUBTREES
1771 [ - + ]: 229 : if (FIB6_SUBTREE(pn) == fn) {
1772 [ # # ]: 0 : WARN_ON(!(fn->fn_flags & RTN_ROOT));
1773 : : RCU_INIT_POINTER(pn->subtree, NULL);
1774 : : nstate = FWS_L;
1775 : : } else {
1776 [ - + ]: 229 : WARN_ON(fn->fn_flags & RTN_ROOT);
1777 : : #endif
1778 [ + + ]: 229 : if (pn_r == fn)
1779 : 218 : rcu_assign_pointer(pn->right, child);
1780 [ + - ]: 11 : else if (pn_l == fn)
1781 : 11 : rcu_assign_pointer(pn->left, child);
1782 : : #if RT6_DEBUG >= 2
1783 : : else
1784 : 0 : WARN_ON(1);
1785 : : #endif
1786 [ + + ]: 229 : if (child)
1787 : 11 : rcu_assign_pointer(child->parent, pn);
1788 : : nstate = FWS_R;
1789 : : #ifdef CONFIG_IPV6_SUBTREES
1790 : : }
1791 : : #endif
1792 : :
1793 : 229 : read_lock(&net->ipv6.fib6_walker_lock);
1794 [ - + ]: 229 : FOR_WALKERS(net, w) {
1795 [ # # ]: 0 : if (!child) {
1796 [ # # ]: 0 : if (w->node == fn) {
1797 : : RT6_TRACE("W %p adjusted by delnode 1, s=%d/%d\n", w, w->state, nstate);
1798 : 0 : w->node = pn;
1799 : 0 : w->state = nstate;
1800 : : }
1801 : : } else {
1802 [ # # ]: 0 : if (w->node == fn) {
1803 : 0 : w->node = child;
1804 [ # # ]: 0 : if (children&2) {
1805 : : RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state);
1806 [ # # ]: 0 : w->state = w->state >= FWS_R ? FWS_U : FWS_INIT;
1807 : : } else {
1808 : : RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state);
1809 [ # # ]: 0 : w->state = w->state >= FWS_C ? FWS_U : FWS_INIT;
1810 : : }
1811 : : }
1812 : : }
1813 : : }
1814 : : read_unlock(&net->ipv6.fib6_walker_lock);
1815 : :
1816 : : node_free(net, fn);
1817 [ + + - + ]: 229 : if (pn->fn_flags & RTN_RTINFO || FIB6_SUBTREE(pn))
1818 : 218 : return pn;
1819 : :
1820 : : RCU_INIT_POINTER(pn->leaf, NULL);
1821 : 11 : fib6_info_release(pn_leaf);
1822 : : fn = pn;
1823 : 11 : }
1824 : : }
1825 : :
1826 : 218 : static void fib6_del_route(struct fib6_table *table, struct fib6_node *fn,
1827 : : struct fib6_info __rcu **rtp, struct nl_info *info)
1828 : : {
1829 : : struct fib6_walker *w;
1830 : 218 : struct fib6_info *rt = rcu_dereference_protected(*rtp,
1831 : : lockdep_is_held(&table->tb6_lock));
1832 : 218 : struct net *net = info->nl_net;
1833 : :
1834 : : RT6_TRACE("fib6_del_route\n");
1835 : :
1836 : : /* Unlink it */
1837 : 218 : *rtp = rt->fib6_next;
1838 : 218 : rt->fib6_node = NULL;
1839 : 218 : net->ipv6.rt6_stats->fib_rt_entries--;
1840 : 218 : net->ipv6.rt6_stats->fib_discarded_routes++;
1841 : :
1842 : : /* Flush all cached dst in exception table */
1843 : 218 : rt6_flush_exceptions(rt);
1844 : :
1845 : : /* Reset round-robin state, if necessary */
1846 [ - + ]: 218 : if (rcu_access_pointer(fn->rr_ptr) == rt)
1847 : 0 : fn->rr_ptr = NULL;
1848 : :
1849 : : /* Remove this entry from other siblings */
1850 [ - + ]: 218 : if (rt->fib6_nsiblings) {
1851 : : struct fib6_info *sibling, *next_sibling;
1852 : :
1853 [ # # ]: 0 : list_for_each_entry_safe(sibling, next_sibling,
1854 : : &rt->fib6_siblings, fib6_siblings)
1855 : 0 : sibling->fib6_nsiblings--;
1856 : 0 : rt->fib6_nsiblings = 0;
1857 : 0 : list_del_init(&rt->fib6_siblings);
1858 : 0 : rt6_multipath_rebalance(next_sibling);
1859 : : }
1860 : :
1861 : : /* Adjust walkers */
1862 : 218 : read_lock(&net->ipv6.fib6_walker_lock);
1863 [ - + ]: 218 : FOR_WALKERS(net, w) {
1864 [ # # # # ]: 0 : if (w->state == FWS_C && w->leaf == rt) {
1865 : : RT6_TRACE("walker %p adjusted by delroute\n", w);
1866 : 0 : w->leaf = rcu_dereference_protected(rt->fib6_next,
1867 : : lockdep_is_held(&table->tb6_lock));
1868 [ # # ]: 0 : if (!w->leaf)
1869 : 0 : w->state = FWS_U;
1870 : : }
1871 : : }
1872 : : read_unlock(&net->ipv6.fib6_walker_lock);
1873 : :
1874 : : /* If it was last route, call fib6_repair_tree() to:
1875 : : * 1. For root node, put back null_entry as how the table was created.
1876 : : * 2. For other nodes, expunge its radix tree node.
1877 : : */
1878 [ + - ]: 218 : if (!rcu_access_pointer(fn->leaf)) {
1879 [ + - ]: 218 : if (!(fn->fn_flags & RTN_TL_ROOT)) {
1880 : 218 : fn->fn_flags &= ~RTN_RTINFO;
1881 : 218 : net->ipv6.rt6_stats->fib_route_nodes--;
1882 : : }
1883 : 218 : fn = fib6_repair_tree(net, table, fn);
1884 : : }
1885 : :
1886 : 218 : fib6_purge_rt(rt, fn, net);
1887 : :
1888 [ + - ]: 218 : if (!info->skip_notify_kernel)
1889 : 218 : call_fib6_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, rt, NULL);
1890 [ + - ]: 218 : if (!info->skip_notify)
1891 : 218 : inet6_rt_notify(RTM_DELROUTE, rt, info, 0);
1892 : :
1893 : 218 : fib6_info_release(rt);
1894 : 218 : }
1895 : :
1896 : : /* Need to own table->tb6_lock */
1897 : 414 : int fib6_del(struct fib6_info *rt, struct nl_info *info)
1898 : : {
1899 : 414 : struct fib6_node *fn = rcu_dereference_protected(rt->fib6_node,
1900 : : lockdep_is_held(&rt->fib6_table->tb6_lock));
1901 : 414 : struct fib6_table *table = rt->fib6_table;
1902 : 414 : struct net *net = info->nl_net;
1903 : : struct fib6_info __rcu **rtp;
1904 : : struct fib6_info __rcu **rtp_next;
1905 : :
1906 [ + + + - ]: 414 : if (!fn || rt == net->ipv6.fib6_null_entry)
1907 : : return -ENOENT;
1908 : :
1909 [ - + ]: 218 : WARN_ON(!(fn->fn_flags & RTN_RTINFO));
1910 : :
1911 : : /*
1912 : : * Walk the leaf entries looking for ourself
1913 : : */
1914 : :
1915 [ + - ]: 436 : for (rtp = &fn->leaf; *rtp; rtp = rtp_next) {
1916 : : struct fib6_info *cur = rcu_dereference_protected(*rtp,
1917 : : lockdep_is_held(&table->tb6_lock));
1918 [ + - ]: 218 : if (rt == cur) {
1919 : 218 : fib6_del_route(table, fn, rtp, info);
1920 : 218 : return 0;
1921 : : }
1922 : 0 : rtp_next = &cur->fib6_next;
1923 : : }
1924 : : return -ENOENT;
1925 : : }
1926 : :
1927 : : /*
1928 : : * Tree traversal function.
1929 : : *
1930 : : * Certainly, it is not interrupt safe.
1931 : : * However, it is internally reenterable wrt itself and fib6_add/fib6_del.
1932 : : * It means, that we can modify tree during walking
1933 : : * and use this function for garbage collection, clone pruning,
1934 : : * cleaning tree when a device goes down etc. etc.
1935 : : *
1936 : : * It guarantees that every node will be traversed,
1937 : : * and that it will be traversed only once.
1938 : : *
1939 : : * Callback function w->func may return:
1940 : : * 0 -> continue walking.
1941 : : * positive value -> walking is suspended (used by tree dumps,
1942 : : * and probably by gc, if it will be split to several slices)
1943 : : * negative value -> terminate walking.
1944 : : *
1945 : : * The function itself returns:
1946 : : * 0 -> walk is complete.
1947 : : * >0 -> walk is incomplete (i.e. suspended)
1948 : : * <0 -> walk is terminated by an error.
1949 : : *
1950 : : * This function is called with tb6_lock held.
1951 : : */
1952 : :
1953 : 4576 : static int fib6_walk_continue(struct fib6_walker *w)
1954 : : {
1955 : : struct fib6_node *fn, *pn, *left, *right;
1956 : :
1957 : : /* w->root should always be table->tb6_root */
1958 [ - + # # ]: 4576 : WARN_ON_ONCE(!(w->root->fn_flags & RTN_TL_ROOT));
1959 : :
1960 : : for (;;) {
1961 : 30882 : fn = w->node;
1962 [ + - ]: 30882 : if (!fn)
1963 : : return 0;
1964 : :
1965 [ - + - + : 30882 : switch (w->state) {
+ - ]
1966 : : #ifdef CONFIG_IPV6_SUBTREES
1967 : : case FWS_S:
1968 [ - + ]: 11893 : if (FIB6_SUBTREE(fn)) {
1969 : 0 : w->node = FIB6_SUBTREE(fn);
1970 : 0 : continue;
1971 : : }
1972 : 11893 : w->state = FWS_L;
1973 : : #endif
1974 : : /* fall through */
1975 : : case FWS_L:
1976 : 11893 : left = rcu_dereference_protected(fn->left, 1);
1977 [ + + ]: 11893 : if (left) {
1978 : 4590 : w->node = left;
1979 : 4590 : w->state = FWS_INIT;
1980 : 4590 : continue;
1981 : : }
1982 : 7303 : w->state = FWS_R;
1983 : : /* fall through */
1984 : : case FWS_R:
1985 : 11893 : right = rcu_dereference_protected(fn->right, 1);
1986 [ + + ]: 11893 : if (right) {
1987 : 2727 : w->node = right;
1988 : 2727 : w->state = FWS_INIT;
1989 : 2727 : continue;
1990 : : }
1991 : 9166 : w->state = FWS_C;
1992 : 9166 : w->leaf = rcu_dereference_protected(fn->leaf, 1);
1993 : : /* fall through */
1994 : : case FWS_C:
1995 [ + + + + ]: 23565 : if (w->leaf && fn->fn_flags & RTN_RTINFO) {
1996 : : int err;
1997 : :
1998 [ - + ]: 11672 : if (w->skip) {
1999 : 0 : w->skip--;
2000 : 0 : goto skip;
2001 : : }
2002 : :
2003 : 11672 : err = w->func(w);
2004 [ - + ]: 11672 : if (err)
2005 : 0 : return err;
2006 : :
2007 : 11672 : w->count++;
2008 : 11672 : continue;
2009 : : }
2010 : : skip:
2011 : 11893 : w->state = FWS_U;
2012 : : /* fall through */
2013 : : case FWS_U:
2014 [ + + ]: 11893 : if (fn == w->root)
2015 : : return 0;
2016 : 7317 : pn = rcu_dereference_protected(fn->parent, 1);
2017 : 7317 : left = rcu_dereference_protected(pn->left, 1);
2018 : 7317 : right = rcu_dereference_protected(pn->right, 1);
2019 : 7317 : w->node = pn;
2020 : : #ifdef CONFIG_IPV6_SUBTREES
2021 [ - + ]: 7317 : if (FIB6_SUBTREE(pn) == fn) {
2022 [ # # ]: 0 : WARN_ON(!(fn->fn_flags & RTN_ROOT));
2023 : 0 : w->state = FWS_L;
2024 : 0 : continue;
2025 : : }
2026 : : #endif
2027 [ + + ]: 7317 : if (left == fn) {
2028 : 4590 : w->state = FWS_R;
2029 : 4590 : continue;
2030 : : }
2031 [ + - ]: 2727 : if (right == fn) {
2032 : 2727 : w->state = FWS_C;
2033 : 2727 : w->leaf = rcu_dereference_protected(w->node->leaf, 1);
2034 : 2727 : continue;
2035 : : }
2036 : : #if RT6_DEBUG >= 2
2037 : 0 : WARN_ON(1);
2038 : : #endif
2039 : : }
2040 : : }
2041 : : }
2042 : :
2043 : 4576 : static int fib6_walk(struct net *net, struct fib6_walker *w)
2044 : : {
2045 : : int res;
2046 : :
2047 : 4576 : w->state = FWS_INIT;
2048 : 4576 : w->node = w->root;
2049 : :
2050 : 4576 : fib6_walker_link(net, w);
2051 : 4576 : res = fib6_walk_continue(w);
2052 [ + - ]: 4576 : if (res <= 0)
2053 : 4576 : fib6_walker_unlink(net, w);
2054 : 4576 : return res;
2055 : : }
2056 : :
2057 : 10637 : static int fib6_clean_node(struct fib6_walker *w)
2058 : : {
2059 : : int res;
2060 : : struct fib6_info *rt;
2061 : : struct fib6_cleaner *c = container_of(w, struct fib6_cleaner, w);
2062 : 31911 : struct nl_info info = {
2063 : 10637 : .nl_net = c->net,
2064 : 10637 : .skip_notify = c->skip_notify,
2065 : : };
2066 : :
2067 [ + + + - ]: 14048 : if (c->sernum != FIB6_NO_SERNUM_CHANGE &&
2068 : 3411 : w->node->fn_sernum != c->sernum)
2069 : 3411 : w->node->fn_sernum = c->sernum;
2070 : :
2071 [ + + ]: 10637 : if (!c->func) {
2072 [ - + # # ]: 3411 : WARN_ON_ONCE(c->sernum == FIB6_NO_SERNUM_CHANGE);
2073 : 3411 : w->leaf = NULL;
2074 : 3411 : return 0;
2075 : : }
2076 : :
2077 [ + + ]: 14452 : for_each_fib6_walker_rt(w) {
2078 : 7226 : res = c->func(rt, c->arg);
2079 [ - + ]: 7226 : if (res == -1) {
2080 : 0 : w->leaf = rt;
2081 : 0 : res = fib6_del(rt, &info);
2082 [ # # ]: 0 : if (res) {
2083 : : #if RT6_DEBUG >= 2
2084 : : pr_debug("%s: del failed: rt=%p@%p err=%d\n",
2085 : : __func__, rt,
2086 : : rcu_access_pointer(rt->fib6_node),
2087 : : res);
2088 : : #endif
2089 : 0 : continue;
2090 : : }
2091 : : return 0;
2092 [ - + ]: 7226 : } else if (res == -2) {
2093 [ # # # # ]: 0 : if (WARN_ON(!rt->fib6_nsiblings))
2094 : 0 : continue;
2095 : 0 : rt = list_last_entry(&rt->fib6_siblings,
2096 : : struct fib6_info, fib6_siblings);
2097 : 0 : continue;
2098 : : }
2099 [ - + ]: 7226 : WARN_ON(res != 0);
2100 : : }
2101 : 7226 : w->leaf = rt;
2102 : 7226 : return 0;
2103 : : }
2104 : :
2105 : : /*
2106 : : * Convenient frontend to tree walker.
2107 : : *
2108 : : * func is called on each route.
2109 : : * It may return -2 -> skip multipath route.
2110 : : * -1 -> delete this route.
2111 : : * 0 -> continue walking
2112 : : */
2113 : :
2114 : 4162 : static void fib6_clean_tree(struct net *net, struct fib6_node *root,
2115 : : int (*func)(struct fib6_info *, void *arg),
2116 : : int sernum, void *arg, bool skip_notify)
2117 : : {
2118 : : struct fib6_cleaner c;
2119 : :
2120 : 4162 : c.w.root = root;
2121 : 4162 : c.w.func = fib6_clean_node;
2122 : 4162 : c.w.count = 0;
2123 : 4162 : c.w.skip = 0;
2124 : 4162 : c.w.skip_in_node = 0;
2125 : 4162 : c.func = func;
2126 : 4162 : c.sernum = sernum;
2127 : 4162 : c.arg = arg;
2128 : 4162 : c.net = net;
2129 : 4162 : c.skip_notify = skip_notify;
2130 : :
2131 : 4162 : fib6_walk(net, &c.w);
2132 : 4162 : }
2133 : :
2134 : 2081 : static void __fib6_clean_all(struct net *net,
2135 : : int (*func)(struct fib6_info *, void *),
2136 : : int sernum, void *arg, bool skip_notify)
2137 : : {
2138 : : struct fib6_table *table;
2139 : : struct hlist_head *head;
2140 : : unsigned int h;
2141 : :
2142 : : rcu_read_lock();
2143 [ + + ]: 534817 : for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
2144 : 532736 : head = &net->ipv6.fib_table_hash[h];
2145 [ + + - + : 536898 : hlist_for_each_entry_rcu(table, head, tb6_hlist) {
+ + ]
2146 : : spin_lock_bh(&table->tb6_lock);
2147 : 4162 : fib6_clean_tree(net, &table->tb6_root,
2148 : : func, sernum, arg, skip_notify);
2149 : : spin_unlock_bh(&table->tb6_lock);
2150 : : }
2151 : : }
2152 : : rcu_read_unlock();
2153 : 2081 : }
2154 : :
2155 : 1449 : void fib6_clean_all(struct net *net, int (*func)(struct fib6_info *, void *),
2156 : : void *arg)
2157 : : {
2158 : 1449 : __fib6_clean_all(net, func, FIB6_NO_SERNUM_CHANGE, arg, false);
2159 : 1449 : }
2160 : :
2161 : 0 : void fib6_clean_all_skip_notify(struct net *net,
2162 : : int (*func)(struct fib6_info *, void *),
2163 : : void *arg)
2164 : : {
2165 : 0 : __fib6_clean_all(net, func, FIB6_NO_SERNUM_CHANGE, arg, true);
2166 : 0 : }
2167 : :
2168 : 632 : static void fib6_flush_trees(struct net *net)
2169 : : {
2170 : 632 : int new_sernum = fib6_new_sernum(net);
2171 : :
2172 : 632 : __fib6_clean_all(net, NULL, new_sernum, NULL, false);
2173 : 632 : }
2174 : :
2175 : : /*
2176 : : * Garbage collection
2177 : : */
2178 : :
2179 : 0 : static int fib6_age(struct fib6_info *rt, void *arg)
2180 : : {
2181 : : struct fib6_gc_args *gc_args = arg;
2182 : 0 : unsigned long now = jiffies;
2183 : :
2184 : : /*
2185 : : * check addrconf expiration here.
2186 : : * Routes are expired even if they are in use.
2187 : : */
2188 : :
2189 [ # # # # ]: 0 : if (rt->fib6_flags & RTF_EXPIRES && rt->expires) {
2190 [ # # ]: 0 : if (time_after(now, rt->expires)) {
2191 : : RT6_TRACE("expiring %p\n", rt);
2192 : : return -1;
2193 : : }
2194 : 0 : gc_args->more++;
2195 : : }
2196 : :
2197 : : /* Also age clones in the exception table.
2198 : : * Note, that clones are aged out
2199 : : * only if they are not in use now.
2200 : : */
2201 : 0 : rt6_age_exceptions(rt, gc_args, now);
2202 : :
2203 : 0 : return 0;
2204 : : }
2205 : :
2206 : 0 : void fib6_run_gc(unsigned long expires, struct net *net, bool force)
2207 : : {
2208 : : struct fib6_gc_args gc_args;
2209 : : unsigned long now;
2210 : :
2211 [ # # ]: 0 : if (force) {
2212 : : spin_lock_bh(&net->ipv6.fib6_gc_lock);
2213 [ # # ]: 0 : } else if (!spin_trylock_bh(&net->ipv6.fib6_gc_lock)) {
2214 : 0 : mod_timer(&net->ipv6.ip6_fib_timer, jiffies + HZ);
2215 : 0 : return;
2216 : : }
2217 [ # # ]: 0 : gc_args.timeout = expires ? (int)expires :
2218 : : net->ipv6.sysctl.ip6_rt_gc_interval;
2219 : 0 : gc_args.more = 0;
2220 : :
2221 : : fib6_clean_all(net, fib6_age, &gc_args);
2222 : 0 : now = jiffies;
2223 : 0 : net->ipv6.ip6_rt_last_gc = now;
2224 : :
2225 [ # # ]: 0 : if (gc_args.more)
2226 : 0 : mod_timer(&net->ipv6.ip6_fib_timer,
2227 : : round_jiffies(now
2228 : 0 : + net->ipv6.sysctl.ip6_rt_gc_interval));
2229 : : else
2230 : 0 : del_timer(&net->ipv6.ip6_fib_timer);
2231 : : spin_unlock_bh(&net->ipv6.fib6_gc_lock);
2232 : : }
2233 : :
2234 : 0 : static void fib6_gc_timer_cb(struct timer_list *t)
2235 : : {
2236 : 0 : struct net *arg = from_timer(arg, t, ipv6.ip6_fib_timer);
2237 : :
2238 : 0 : fib6_run_gc(0, arg, true);
2239 : 0 : }
2240 : :
2241 : 207 : static int __net_init fib6_net_init(struct net *net)
2242 : : {
2243 : : size_t size = sizeof(struct hlist_head) * FIB6_TABLE_HASHSZ;
2244 : : int err;
2245 : :
2246 : 207 : err = fib6_notifier_init(net);
2247 [ + - ]: 207 : if (err)
2248 : : return err;
2249 : :
2250 : 207 : spin_lock_init(&net->ipv6.fib6_gc_lock);
2251 : 207 : rwlock_init(&net->ipv6.fib6_walker_lock);
2252 : 207 : INIT_LIST_HEAD(&net->ipv6.fib6_walkers);
2253 : 207 : timer_setup(&net->ipv6.ip6_fib_timer, fib6_gc_timer_cb, 0);
2254 : :
2255 : 207 : net->ipv6.rt6_stats = kzalloc(sizeof(*net->ipv6.rt6_stats), GFP_KERNEL);
2256 [ + - ]: 207 : if (!net->ipv6.rt6_stats)
2257 : : goto out_timer;
2258 : :
2259 : : /* Avoid false sharing : Use at least a full cache line */
2260 : : size = max_t(size_t, size, L1_CACHE_BYTES);
2261 : :
2262 : 207 : net->ipv6.fib_table_hash = kzalloc(size, GFP_KERNEL);
2263 [ + - ]: 207 : if (!net->ipv6.fib_table_hash)
2264 : : goto out_rt6_stats;
2265 : :
2266 : 207 : net->ipv6.fib6_main_tbl = kzalloc(sizeof(*net->ipv6.fib6_main_tbl),
2267 : : GFP_KERNEL);
2268 [ + - ]: 207 : if (!net->ipv6.fib6_main_tbl)
2269 : : goto out_fib_table_hash;
2270 : :
2271 : 207 : net->ipv6.fib6_main_tbl->tb6_id = RT6_TABLE_MAIN;
2272 : 207 : rcu_assign_pointer(net->ipv6.fib6_main_tbl->tb6_root.leaf,
2273 : : net->ipv6.fib6_null_entry);
2274 : 207 : net->ipv6.fib6_main_tbl->tb6_root.fn_flags =
2275 : : RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
2276 : 207 : inet_peer_base_init(&net->ipv6.fib6_main_tbl->tb6_peers);
2277 : :
2278 : : #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2279 : 207 : net->ipv6.fib6_local_tbl = kzalloc(sizeof(*net->ipv6.fib6_local_tbl),
2280 : : GFP_KERNEL);
2281 [ + - ]: 207 : if (!net->ipv6.fib6_local_tbl)
2282 : : goto out_fib6_main_tbl;
2283 : 207 : net->ipv6.fib6_local_tbl->tb6_id = RT6_TABLE_LOCAL;
2284 : 207 : rcu_assign_pointer(net->ipv6.fib6_local_tbl->tb6_root.leaf,
2285 : : net->ipv6.fib6_null_entry);
2286 : 207 : net->ipv6.fib6_local_tbl->tb6_root.fn_flags =
2287 : : RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;
2288 : 207 : inet_peer_base_init(&net->ipv6.fib6_local_tbl->tb6_peers);
2289 : : #endif
2290 : 207 : fib6_tables_init(net);
2291 : :
2292 : 207 : return 0;
2293 : :
2294 : : #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2295 : : out_fib6_main_tbl:
2296 : 0 : kfree(net->ipv6.fib6_main_tbl);
2297 : : #endif
2298 : : out_fib_table_hash:
2299 : 0 : kfree(net->ipv6.fib_table_hash);
2300 : : out_rt6_stats:
2301 : 0 : kfree(net->ipv6.rt6_stats);
2302 : : out_timer:
2303 : 0 : fib6_notifier_exit(net);
2304 : 0 : return -ENOMEM;
2305 : : }
2306 : :
2307 : 0 : static void fib6_net_exit(struct net *net)
2308 : : {
2309 : : unsigned int i;
2310 : :
2311 : 0 : del_timer_sync(&net->ipv6.ip6_fib_timer);
2312 : :
2313 [ # # ]: 0 : for (i = 0; i < FIB6_TABLE_HASHSZ; i++) {
2314 : 0 : struct hlist_head *head = &net->ipv6.fib_table_hash[i];
2315 : : struct hlist_node *tmp;
2316 : : struct fib6_table *tb;
2317 : :
2318 [ # # # # : 0 : hlist_for_each_entry_safe(tb, tmp, head, tb6_hlist) {
# # ]
2319 : : hlist_del(&tb->tb6_hlist);
2320 : : fib6_free_table(tb);
2321 : : }
2322 : : }
2323 : :
2324 : 0 : kfree(net->ipv6.fib_table_hash);
2325 : 0 : kfree(net->ipv6.rt6_stats);
2326 : 0 : fib6_notifier_exit(net);
2327 : 0 : }
2328 : :
2329 : : static struct pernet_operations fib6_net_ops = {
2330 : : .init = fib6_net_init,
2331 : : .exit = fib6_net_exit,
2332 : : };
2333 : :
2334 : 207 : int __init fib6_init(void)
2335 : : {
2336 : : int ret = -ENOMEM;
2337 : :
2338 : 207 : fib6_node_kmem = kmem_cache_create("fib6_nodes",
2339 : : sizeof(struct fib6_node),
2340 : : 0, SLAB_HWCACHE_ALIGN,
2341 : : NULL);
2342 [ + - ]: 207 : if (!fib6_node_kmem)
2343 : : goto out;
2344 : :
2345 : 207 : ret = register_pernet_subsys(&fib6_net_ops);
2346 [ + - ]: 207 : if (ret)
2347 : : goto out_kmem_cache_create;
2348 : :
2349 : 207 : ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE, NULL,
2350 : : inet6_dump_fib, 0);
2351 [ + - ]: 207 : if (ret)
2352 : : goto out_unregister_subsys;
2353 : :
2354 : 207 : __fib6_flush_trees = fib6_flush_trees;
2355 : : out:
2356 : 207 : return ret;
2357 : :
2358 : : out_unregister_subsys:
2359 : 0 : unregister_pernet_subsys(&fib6_net_ops);
2360 : : out_kmem_cache_create:
2361 : 0 : kmem_cache_destroy(fib6_node_kmem);
2362 : 0 : goto out;
2363 : : }
2364 : :
2365 : 0 : void fib6_gc_cleanup(void)
2366 : : {
2367 : 0 : unregister_pernet_subsys(&fib6_net_ops);
2368 : 0 : kmem_cache_destroy(fib6_node_kmem);
2369 : 0 : }
2370 : :
2371 : : #ifdef CONFIG_PROC_FS
2372 : 0 : static int ipv6_route_seq_show(struct seq_file *seq, void *v)
2373 : : {
2374 : : struct fib6_info *rt = v;
2375 : 0 : struct ipv6_route_iter *iter = seq->private;
2376 : 0 : struct fib6_nh *fib6_nh = rt->fib6_nh;
2377 : 0 : unsigned int flags = rt->fib6_flags;
2378 : : const struct net_device *dev;
2379 : :
2380 [ # # ]: 0 : if (rt->nh)
2381 : : fib6_nh = nexthop_fib6_nh(rt->nh);
2382 : :
2383 : 0 : seq_printf(seq, "%pi6 %02x ", &rt->fib6_dst.addr, rt->fib6_dst.plen);
2384 : :
2385 : : #ifdef CONFIG_IPV6_SUBTREES
2386 : 0 : seq_printf(seq, "%pi6 %02x ", &rt->fib6_src.addr, rt->fib6_src.plen);
2387 : : #else
2388 : : seq_puts(seq, "00000000000000000000000000000000 00 ");
2389 : : #endif
2390 [ # # ]: 0 : if (fib6_nh->fib_nh_gw_family) {
2391 : 0 : flags |= RTF_GATEWAY;
2392 : 0 : seq_printf(seq, "%pi6", &fib6_nh->fib_nh_gw6);
2393 : : } else {
2394 : 0 : seq_puts(seq, "00000000000000000000000000000000");
2395 : : }
2396 : :
2397 : 0 : dev = fib6_nh->fib_nh_dev;
2398 [ # # ]: 0 : seq_printf(seq, " %08x %08x %08x %08x %8s\n",
2399 : : rt->fib6_metric, refcount_read(&rt->fib6_ref), 0,
2400 : : flags, dev ? dev->name : "");
2401 : 0 : iter->w.leaf = NULL;
2402 : 0 : return 0;
2403 : : }
2404 : :
2405 : 0 : static int ipv6_route_yield(struct fib6_walker *w)
2406 : : {
2407 : 0 : struct ipv6_route_iter *iter = w->args;
2408 : :
2409 [ # # ]: 0 : if (!iter->skip)
2410 : : return 1;
2411 : :
2412 : : do {
2413 : 0 : iter->w.leaf = rcu_dereference_protected(
2414 : : iter->w.leaf->fib6_next,
2415 : : lockdep_is_held(&iter->tbl->tb6_lock));
2416 : 0 : iter->skip--;
2417 [ # # # # ]: 0 : if (!iter->skip && iter->w.leaf)
2418 : : return 1;
2419 [ # # ]: 0 : } while (iter->w.leaf);
2420 : :
2421 : : return 0;
2422 : : }
2423 : :
2424 : 0 : static void ipv6_route_seq_setup_walk(struct ipv6_route_iter *iter,
2425 : : struct net *net)
2426 : : {
2427 : 0 : memset(&iter->w, 0, sizeof(iter->w));
2428 : 0 : iter->w.func = ipv6_route_yield;
2429 : 0 : iter->w.root = &iter->tbl->tb6_root;
2430 : 0 : iter->w.state = FWS_INIT;
2431 : 0 : iter->w.node = iter->w.root;
2432 : 0 : iter->w.args = iter;
2433 : 0 : iter->sernum = iter->w.root->fn_sernum;
2434 : 0 : INIT_LIST_HEAD(&iter->w.lh);
2435 : 0 : fib6_walker_link(net, &iter->w);
2436 : 0 : }
2437 : :
2438 : 0 : static struct fib6_table *ipv6_route_seq_next_table(struct fib6_table *tbl,
2439 : : struct net *net)
2440 : : {
2441 : : unsigned int h;
2442 : : struct hlist_node *node;
2443 : :
2444 [ # # ]: 0 : if (tbl) {
2445 : 0 : h = (tbl->tb6_id & (FIB6_TABLE_HASHSZ - 1)) + 1;
2446 : 0 : node = rcu_dereference_bh(hlist_next_rcu(&tbl->tb6_hlist));
2447 : : } else {
2448 : : h = 0;
2449 : : node = NULL;
2450 : : }
2451 : :
2452 [ # # ]: 0 : while (!node && h < FIB6_TABLE_HASHSZ) {
2453 : 0 : node = rcu_dereference_bh(
2454 : : hlist_first_rcu(&net->ipv6.fib_table_hash[h++]));
2455 : : }
2456 [ # # ]: 0 : return hlist_entry_safe(node, struct fib6_table, tb6_hlist);
2457 : : }
2458 : :
2459 : 0 : static void ipv6_route_check_sernum(struct ipv6_route_iter *iter)
2460 : : {
2461 [ # # ]: 0 : if (iter->sernum != iter->w.root->fn_sernum) {
2462 : 0 : iter->sernum = iter->w.root->fn_sernum;
2463 : 0 : iter->w.state = FWS_INIT;
2464 : 0 : iter->w.node = iter->w.root;
2465 [ # # ]: 0 : WARN_ON(iter->w.skip);
2466 : 0 : iter->w.skip = iter->w.count;
2467 : : }
2468 : 0 : }
2469 : :
2470 : 0 : static void *ipv6_route_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2471 : : {
2472 : : int r;
2473 : : struct fib6_info *n;
2474 : : struct net *net = seq_file_net(seq);
2475 : : struct ipv6_route_iter *iter = seq->private;
2476 : :
2477 [ # # ]: 0 : if (!v)
2478 : : goto iter_table;
2479 : :
2480 : 0 : n = rcu_dereference_bh(((struct fib6_info *)v)->fib6_next);
2481 [ # # ]: 0 : if (n) {
2482 : 0 : ++*pos;
2483 : 0 : return n;
2484 : : }
2485 : :
2486 : : iter_table:
2487 : 0 : ipv6_route_check_sernum(iter);
2488 : 0 : spin_lock_bh(&iter->tbl->tb6_lock);
2489 : 0 : r = fib6_walk_continue(&iter->w);
2490 : 0 : spin_unlock_bh(&iter->tbl->tb6_lock);
2491 [ # # ]: 0 : if (r > 0) {
2492 [ # # ]: 0 : if (v)
2493 : 0 : ++*pos;
2494 : 0 : return iter->w.leaf;
2495 [ # # ]: 0 : } else if (r < 0) {
2496 : 0 : fib6_walker_unlink(net, &iter->w);
2497 : 0 : return NULL;
2498 : : }
2499 : 0 : fib6_walker_unlink(net, &iter->w);
2500 : :
2501 : 0 : iter->tbl = ipv6_route_seq_next_table(iter->tbl, net);
2502 [ # # ]: 0 : if (!iter->tbl)
2503 : : return NULL;
2504 : :
2505 : 0 : ipv6_route_seq_setup_walk(iter, net);
2506 : 0 : goto iter_table;
2507 : : }
2508 : :
2509 : 0 : static void *ipv6_route_seq_start(struct seq_file *seq, loff_t *pos)
2510 : : __acquires(RCU_BH)
2511 : : {
2512 : : struct net *net = seq_file_net(seq);
2513 : : struct ipv6_route_iter *iter = seq->private;
2514 : :
2515 : : rcu_read_lock_bh();
2516 : 0 : iter->tbl = ipv6_route_seq_next_table(NULL, net);
2517 : 0 : iter->skip = *pos;
2518 : :
2519 [ # # ]: 0 : if (iter->tbl) {
2520 : 0 : ipv6_route_seq_setup_walk(iter, net);
2521 : 0 : return ipv6_route_seq_next(seq, NULL, pos);
2522 : : } else {
2523 : : return NULL;
2524 : : }
2525 : : }
2526 : :
2527 : : static bool ipv6_route_iter_active(struct ipv6_route_iter *iter)
2528 : : {
2529 : : struct fib6_walker *w = &iter->w;
2530 [ # # # # : 0 : return w->node && !(w->state == FWS_U && w->node == w->root);
# # ]
2531 : : }
2532 : :
2533 : 0 : static void ipv6_route_seq_stop(struct seq_file *seq, void *v)
2534 : : __releases(RCU_BH)
2535 : : {
2536 : : struct net *net = seq_file_net(seq);
2537 : : struct ipv6_route_iter *iter = seq->private;
2538 : :
2539 [ # # ]: 0 : if (ipv6_route_iter_active(iter))
2540 : 0 : fib6_walker_unlink(net, &iter->w);
2541 : :
2542 : : rcu_read_unlock_bh();
2543 : 0 : }
2544 : :
2545 : : const struct seq_operations ipv6_route_seq_ops = {
2546 : : .start = ipv6_route_seq_start,
2547 : : .next = ipv6_route_seq_next,
2548 : : .stop = ipv6_route_seq_stop,
2549 : : .show = ipv6_route_seq_show
2550 : : };
2551 : : #endif /* CONFIG_PROC_FS */
|
