1
2
3
4
5
6
7
8
9
10
11
12#include <linux/uaccess.h>
13#include <linux/bitops.h>
14#include <linux/types.h>
15#include <linux/kernel.h>
16#include <linux/jiffies.h>
17#include <linux/mm.h>
18#include <linux/string.h>
19#include <linux/socket.h>
20#include <linux/sockios.h>
21#include <linux/errno.h>
22#include <linux/in.h>
23#include <linux/inet.h>
24#include <linux/inetdevice.h>
25#include <linux/netdevice.h>
26#include <linux/if_arp.h>
27#include <linux/proc_fs.h>
28#include <linux/skbuff.h>
29#include <linux/init.h>
30#include <linux/slab.h>
31#include <linux/netlink.h>
32
33#include <net/arp.h>
34#include <net/ip.h>
35#include <net/protocol.h>
36#include <net/route.h>
37#include <net/tcp.h>
38#include <net/sock.h>
39#include <net/ip_fib.h>
40#include <net/ip6_fib.h>
41#include <net/nexthop.h>
42#include <net/netlink.h>
43#include <net/rtnh.h>
44#include <net/lwtunnel.h>
45#include <net/fib_notifier.h>
46#include <net/addrconf.h>
47
48#include "fib_lookup.h"
49
50static DEFINE_SPINLOCK(fib_info_lock);
51static struct hlist_head *fib_info_hash;
52static struct hlist_head *fib_info_laddrhash;
53static unsigned int fib_info_hash_size;
54static unsigned int fib_info_cnt;
55
56#define DEVINDEX_HASHBITS 8
57#define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS)
58static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE];
59
60
61
62
63#ifdef CONFIG_IP_ROUTE_MULTIPATH
64
65#define for_nexthops(fi) { \
66 int nhsel; const struct fib_nh *nh; \
67 for (nhsel = 0, nh = (fi)->fib_nh; \
68 nhsel < fib_info_num_path((fi)); \
69 nh++, nhsel++)
70
71#define change_nexthops(fi) { \
72 int nhsel; struct fib_nh *nexthop_nh; \
73 for (nhsel = 0, nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \
74 nhsel < fib_info_num_path((fi)); \
75 nexthop_nh++, nhsel++)
76
77#else
78
79
80
81#define for_nexthops(fi) { \
82 int nhsel; const struct fib_nh *nh = (fi)->fib_nh; \
83 for (nhsel = 0; nhsel < 1; nhsel++)
84
85#define change_nexthops(fi) { \
86 int nhsel; \
87 struct fib_nh *nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \
88 for (nhsel = 0; nhsel < 1; nhsel++)
89
90#endif
91
92#define endfor_nexthops(fi) }
93
94
95const struct fib_prop fib_props[RTN_MAX + 1] = {
96 [RTN_UNSPEC] = {
97 .error = 0,
98 .scope = RT_SCOPE_NOWHERE,
99 },
100 [RTN_UNICAST] = {
101 .error = 0,
102 .scope = RT_SCOPE_UNIVERSE,
103 },
104 [RTN_LOCAL] = {
105 .error = 0,
106 .scope = RT_SCOPE_HOST,
107 },
108 [RTN_BROADCAST] = {
109 .error = 0,
110 .scope = RT_SCOPE_LINK,
111 },
112 [RTN_ANYCAST] = {
113 .error = 0,
114 .scope = RT_SCOPE_LINK,
115 },
116 [RTN_MULTICAST] = {
117 .error = 0,
118 .scope = RT_SCOPE_UNIVERSE,
119 },
120 [RTN_BLACKHOLE] = {
121 .error = -EINVAL,
122 .scope = RT_SCOPE_UNIVERSE,
123 },
124 [RTN_UNREACHABLE] = {
125 .error = -EHOSTUNREACH,
126 .scope = RT_SCOPE_UNIVERSE,
127 },
128 [RTN_PROHIBIT] = {
129 .error = -EACCES,
130 .scope = RT_SCOPE_UNIVERSE,
131 },
132 [RTN_THROW] = {
133 .error = -EAGAIN,
134 .scope = RT_SCOPE_UNIVERSE,
135 },
136 [RTN_NAT] = {
137 .error = -EINVAL,
138 .scope = RT_SCOPE_NOWHERE,
139 },
140 [RTN_XRESOLVE] = {
141 .error = -EINVAL,
142 .scope = RT_SCOPE_NOWHERE,
143 },
144};
145
146static void rt_fibinfo_free(struct rtable __rcu **rtp)
147{
148 struct rtable *rt = rcu_dereference_protected(*rtp, 1);
149
150 if (!rt)
151 return;
152
153
154
155
156
157
158 dst_dev_put(&rt->dst);
159 dst_release_immediate(&rt->dst);
160}
161
162static void free_nh_exceptions(struct fib_nh_common *nhc)
163{
164 struct fnhe_hash_bucket *hash;
165 int i;
166
167 hash = rcu_dereference_protected(nhc->nhc_exceptions, 1);
168 if (!hash)
169 return;
170 for (i = 0; i < FNHE_HASH_SIZE; i++) {
171 struct fib_nh_exception *fnhe;
172
173 fnhe = rcu_dereference_protected(hash[i].chain, 1);
174 while (fnhe) {
175 struct fib_nh_exception *next;
176
177 next = rcu_dereference_protected(fnhe->fnhe_next, 1);
178
179 rt_fibinfo_free(&fnhe->fnhe_rth_input);
180 rt_fibinfo_free(&fnhe->fnhe_rth_output);
181
182 kfree(fnhe);
183
184 fnhe = next;
185 }
186 }
187 kfree(hash);
188}
189
190static void rt_fibinfo_free_cpus(struct rtable __rcu * __percpu *rtp)
191{
192 int cpu;
193
194 if (!rtp)
195 return;
196
197 for_each_possible_cpu(cpu) {
198 struct rtable *rt;
199
200 rt = rcu_dereference_protected(*per_cpu_ptr(rtp, cpu), 1);
201 if (rt) {
202 dst_dev_put(&rt->dst);
203 dst_release_immediate(&rt->dst);
204 }
205 }
206 free_percpu(rtp);
207}
208
209void fib_nh_common_release(struct fib_nh_common *nhc)
210{
211 dev_put(nhc->nhc_dev);
212 lwtstate_put(nhc->nhc_lwtstate);
213 rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
214 rt_fibinfo_free(&nhc->nhc_rth_input);
215 free_nh_exceptions(nhc);
216}
217EXPORT_SYMBOL_GPL(fib_nh_common_release);
218
219void fib_nh_release(struct net *net, struct fib_nh *fib_nh)
220{
221#ifdef CONFIG_IP_ROUTE_CLASSID
222 if (fib_nh->nh_tclassid)
223 net->ipv4.fib_num_tclassid_users--;
224#endif
225 fib_nh_common_release(&fib_nh->nh_common);
226}
227
228
229static void free_fib_info_rcu(struct rcu_head *head)
230{
231 struct fib_info *fi = container_of(head, struct fib_info, rcu);
232
233 if (fi->nh) {
234 nexthop_put(fi->nh);
235 } else {
236 change_nexthops(fi) {
237 fib_nh_release(fi->fib_net, nexthop_nh);
238 } endfor_nexthops(fi);
239 }
240
241 ip_fib_metrics_put(fi->fib_metrics);
242
243 kfree(fi);
244}
245
246void free_fib_info(struct fib_info *fi)
247{
248 if (fi->fib_dead == 0) {
249 pr_warn("Freeing alive fib_info %p\n", fi);
250 return;
251 }
252 fib_info_cnt--;
253
254 call_rcu(&fi->rcu, free_fib_info_rcu);
255}
256EXPORT_SYMBOL_GPL(free_fib_info);
257
258void fib_release_info(struct fib_info *fi)
259{
260 spin_lock_bh(&fib_info_lock);
261 if (fi && refcount_dec_and_test(&fi->fib_treeref)) {
262 hlist_del(&fi->fib_hash);
263 if (fi->fib_prefsrc)
264 hlist_del(&fi->fib_lhash);
265 if (fi->nh) {
266 list_del(&fi->nh_list);
267 } else {
268 change_nexthops(fi) {
269 if (!nexthop_nh->fib_nh_dev)
270 continue;
271 hlist_del(&nexthop_nh->nh_hash);
272 } endfor_nexthops(fi)
273 }
274 fi->fib_dead = 1;
275 fib_info_put(fi);
276 }
277 spin_unlock_bh(&fib_info_lock);
278}
279
280static inline int nh_comp(struct fib_info *fi, struct fib_info *ofi)
281{
282 const struct fib_nh *onh;
283
284 if (fi->nh || ofi->nh)
285 return nexthop_cmp(fi->nh, ofi->nh) ? 0 : -1;
286
287 if (ofi->fib_nhs == 0)
288 return 0;
289
290 for_nexthops(fi) {
291 onh = fib_info_nh(ofi, nhsel);
292
293 if (nh->fib_nh_oif != onh->fib_nh_oif ||
294 nh->fib_nh_gw_family != onh->fib_nh_gw_family ||
295 nh->fib_nh_scope != onh->fib_nh_scope ||
296#ifdef CONFIG_IP_ROUTE_MULTIPATH
297 nh->fib_nh_weight != onh->fib_nh_weight ||
298#endif
299#ifdef CONFIG_IP_ROUTE_CLASSID
300 nh->nh_tclassid != onh->nh_tclassid ||
301#endif
302 lwtunnel_cmp_encap(nh->fib_nh_lws, onh->fib_nh_lws) ||
303 ((nh->fib_nh_flags ^ onh->fib_nh_flags) & ~RTNH_COMPARE_MASK))
304 return -1;
305
306 if (nh->fib_nh_gw_family == AF_INET &&
307 nh->fib_nh_gw4 != onh->fib_nh_gw4)
308 return -1;
309
310 if (nh->fib_nh_gw_family == AF_INET6 &&
311 ipv6_addr_cmp(&nh->fib_nh_gw6, &onh->fib_nh_gw6))
312 return -1;
313 } endfor_nexthops(fi);
314 return 0;
315}
316
317static inline unsigned int fib_devindex_hashfn(unsigned int val)
318{
319 unsigned int mask = DEVINDEX_HASHSIZE - 1;
320
321 return (val ^
322 (val >> DEVINDEX_HASHBITS) ^
323 (val >> (DEVINDEX_HASHBITS * 2))) & mask;
324}
325
326static unsigned int fib_info_hashfn_1(int init_val, u8 protocol, u8 scope,
327 u32 prefsrc, u32 priority)
328{
329 unsigned int val = init_val;
330
331 val ^= (protocol << 8) | scope;
332 val ^= prefsrc;
333 val ^= priority;
334
335 return val;
336}
337
338static unsigned int fib_info_hashfn_result(unsigned int val)
339{
340 unsigned int mask = (fib_info_hash_size - 1);
341
342 return (val ^ (val >> 7) ^ (val >> 12)) & mask;
343}
344
345static inline unsigned int fib_info_hashfn(struct fib_info *fi)
346{
347 unsigned int val;
348
349 val = fib_info_hashfn_1(fi->fib_nhs, fi->fib_protocol,
350 fi->fib_scope, (__force u32)fi->fib_prefsrc,
351 fi->fib_priority);
352
353 if (fi->nh) {
354 val ^= fib_devindex_hashfn(fi->nh->id);
355 } else {
356 for_nexthops(fi) {
357 val ^= fib_devindex_hashfn(nh->fib_nh_oif);
358 } endfor_nexthops(fi)
359 }
360
361 return fib_info_hashfn_result(val);
362}
363
364
365static struct fib_info *fib_find_info_nh(struct net *net,
366 const struct fib_config *cfg)
367{
368 struct hlist_head *head;
369 struct fib_info *fi;
370 unsigned int hash;
371
372 hash = fib_info_hashfn_1(fib_devindex_hashfn(cfg->fc_nh_id),
373 cfg->fc_protocol, cfg->fc_scope,
374 (__force u32)cfg->fc_prefsrc,
375 cfg->fc_priority);
376 hash = fib_info_hashfn_result(hash);
377 head = &fib_info_hash[hash];
378
379 hlist_for_each_entry(fi, head, fib_hash) {
380 if (!net_eq(fi->fib_net, net))
381 continue;
382 if (!fi->nh || fi->nh->id != cfg->fc_nh_id)
383 continue;
384 if (cfg->fc_protocol == fi->fib_protocol &&
385 cfg->fc_scope == fi->fib_scope &&
386 cfg->fc_prefsrc == fi->fib_prefsrc &&
387 cfg->fc_priority == fi->fib_priority &&
388 cfg->fc_type == fi->fib_type &&
389 cfg->fc_table == fi->fib_tb_id &&
390 !((cfg->fc_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK))
391 return fi;
392 }
393
394 return NULL;
395}
396
397static struct fib_info *fib_find_info(struct fib_info *nfi)
398{
399 struct hlist_head *head;
400 struct fib_info *fi;
401 unsigned int hash;
402
403 hash = fib_info_hashfn(nfi);
404 head = &fib_info_hash[hash];
405
406 hlist_for_each_entry(fi, head, fib_hash) {
407 if (!net_eq(fi->fib_net, nfi->fib_net))
408 continue;
409 if (fi->fib_nhs != nfi->fib_nhs)
410 continue;
411 if (nfi->fib_protocol == fi->fib_protocol &&
412 nfi->fib_scope == fi->fib_scope &&
413 nfi->fib_prefsrc == fi->fib_prefsrc &&
414 nfi->fib_priority == fi->fib_priority &&
415 nfi->fib_type == fi->fib_type &&
416 memcmp(nfi->fib_metrics, fi->fib_metrics,
417 sizeof(u32) * RTAX_MAX) == 0 &&
418 !((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) &&
419 nh_comp(fi, nfi) == 0)
420 return fi;
421 }
422
423 return NULL;
424}
425
426
427
428
429int ip_fib_check_default(__be32 gw, struct net_device *dev)
430{
431 struct hlist_head *head;
432 struct fib_nh *nh;
433 unsigned int hash;
434
435 spin_lock(&fib_info_lock);
436
437 hash = fib_devindex_hashfn(dev->ifindex);
438 head = &fib_info_devhash[hash];
439 hlist_for_each_entry(nh, head, nh_hash) {
440 if (nh->fib_nh_dev == dev &&
441 nh->fib_nh_gw4 == gw &&
442 !(nh->fib_nh_flags & RTNH_F_DEAD)) {
443 spin_unlock(&fib_info_lock);
444 return 0;
445 }
446 }
447
448 spin_unlock(&fib_info_lock);
449
450 return -1;
451}
452
453size_t fib_nlmsg_size(struct fib_info *fi)
454{
455 size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg))
456 + nla_total_size(4)
457 + nla_total_size(4)
458 + nla_total_size(4)
459 + nla_total_size(4)
460 + nla_total_size(TCP_CA_NAME_MAX);
461 unsigned int nhs = fib_info_num_path(fi);
462
463
464 payload += nla_total_size((RTAX_MAX * nla_total_size(4)));
465
466 if (fi->nh)
467 payload += nla_total_size(4);
468
469 if (nhs) {
470 size_t nh_encapsize = 0;
471
472
473
474 size_t nhsize = nla_total_size(sizeof(struct rtnexthop));
475 unsigned int i;
476
477
478 nhsize += 2 * nla_total_size(4);
479
480
481 for (i = 0; i < fib_info_num_path(fi); i++) {
482 struct fib_nh_common *nhc = fib_info_nhc(fi, i);
483
484 if (nhc->nhc_lwtstate) {
485
486 nh_encapsize += lwtunnel_get_encap_size(
487 nhc->nhc_lwtstate);
488
489 nh_encapsize += nla_total_size(2);
490 }
491 }
492
493
494 payload += nla_total_size((nhs * nhsize) + nh_encapsize);
495
496 }
497
498 return payload;
499}
500
501void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
502 int dst_len, u32 tb_id, const struct nl_info *info,
503 unsigned int nlm_flags)
504{
505 struct fib_rt_info fri;
506 struct sk_buff *skb;
507 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
508 int err = -ENOBUFS;
509
510 skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
511 if (!skb)
512 goto errout;
513
514 fri.fi = fa->fa_info;
515 fri.tb_id = tb_id;
516 fri.dst = key;
517 fri.dst_len = dst_len;
518 fri.tos = fa->fa_tos;
519 fri.type = fa->fa_type;
520 fri.offload = fa->offload;
521 fri.trap = fa->trap;
522 fri.offload_failed = fa->offload_failed;
523 err = fib_dump_info(skb, info->portid, seq, event, &fri, nlm_flags);
524 if (err < 0) {
525
526 WARN_ON(err == -EMSGSIZE);
527 kfree_skb(skb);
528 goto errout;
529 }
530 rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV4_ROUTE,
531 info->nlh, GFP_KERNEL);
532 return;
533errout:
534 if (err < 0)
535 rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err);
536}
537
538static int fib_detect_death(struct fib_info *fi, int order,
539 struct fib_info **last_resort, int *last_idx,
540 int dflt)
541{
542 const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
543 struct neighbour *n;
544 int state = NUD_NONE;
545
546 if (likely(nhc->nhc_gw_family == AF_INET))
547 n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev);
548 else if (nhc->nhc_gw_family == AF_INET6)
549 n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6,
550 nhc->nhc_dev);
551 else
552 n = NULL;
553
554 if (n) {
555 state = n->nud_state;
556 neigh_release(n);
557 } else {
558 return 0;
559 }
560 if (state == NUD_REACHABLE)
561 return 0;
562 if ((state & NUD_VALID) && order != dflt)
563 return 0;
564 if ((state & NUD_VALID) ||
565 (*last_idx < 0 && order > dflt && state != NUD_INCOMPLETE)) {
566 *last_resort = fi;
567 *last_idx = order;
568 }
569 return 1;
570}
571
572int fib_nh_common_init(struct net *net, struct fib_nh_common *nhc,
573 struct nlattr *encap, u16 encap_type,
574 void *cfg, gfp_t gfp_flags,
575 struct netlink_ext_ack *extack)
576{
577 int err;
578
579 nhc->nhc_pcpu_rth_output = alloc_percpu_gfp(struct rtable __rcu *,
580 gfp_flags);
581 if (!nhc->nhc_pcpu_rth_output)
582 return -ENOMEM;
583
584 if (encap) {
585 struct lwtunnel_state *lwtstate;
586
587 if (encap_type == LWTUNNEL_ENCAP_NONE) {
588 NL_SET_ERR_MSG(extack, "LWT encap type not specified");
589 err = -EINVAL;
590 goto lwt_failure;
591 }
592 err = lwtunnel_build_state(net, encap_type, encap,
593 nhc->nhc_family, cfg, &lwtstate,
594 extack);
595 if (err)
596 goto lwt_failure;
597
598 nhc->nhc_lwtstate = lwtstate_get(lwtstate);
599 }
600
601 return 0;
602
603lwt_failure:
604 rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
605 nhc->nhc_pcpu_rth_output = NULL;
606 return err;
607}
608EXPORT_SYMBOL_GPL(fib_nh_common_init);
609
610int fib_nh_init(struct net *net, struct fib_nh *nh,
611 struct fib_config *cfg, int nh_weight,
612 struct netlink_ext_ack *extack)
613{
614 int err;
615
616 nh->fib_nh_family = AF_INET;
617
618 err = fib_nh_common_init(net, &nh->nh_common, cfg->fc_encap,
619 cfg->fc_encap_type, cfg, GFP_KERNEL, extack);
620 if (err)
621 return err;
622
623 nh->fib_nh_oif = cfg->fc_oif;
624 nh->fib_nh_gw_family = cfg->fc_gw_family;
625 if (cfg->fc_gw_family == AF_INET)
626 nh->fib_nh_gw4 = cfg->fc_gw4;
627 else if (cfg->fc_gw_family == AF_INET6)
628 nh->fib_nh_gw6 = cfg->fc_gw6;
629
630 nh->fib_nh_flags = cfg->fc_flags;
631
632#ifdef CONFIG_IP_ROUTE_CLASSID
633 nh->nh_tclassid = cfg->fc_flow;
634 if (nh->nh_tclassid)
635 net->ipv4.fib_num_tclassid_users++;
636#endif
637#ifdef CONFIG_IP_ROUTE_MULTIPATH
638 nh->fib_nh_weight = nh_weight;
639#endif
640 return 0;
641}
642
643#ifdef CONFIG_IP_ROUTE_MULTIPATH
644
645static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining,
646 struct netlink_ext_ack *extack)
647{
648 int nhs = 0;
649
650 while (rtnh_ok(rtnh, remaining)) {
651 nhs++;
652 rtnh = rtnh_next(rtnh, &remaining);
653 }
654
655
656 if (remaining > 0) {
657 NL_SET_ERR_MSG(extack,
658 "Invalid nexthop configuration - extra data after nexthops");
659 nhs = 0;
660 }
661
662 return nhs;
663}
664
665
666static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
667 int remaining, struct fib_config *cfg,
668 struct netlink_ext_ack *extack)
669{
670 struct net *net = fi->fib_net;
671 struct fib_config fib_cfg;
672 struct fib_nh *nh;
673 int ret;
674
675 change_nexthops(fi) {
676 int attrlen;
677
678 memset(&fib_cfg, 0, sizeof(fib_cfg));
679
680 if (!rtnh_ok(rtnh, remaining)) {
681 NL_SET_ERR_MSG(extack,
682 "Invalid nexthop configuration - extra data after nexthop");
683 return -EINVAL;
684 }
685
686 if (rtnh->rtnh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
687 NL_SET_ERR_MSG(extack,
688 "Invalid flags for nexthop - can not contain DEAD or LINKDOWN");
689 return -EINVAL;
690 }
691
692 fib_cfg.fc_flags = (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags;
693 fib_cfg.fc_oif = rtnh->rtnh_ifindex;
694
695 attrlen = rtnh_attrlen(rtnh);
696 if (attrlen > 0) {
697 struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh);
698
699 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
700 nlav = nla_find(attrs, attrlen, RTA_VIA);
701 if (nla && nlav) {
702 NL_SET_ERR_MSG(extack,
703 "Nexthop configuration can not contain both GATEWAY and VIA");
704 return -EINVAL;
705 }
706 if (nla) {
707 fib_cfg.fc_gw4 = nla_get_in_addr(nla);
708 if (fib_cfg.fc_gw4)
709 fib_cfg.fc_gw_family = AF_INET;
710 } else if (nlav) {
711 ret = fib_gw_from_via(&fib_cfg, nlav, extack);
712 if (ret)
713 goto errout;
714 }
715
716 nla = nla_find(attrs, attrlen, RTA_FLOW);
717 if (nla)
718 fib_cfg.fc_flow = nla_get_u32(nla);
719
720 fib_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
721 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
722 if (nla)
723 fib_cfg.fc_encap_type = nla_get_u16(nla);
724 }
725
726 ret = fib_nh_init(net, nexthop_nh, &fib_cfg,
727 rtnh->rtnh_hops + 1, extack);
728 if (ret)
729 goto errout;
730
731 rtnh = rtnh_next(rtnh, &remaining);
732 } endfor_nexthops(fi);
733
734 ret = -EINVAL;
735 nh = fib_info_nh(fi, 0);
736 if (cfg->fc_oif && nh->fib_nh_oif != cfg->fc_oif) {
737 NL_SET_ERR_MSG(extack,
738 "Nexthop device index does not match RTA_OIF");
739 goto errout;
740 }
741 if (cfg->fc_gw_family) {
742 if (cfg->fc_gw_family != nh->fib_nh_gw_family ||
743 (cfg->fc_gw_family == AF_INET &&
744 nh->fib_nh_gw4 != cfg->fc_gw4) ||
745 (cfg->fc_gw_family == AF_INET6 &&
746 ipv6_addr_cmp(&nh->fib_nh_gw6, &cfg->fc_gw6))) {
747 NL_SET_ERR_MSG(extack,
748 "Nexthop gateway does not match RTA_GATEWAY or RTA_VIA");
749 goto errout;
750 }
751 }
752#ifdef CONFIG_IP_ROUTE_CLASSID
753 if (cfg->fc_flow && nh->nh_tclassid != cfg->fc_flow) {
754 NL_SET_ERR_MSG(extack,
755 "Nexthop class id does not match RTA_FLOW");
756 goto errout;
757 }
758#endif
759 ret = 0;
760errout:
761 return ret;
762}
763
764
765static void fib_rebalance(struct fib_info *fi)
766{
767 int total;
768 int w;
769
770 if (fib_info_num_path(fi) < 2)
771 return;
772
773 total = 0;
774 for_nexthops(fi) {
775 if (nh->fib_nh_flags & RTNH_F_DEAD)
776 continue;
777
778 if (ip_ignore_linkdown(nh->fib_nh_dev) &&
779 nh->fib_nh_flags & RTNH_F_LINKDOWN)
780 continue;
781
782 total += nh->fib_nh_weight;
783 } endfor_nexthops(fi);
784
785 w = 0;
786 change_nexthops(fi) {
787 int upper_bound;
788
789 if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) {
790 upper_bound = -1;
791 } else if (ip_ignore_linkdown(nexthop_nh->fib_nh_dev) &&
792 nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) {
793 upper_bound = -1;
794 } else {
795 w += nexthop_nh->fib_nh_weight;
796 upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31,
797 total) - 1;
798 }
799
800 atomic_set(&nexthop_nh->fib_nh_upper_bound, upper_bound);
801 } endfor_nexthops(fi);
802}
803#else
804
805static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
806 int remaining, struct fib_config *cfg,
807 struct netlink_ext_ack *extack)
808{
809 NL_SET_ERR_MSG(extack, "Multipath support not enabled in kernel");
810
811 return -EINVAL;
812}
813
814#define fib_rebalance(fi) do { } while (0)
815
816#endif
817
818static int fib_encap_match(struct net *net, u16 encap_type,
819 struct nlattr *encap,
820 const struct fib_nh *nh,
821 const struct fib_config *cfg,
822 struct netlink_ext_ack *extack)
823{
824 struct lwtunnel_state *lwtstate;
825 int ret, result = 0;
826
827 if (encap_type == LWTUNNEL_ENCAP_NONE)
828 return 0;
829
830 ret = lwtunnel_build_state(net, encap_type, encap, AF_INET,
831 cfg, &lwtstate, extack);
832 if (!ret) {
833 result = lwtunnel_cmp_encap(lwtstate, nh->fib_nh_lws);
834 lwtstate_free(lwtstate);
835 }
836
837 return result;
838}
839
840int fib_nh_match(struct net *net, struct fib_config *cfg, struct fib_info *fi,
841 struct netlink_ext_ack *extack)
842{
843#ifdef CONFIG_IP_ROUTE_MULTIPATH
844 struct rtnexthop *rtnh;
845 int remaining;
846#endif
847
848 if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority)
849 return 1;
850
851 if (cfg->fc_nh_id) {
852 if (fi->nh && cfg->fc_nh_id == fi->nh->id)
853 return 0;
854 return 1;
855 }
856
857 if (cfg->fc_oif || cfg->fc_gw_family) {
858 struct fib_nh *nh = fib_info_nh(fi, 0);
859
860 if (cfg->fc_encap) {
861 if (fib_encap_match(net, cfg->fc_encap_type,
862 cfg->fc_encap, nh, cfg, extack))
863 return 1;
864 }
865#ifdef CONFIG_IP_ROUTE_CLASSID
866 if (cfg->fc_flow &&
867 cfg->fc_flow != nh->nh_tclassid)
868 return 1;
869#endif
870 if ((cfg->fc_oif && cfg->fc_oif != nh->fib_nh_oif) ||
871 (cfg->fc_gw_family &&
872 cfg->fc_gw_family != nh->fib_nh_gw_family))
873 return 1;
874
875 if (cfg->fc_gw_family == AF_INET &&
876 cfg->fc_gw4 != nh->fib_nh_gw4)
877 return 1;
878
879 if (cfg->fc_gw_family == AF_INET6 &&
880 ipv6_addr_cmp(&cfg->fc_gw6, &nh->fib_nh_gw6))
881 return 1;
882
883 return 0;
884 }
885
886#ifdef CONFIG_IP_ROUTE_MULTIPATH
887 if (!cfg->fc_mp)
888 return 0;
889
890 rtnh = cfg->fc_mp;
891 remaining = cfg->fc_mp_len;
892
893 for_nexthops(fi) {
894 int attrlen;
895
896 if (!rtnh_ok(rtnh, remaining))
897 return -EINVAL;
898
899 if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->fib_nh_oif)
900 return 1;
901
902 attrlen = rtnh_attrlen(rtnh);
903 if (attrlen > 0) {
904 struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh);
905
906 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
907 nlav = nla_find(attrs, attrlen, RTA_VIA);
908 if (nla && nlav) {
909 NL_SET_ERR_MSG(extack,
910 "Nexthop configuration can not contain both GATEWAY and VIA");
911 return -EINVAL;
912 }
913
914 if (nla) {
915 if (nh->fib_nh_gw_family != AF_INET ||
916 nla_get_in_addr(nla) != nh->fib_nh_gw4)
917 return 1;
918 } else if (nlav) {
919 struct fib_config cfg2;
920 int err;
921
922 err = fib_gw_from_via(&cfg2, nlav, extack);
923 if (err)
924 return err;
925
926 switch (nh->fib_nh_gw_family) {
927 case AF_INET:
928 if (cfg2.fc_gw_family != AF_INET ||
929 cfg2.fc_gw4 != nh->fib_nh_gw4)
930 return 1;
931 break;
932 case AF_INET6:
933 if (cfg2.fc_gw_family != AF_INET6 ||
934 ipv6_addr_cmp(&cfg2.fc_gw6,
935 &nh->fib_nh_gw6))
936 return 1;
937 break;
938 }
939 }
940
941#ifdef CONFIG_IP_ROUTE_CLASSID
942 nla = nla_find(attrs, attrlen, RTA_FLOW);
943 if (nla && nla_get_u32(nla) != nh->nh_tclassid)
944 return 1;
945#endif
946 }
947
948 rtnh = rtnh_next(rtnh, &remaining);
949 } endfor_nexthops(fi);
950#endif
951 return 0;
952}
953
954bool fib_metrics_match(struct fib_config *cfg, struct fib_info *fi)
955{
956 struct nlattr *nla;
957 int remaining;
958
959 if (!cfg->fc_mx)
960 return true;
961
962 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
963 int type = nla_type(nla);
964 u32 fi_val, val;
965
966 if (!type)
967 continue;
968 if (type > RTAX_MAX)
969 return false;
970
971 if (type == RTAX_CC_ALGO) {
972 char tmp[TCP_CA_NAME_MAX];
973 bool ecn_ca = false;
974
975 nla_strscpy(tmp, nla, sizeof(tmp));
976 val = tcp_ca_get_key_by_name(fi->fib_net, tmp, &ecn_ca);
977 } else {
978 if (nla_len(nla) != sizeof(u32))
979 return false;
980 val = nla_get_u32(nla);
981 }
982
983 fi_val = fi->fib_metrics->metrics[type - 1];
984 if (type == RTAX_FEATURES)
985 fi_val &= ~DST_FEATURE_ECN_CA;
986
987 if (fi_val != val)
988 return false;
989 }
990
991 return true;
992}
993
994static int fib_check_nh_v6_gw(struct net *net, struct fib_nh *nh,
995 u32 table, struct netlink_ext_ack *extack)
996{
997 struct fib6_config cfg = {
998 .fc_table = table,
999 .fc_flags = nh->fib_nh_flags | RTF_GATEWAY,
1000 .fc_ifindex = nh->fib_nh_oif,
1001 .fc_gateway = nh->fib_nh_gw6,
1002 };
1003 struct fib6_nh fib6_nh = {};
1004 int err;
1005
1006 err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack);
1007 if (!err) {
1008 nh->fib_nh_dev = fib6_nh.fib_nh_dev;
1009 dev_hold(nh->fib_nh_dev);
1010 nh->fib_nh_oif = nh->fib_nh_dev->ifindex;
1011 nh->fib_nh_scope = RT_SCOPE_LINK;
1012
1013 ipv6_stub->fib6_nh_release(&fib6_nh);
1014 }
1015
1016 return err;
1017}
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062static int fib_check_nh_v4_gw(struct net *net, struct fib_nh *nh, u32 table,
1063 u8 scope, struct netlink_ext_ack *extack)
1064{
1065 struct net_device *dev;
1066 struct fib_result res;
1067 int err = 0;
1068
1069 if (nh->fib_nh_flags & RTNH_F_ONLINK) {
1070 unsigned int addr_type;
1071
1072 if (scope >= RT_SCOPE_LINK) {
1073 NL_SET_ERR_MSG(extack, "Nexthop has invalid scope");
1074 return -EINVAL;
1075 }
1076 dev = __dev_get_by_index(net, nh->fib_nh_oif);
1077 if (!dev) {
1078 NL_SET_ERR_MSG(extack, "Nexthop device required for onlink");
1079 return -ENODEV;
1080 }
1081 if (!(dev->flags & IFF_UP)) {
1082 NL_SET_ERR_MSG(extack, "Nexthop device is not up");
1083 return -ENETDOWN;
1084 }
1085 addr_type = inet_addr_type_dev_table(net, dev, nh->fib_nh_gw4);
1086 if (addr_type != RTN_UNICAST) {
1087 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1088 return -EINVAL;
1089 }
1090 if (!netif_carrier_ok(dev))
1091 nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1092 nh->fib_nh_dev = dev;
1093 dev_hold(dev);
1094 nh->fib_nh_scope = RT_SCOPE_LINK;
1095 return 0;
1096 }
1097 rcu_read_lock();
1098 {
1099 struct fib_table *tbl = NULL;
1100 struct flowi4 fl4 = {
1101 .daddr = nh->fib_nh_gw4,
1102 .flowi4_scope = scope + 1,
1103 .flowi4_oif = nh->fib_nh_oif,
1104 .flowi4_iif = LOOPBACK_IFINDEX,
1105 };
1106
1107
1108 if (fl4.flowi4_scope < RT_SCOPE_LINK)
1109 fl4.flowi4_scope = RT_SCOPE_LINK;
1110
1111 if (table && table != RT_TABLE_MAIN)
1112 tbl = fib_get_table(net, table);
1113
1114 if (tbl)
1115 err = fib_table_lookup(tbl, &fl4, &res,
1116 FIB_LOOKUP_IGNORE_LINKSTATE |
1117 FIB_LOOKUP_NOREF);
1118
1119
1120
1121
1122
1123 if (!tbl || err) {
1124 err = fib_lookup(net, &fl4, &res,
1125 FIB_LOOKUP_IGNORE_LINKSTATE);
1126 }
1127
1128 if (err) {
1129 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1130 goto out;
1131 }
1132 }
1133
1134 err = -EINVAL;
1135 if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) {
1136 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1137 goto out;
1138 }
1139 nh->fib_nh_scope = res.scope;
1140 nh->fib_nh_oif = FIB_RES_OIF(res);
1141 nh->fib_nh_dev = dev = FIB_RES_DEV(res);
1142 if (!dev) {
1143 NL_SET_ERR_MSG(extack,
1144 "No egress device for nexthop gateway");
1145 goto out;
1146 }
1147 dev_hold(dev);
1148 if (!netif_carrier_ok(dev))
1149 nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1150 err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN;
1151out:
1152 rcu_read_unlock();
1153 return err;
1154}
1155
1156static int fib_check_nh_nongw(struct net *net, struct fib_nh *nh,
1157 struct netlink_ext_ack *extack)
1158{
1159 struct in_device *in_dev;
1160 int err;
1161
1162 if (nh->fib_nh_flags & (RTNH_F_PERVASIVE | RTNH_F_ONLINK)) {
1163 NL_SET_ERR_MSG(extack,
1164 "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set");
1165 return -EINVAL;
1166 }
1167
1168 rcu_read_lock();
1169
1170 err = -ENODEV;
1171 in_dev = inetdev_by_index(net, nh->fib_nh_oif);
1172 if (!in_dev)
1173 goto out;
1174 err = -ENETDOWN;
1175 if (!(in_dev->dev->flags & IFF_UP)) {
1176 NL_SET_ERR_MSG(extack, "Device for nexthop is not up");
1177 goto out;
1178 }
1179
1180 nh->fib_nh_dev = in_dev->dev;
1181 dev_hold(nh->fib_nh_dev);
1182 nh->fib_nh_scope = RT_SCOPE_HOST;
1183 if (!netif_carrier_ok(nh->fib_nh_dev))
1184 nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1185 err = 0;
1186out:
1187 rcu_read_unlock();
1188 return err;
1189}
1190
1191int fib_check_nh(struct net *net, struct fib_nh *nh, u32 table, u8 scope,
1192 struct netlink_ext_ack *extack)
1193{
1194 int err;
1195
1196 if (nh->fib_nh_gw_family == AF_INET)
1197 err = fib_check_nh_v4_gw(net, nh, table, scope, extack);
1198 else if (nh->fib_nh_gw_family == AF_INET6)
1199 err = fib_check_nh_v6_gw(net, nh, table, extack);
1200 else
1201 err = fib_check_nh_nongw(net, nh, extack);
1202
1203 return err;
1204}
1205
1206static inline unsigned int fib_laddr_hashfn(__be32 val)
1207{
1208 unsigned int mask = (fib_info_hash_size - 1);
1209
1210 return ((__force u32)val ^
1211 ((__force u32)val >> 7) ^
1212 ((__force u32)val >> 14)) & mask;
1213}
1214
1215static struct hlist_head *fib_info_hash_alloc(int bytes)
1216{
1217 if (bytes <= PAGE_SIZE)
1218 return kzalloc(bytes, GFP_KERNEL);
1219 else
1220 return (struct hlist_head *)
1221 __get_free_pages(GFP_KERNEL | __GFP_ZERO,
1222 get_order(bytes));
1223}
1224
1225static void fib_info_hash_free(struct hlist_head *hash, int bytes)
1226{
1227 if (!hash)
1228 return;
1229
1230 if (bytes <= PAGE_SIZE)
1231 kfree(hash);
1232 else
1233 free_pages((unsigned long) hash, get_order(bytes));
1234}
1235
1236static void fib_info_hash_move(struct hlist_head *new_info_hash,
1237 struct hlist_head *new_laddrhash,
1238 unsigned int new_size)
1239{
1240 struct hlist_head *old_info_hash, *old_laddrhash;
1241 unsigned int old_size = fib_info_hash_size;
1242 unsigned int i, bytes;
1243
1244 spin_lock_bh(&fib_info_lock);
1245 old_info_hash = fib_info_hash;
1246 old_laddrhash = fib_info_laddrhash;
1247 fib_info_hash_size = new_size;
1248
1249 for (i = 0; i < old_size; i++) {
1250 struct hlist_head *head = &fib_info_hash[i];
1251 struct hlist_node *n;
1252 struct fib_info *fi;
1253
1254 hlist_for_each_entry_safe(fi, n, head, fib_hash) {
1255 struct hlist_head *dest;
1256 unsigned int new_hash;
1257
1258 new_hash = fib_info_hashfn(fi);
1259 dest = &new_info_hash[new_hash];
1260 hlist_add_head(&fi->fib_hash, dest);
1261 }
1262 }
1263 fib_info_hash = new_info_hash;
1264
1265 for (i = 0; i < old_size; i++) {
1266 struct hlist_head *lhead = &fib_info_laddrhash[i];
1267 struct hlist_node *n;
1268 struct fib_info *fi;
1269
1270 hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) {
1271 struct hlist_head *ldest;
1272 unsigned int new_hash;
1273
1274 new_hash = fib_laddr_hashfn(fi->fib_prefsrc);
1275 ldest = &new_laddrhash[new_hash];
1276 hlist_add_head(&fi->fib_lhash, ldest);
1277 }
1278 }
1279 fib_info_laddrhash = new_laddrhash;
1280
1281 spin_unlock_bh(&fib_info_lock);
1282
1283 bytes = old_size * sizeof(struct hlist_head *);
1284 fib_info_hash_free(old_info_hash, bytes);
1285 fib_info_hash_free(old_laddrhash, bytes);
1286}
1287
1288__be32 fib_info_update_nhc_saddr(struct net *net, struct fib_nh_common *nhc,
1289 unsigned char scope)
1290{
1291 struct fib_nh *nh;
1292
1293 if (nhc->nhc_family != AF_INET)
1294 return inet_select_addr(nhc->nhc_dev, 0, scope);
1295
1296 nh = container_of(nhc, struct fib_nh, nh_common);
1297 nh->nh_saddr = inet_select_addr(nh->fib_nh_dev, nh->fib_nh_gw4, scope);
1298 nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid);
1299
1300 return nh->nh_saddr;
1301}
1302
1303__be32 fib_result_prefsrc(struct net *net, struct fib_result *res)
1304{
1305 struct fib_nh_common *nhc = res->nhc;
1306
1307 if (res->fi->fib_prefsrc)
1308 return res->fi->fib_prefsrc;
1309
1310 if (nhc->nhc_family == AF_INET) {
1311 struct fib_nh *nh;
1312
1313 nh = container_of(nhc, struct fib_nh, nh_common);
1314 if (nh->nh_saddr_genid == atomic_read(&net->ipv4.dev_addr_genid))
1315 return nh->nh_saddr;
1316 }
1317
1318 return fib_info_update_nhc_saddr(net, nhc, res->fi->fib_scope);
1319}
1320
1321static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc)
1322{
1323 if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst ||
1324 fib_prefsrc != cfg->fc_dst) {
1325 u32 tb_id = cfg->fc_table;
1326 int rc;
1327
1328 if (tb_id == RT_TABLE_MAIN)
1329 tb_id = RT_TABLE_LOCAL;
1330
1331 rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1332 fib_prefsrc, tb_id);
1333
1334 if (rc != RTN_LOCAL && tb_id != RT_TABLE_LOCAL) {
1335 rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1336 fib_prefsrc, RT_TABLE_LOCAL);
1337 }
1338
1339 if (rc != RTN_LOCAL)
1340 return false;
1341 }
1342 return true;
1343}
1344
1345struct fib_info *fib_create_info(struct fib_config *cfg,
1346 struct netlink_ext_ack *extack)
1347{
1348 int err;
1349 struct fib_info *fi = NULL;
1350 struct nexthop *nh = NULL;
1351 struct fib_info *ofi;
1352 int nhs = 1;
1353 struct net *net = cfg->fc_nlinfo.nl_net;
1354
1355 if (cfg->fc_type > RTN_MAX)
1356 goto err_inval;
1357
1358
1359 if (fib_props[cfg->fc_type].scope > cfg->fc_scope) {
1360 NL_SET_ERR_MSG(extack, "Invalid scope");
1361 goto err_inval;
1362 }
1363
1364 if (cfg->fc_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
1365 NL_SET_ERR_MSG(extack,
1366 "Invalid rtm_flags - can not contain DEAD or LINKDOWN");
1367 goto err_inval;
1368 }
1369
1370 if (cfg->fc_nh_id) {
1371 if (!cfg->fc_mx) {
1372 fi = fib_find_info_nh(net, cfg);
1373 if (fi) {
1374 refcount_inc(&fi->fib_treeref);
1375 return fi;
1376 }
1377 }
1378
1379 nh = nexthop_find_by_id(net, cfg->fc_nh_id);
1380 if (!nh) {
1381 NL_SET_ERR_MSG(extack, "Nexthop id does not exist");
1382 goto err_inval;
1383 }
1384 nhs = 0;
1385 }
1386
1387#ifdef CONFIG_IP_ROUTE_MULTIPATH
1388 if (cfg->fc_mp) {
1389 nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack);
1390 if (nhs == 0)
1391 goto err_inval;
1392 }
1393#endif
1394
1395 err = -ENOBUFS;
1396 if (fib_info_cnt >= fib_info_hash_size) {
1397 unsigned int new_size = fib_info_hash_size << 1;
1398 struct hlist_head *new_info_hash;
1399 struct hlist_head *new_laddrhash;
1400 unsigned int bytes;
1401
1402 if (!new_size)
1403 new_size = 16;
1404 bytes = new_size * sizeof(struct hlist_head *);
1405 new_info_hash = fib_info_hash_alloc(bytes);
1406 new_laddrhash = fib_info_hash_alloc(bytes);
1407 if (!new_info_hash || !new_laddrhash) {
1408 fib_info_hash_free(new_info_hash, bytes);
1409 fib_info_hash_free(new_laddrhash, bytes);
1410 } else
1411 fib_info_hash_move(new_info_hash, new_laddrhash, new_size);
1412
1413 if (!fib_info_hash_size)
1414 goto failure;
1415 }
1416
1417 fi = kzalloc(struct_size(fi, fib_nh, nhs), GFP_KERNEL);
1418 if (!fi)
1419 goto failure;
1420 fi->fib_metrics = ip_fib_metrics_init(fi->fib_net, cfg->fc_mx,
1421 cfg->fc_mx_len, extack);
1422 if (IS_ERR(fi->fib_metrics)) {
1423 err = PTR_ERR(fi->fib_metrics);
1424 kfree(fi);
1425 return ERR_PTR(err);
1426 }
1427
1428 fib_info_cnt++;
1429 fi->fib_net = net;
1430 fi->fib_protocol = cfg->fc_protocol;
1431 fi->fib_scope = cfg->fc_scope;
1432 fi->fib_flags = cfg->fc_flags;
1433 fi->fib_priority = cfg->fc_priority;
1434 fi->fib_prefsrc = cfg->fc_prefsrc;
1435 fi->fib_type = cfg->fc_type;
1436 fi->fib_tb_id = cfg->fc_table;
1437
1438 fi->fib_nhs = nhs;
1439 if (nh) {
1440 if (!nexthop_get(nh)) {
1441 NL_SET_ERR_MSG(extack, "Nexthop has been deleted");
1442 err = -EINVAL;
1443 } else {
1444 err = 0;
1445 fi->nh = nh;
1446 }
1447 } else {
1448 change_nexthops(fi) {
1449 nexthop_nh->nh_parent = fi;
1450 } endfor_nexthops(fi)
1451
1452 if (cfg->fc_mp)
1453 err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg,
1454 extack);
1455 else
1456 err = fib_nh_init(net, fi->fib_nh, cfg, 1, extack);
1457 }
1458
1459 if (err != 0)
1460 goto failure;
1461
1462 if (fib_props[cfg->fc_type].error) {
1463 if (cfg->fc_gw_family || cfg->fc_oif || cfg->fc_mp) {
1464 NL_SET_ERR_MSG(extack,
1465 "Gateway, device and multipath can not be specified for this route type");
1466 goto err_inval;
1467 }
1468 goto link_it;
1469 } else {
1470 switch (cfg->fc_type) {
1471 case RTN_UNICAST:
1472 case RTN_LOCAL:
1473 case RTN_BROADCAST:
1474 case RTN_ANYCAST:
1475 case RTN_MULTICAST:
1476 break;
1477 default:
1478 NL_SET_ERR_MSG(extack, "Invalid route type");
1479 goto err_inval;
1480 }
1481 }
1482
1483 if (cfg->fc_scope > RT_SCOPE_HOST) {
1484 NL_SET_ERR_MSG(extack, "Invalid scope");
1485 goto err_inval;
1486 }
1487
1488 if (fi->nh) {
1489 err = fib_check_nexthop(fi->nh, cfg->fc_scope, extack);
1490 if (err)
1491 goto failure;
1492 } else if (cfg->fc_scope == RT_SCOPE_HOST) {
1493 struct fib_nh *nh = fi->fib_nh;
1494
1495
1496 if (nhs != 1) {
1497 NL_SET_ERR_MSG(extack,
1498 "Route with host scope can not have multiple nexthops");
1499 goto err_inval;
1500 }
1501 if (nh->fib_nh_gw_family) {
1502 NL_SET_ERR_MSG(extack,
1503 "Route with host scope can not have a gateway");
1504 goto err_inval;
1505 }
1506 nh->fib_nh_scope = RT_SCOPE_NOWHERE;
1507 nh->fib_nh_dev = dev_get_by_index(net, nh->fib_nh_oif);
1508 err = -ENODEV;
1509 if (!nh->fib_nh_dev)
1510 goto failure;
1511 } else {
1512 int linkdown = 0;
1513
1514 change_nexthops(fi) {
1515 err = fib_check_nh(cfg->fc_nlinfo.nl_net, nexthop_nh,
1516 cfg->fc_table, cfg->fc_scope,
1517 extack);
1518 if (err != 0)
1519 goto failure;
1520 if (nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN)
1521 linkdown++;
1522 } endfor_nexthops(fi)
1523 if (linkdown == fi->fib_nhs)
1524 fi->fib_flags |= RTNH_F_LINKDOWN;
1525 }
1526
1527 if (fi->fib_prefsrc && !fib_valid_prefsrc(cfg, fi->fib_prefsrc)) {
1528 NL_SET_ERR_MSG(extack, "Invalid prefsrc address");
1529 goto err_inval;
1530 }
1531
1532 if (!fi->nh) {
1533 change_nexthops(fi) {
1534 fib_info_update_nhc_saddr(net, &nexthop_nh->nh_common,
1535 fi->fib_scope);
1536 if (nexthop_nh->fib_nh_gw_family == AF_INET6)
1537 fi->fib_nh_is_v6 = true;
1538 } endfor_nexthops(fi)
1539
1540 fib_rebalance(fi);
1541 }
1542
1543link_it:
1544 ofi = fib_find_info(fi);
1545 if (ofi) {
1546 fi->fib_dead = 1;
1547 free_fib_info(fi);
1548 refcount_inc(&ofi->fib_treeref);
1549 return ofi;
1550 }
1551
1552 refcount_set(&fi->fib_treeref, 1);
1553 refcount_set(&fi->fib_clntref, 1);
1554 spin_lock_bh(&fib_info_lock);
1555 hlist_add_head(&fi->fib_hash,
1556 &fib_info_hash[fib_info_hashfn(fi)]);
1557 if (fi->fib_prefsrc) {
1558 struct hlist_head *head;
1559
1560 head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)];
1561 hlist_add_head(&fi->fib_lhash, head);
1562 }
1563 if (fi->nh) {
1564 list_add(&fi->nh_list, &nh->fi_list);
1565 } else {
1566 change_nexthops(fi) {
1567 struct hlist_head *head;
1568 unsigned int hash;
1569
1570 if (!nexthop_nh->fib_nh_dev)
1571 continue;
1572 hash = fib_devindex_hashfn(nexthop_nh->fib_nh_dev->ifindex);
1573 head = &fib_info_devhash[hash];
1574 hlist_add_head(&nexthop_nh->nh_hash, head);
1575 } endfor_nexthops(fi)
1576 }
1577 spin_unlock_bh(&fib_info_lock);
1578 return fi;
1579
1580err_inval:
1581 err = -EINVAL;
1582
1583failure:
1584 if (fi) {
1585 fi->fib_dead = 1;
1586 free_fib_info(fi);
1587 }
1588
1589 return ERR_PTR(err);
1590}
1591
1592int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nhc,
1593 u8 rt_family, unsigned char *flags, bool skip_oif)
1594{
1595 if (nhc->nhc_flags & RTNH_F_DEAD)
1596 *flags |= RTNH_F_DEAD;
1597
1598 if (nhc->nhc_flags & RTNH_F_LINKDOWN) {
1599 *flags |= RTNH_F_LINKDOWN;
1600
1601 rcu_read_lock();
1602 switch (nhc->nhc_family) {
1603 case AF_INET:
1604 if (ip_ignore_linkdown(nhc->nhc_dev))
1605 *flags |= RTNH_F_DEAD;
1606 break;
1607 case AF_INET6:
1608 if (ip6_ignore_linkdown(nhc->nhc_dev))
1609 *flags |= RTNH_F_DEAD;
1610 break;
1611 }
1612 rcu_read_unlock();
1613 }
1614
1615 switch (nhc->nhc_gw_family) {
1616 case AF_INET:
1617 if (nla_put_in_addr(skb, RTA_GATEWAY, nhc->nhc_gw.ipv4))
1618 goto nla_put_failure;
1619 break;
1620 case AF_INET6:
1621
1622
1623
1624 if (rt_family != nhc->nhc_gw_family) {
1625 int alen = sizeof(struct in6_addr);
1626 struct nlattr *nla;
1627 struct rtvia *via;
1628
1629 nla = nla_reserve(skb, RTA_VIA, alen + 2);
1630 if (!nla)
1631 goto nla_put_failure;
1632
1633 via = nla_data(nla);
1634 via->rtvia_family = AF_INET6;
1635 memcpy(via->rtvia_addr, &nhc->nhc_gw.ipv6, alen);
1636 } else if (nla_put_in6_addr(skb, RTA_GATEWAY,
1637 &nhc->nhc_gw.ipv6) < 0) {
1638 goto nla_put_failure;
1639 }
1640 break;
1641 }
1642
1643 *flags |= (nhc->nhc_flags &
1644 (RTNH_F_ONLINK | RTNH_F_OFFLOAD | RTNH_F_TRAP));
1645
1646 if (!skip_oif && nhc->nhc_dev &&
1647 nla_put_u32(skb, RTA_OIF, nhc->nhc_dev->ifindex))
1648 goto nla_put_failure;
1649
1650 if (nhc->nhc_lwtstate &&
1651 lwtunnel_fill_encap(skb, nhc->nhc_lwtstate,
1652 RTA_ENCAP, RTA_ENCAP_TYPE) < 0)
1653 goto nla_put_failure;
1654
1655 return 0;
1656
1657nla_put_failure:
1658 return -EMSGSIZE;
1659}
1660EXPORT_SYMBOL_GPL(fib_nexthop_info);
1661
1662#if IS_ENABLED(CONFIG_IP_ROUTE_MULTIPATH) || IS_ENABLED(CONFIG_IPV6)
1663int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nhc,
1664 int nh_weight, u8 rt_family, u32 nh_tclassid)
1665{
1666 const struct net_device *dev = nhc->nhc_dev;
1667 struct rtnexthop *rtnh;
1668 unsigned char flags = 0;
1669
1670 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
1671 if (!rtnh)
1672 goto nla_put_failure;
1673
1674 rtnh->rtnh_hops = nh_weight - 1;
1675 rtnh->rtnh_ifindex = dev ? dev->ifindex : 0;
1676
1677 if (fib_nexthop_info(skb, nhc, rt_family, &flags, true) < 0)
1678 goto nla_put_failure;
1679
1680 rtnh->rtnh_flags = flags;
1681
1682 if (nh_tclassid && nla_put_u32(skb, RTA_FLOW, nh_tclassid))
1683 goto nla_put_failure;
1684
1685
1686 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
1687
1688 return 0;
1689
1690nla_put_failure:
1691 return -EMSGSIZE;
1692}
1693EXPORT_SYMBOL_GPL(fib_add_nexthop);
1694#endif
1695
1696#ifdef CONFIG_IP_ROUTE_MULTIPATH
1697static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi)
1698{
1699 struct nlattr *mp;
1700
1701 mp = nla_nest_start_noflag(skb, RTA_MULTIPATH);
1702 if (!mp)
1703 goto nla_put_failure;
1704
1705 if (unlikely(fi->nh)) {
1706 if (nexthop_mpath_fill_node(skb, fi->nh, AF_INET) < 0)
1707 goto nla_put_failure;
1708 goto mp_end;
1709 }
1710
1711 for_nexthops(fi) {
1712 u32 nh_tclassid = 0;
1713#ifdef CONFIG_IP_ROUTE_CLASSID
1714 nh_tclassid = nh->nh_tclassid;
1715#endif
1716 if (fib_add_nexthop(skb, &nh->nh_common, nh->fib_nh_weight,
1717 AF_INET, nh_tclassid) < 0)
1718 goto nla_put_failure;
1719 } endfor_nexthops(fi);
1720
1721mp_end:
1722 nla_nest_end(skb, mp);
1723
1724 return 0;
1725
1726nla_put_failure:
1727 return -EMSGSIZE;
1728}
1729#else
1730static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi)
1731{
1732 return 0;
1733}
1734#endif
1735
1736int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
1737 const struct fib_rt_info *fri, unsigned int flags)
1738{
1739 unsigned int nhs = fib_info_num_path(fri->fi);
1740 struct fib_info *fi = fri->fi;
1741 u32 tb_id = fri->tb_id;
1742 struct nlmsghdr *nlh;
1743 struct rtmsg *rtm;
1744
1745 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags);
1746 if (!nlh)
1747 return -EMSGSIZE;
1748
1749 rtm = nlmsg_data(nlh);
1750 rtm->rtm_family = AF_INET;
1751 rtm->rtm_dst_len = fri->dst_len;
1752 rtm->rtm_src_len = 0;
1753 rtm->rtm_tos = fri->tos;
1754 if (tb_id < 256)
1755 rtm->rtm_table = tb_id;
1756 else
1757 rtm->rtm_table = RT_TABLE_COMPAT;
1758 if (nla_put_u32(skb, RTA_TABLE, tb_id))
1759 goto nla_put_failure;
1760 rtm->rtm_type = fri->type;
1761 rtm->rtm_flags = fi->fib_flags;
1762 rtm->rtm_scope = fi->fib_scope;
1763 rtm->rtm_protocol = fi->fib_protocol;
1764
1765 if (rtm->rtm_dst_len &&
1766 nla_put_in_addr(skb, RTA_DST, fri->dst))
1767 goto nla_put_failure;
1768 if (fi->fib_priority &&
1769 nla_put_u32(skb, RTA_PRIORITY, fi->fib_priority))
1770 goto nla_put_failure;
1771 if (rtnetlink_put_metrics(skb, fi->fib_metrics->metrics) < 0)
1772 goto nla_put_failure;
1773
1774 if (fi->fib_prefsrc &&
1775 nla_put_in_addr(skb, RTA_PREFSRC, fi->fib_prefsrc))
1776 goto nla_put_failure;
1777
1778 if (fi->nh) {
1779 if (nla_put_u32(skb, RTA_NH_ID, fi->nh->id))
1780 goto nla_put_failure;
1781 if (nexthop_is_blackhole(fi->nh))
1782 rtm->rtm_type = RTN_BLACKHOLE;
1783 if (!fi->fib_net->ipv4.sysctl_nexthop_compat_mode)
1784 goto offload;
1785 }
1786
1787 if (nhs == 1) {
1788 const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
1789 unsigned char flags = 0;
1790
1791 if (fib_nexthop_info(skb, nhc, AF_INET, &flags, false) < 0)
1792 goto nla_put_failure;
1793
1794 rtm->rtm_flags = flags;
1795#ifdef CONFIG_IP_ROUTE_CLASSID
1796 if (nhc->nhc_family == AF_INET) {
1797 struct fib_nh *nh;
1798
1799 nh = container_of(nhc, struct fib_nh, nh_common);
1800 if (nh->nh_tclassid &&
1801 nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid))
1802 goto nla_put_failure;
1803 }
1804#endif
1805 } else {
1806 if (fib_add_multipath(skb, fi) < 0)
1807 goto nla_put_failure;
1808 }
1809
1810offload:
1811 if (fri->offload)
1812 rtm->rtm_flags |= RTM_F_OFFLOAD;
1813 if (fri->trap)
1814 rtm->rtm_flags |= RTM_F_TRAP;
1815 if (fri->offload_failed)
1816 rtm->rtm_flags |= RTM_F_OFFLOAD_FAILED;
1817
1818 nlmsg_end(skb, nlh);
1819 return 0;
1820
1821nla_put_failure:
1822 nlmsg_cancel(skb, nlh);
1823 return -EMSGSIZE;
1824}
1825
1826
1827
1828
1829
1830
1831
1832int fib_sync_down_addr(struct net_device *dev, __be32 local)
1833{
1834 int ret = 0;
1835 unsigned int hash = fib_laddr_hashfn(local);
1836 struct hlist_head *head = &fib_info_laddrhash[hash];
1837 int tb_id = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN;
1838 struct net *net = dev_net(dev);
1839 struct fib_info *fi;
1840
1841 if (!fib_info_laddrhash || local == 0)
1842 return 0;
1843
1844 hlist_for_each_entry(fi, head, fib_lhash) {
1845 if (!net_eq(fi->fib_net, net) ||
1846 fi->fib_tb_id != tb_id)
1847 continue;
1848 if (fi->fib_prefsrc == local) {
1849 fi->fib_flags |= RTNH_F_DEAD;
1850 ret++;
1851 }
1852 }
1853 return ret;
1854}
1855
1856static int call_fib_nh_notifiers(struct fib_nh *nh,
1857 enum fib_event_type event_type)
1858{
1859 bool ignore_link_down = ip_ignore_linkdown(nh->fib_nh_dev);
1860 struct fib_nh_notifier_info info = {
1861 .fib_nh = nh,
1862 };
1863
1864 switch (event_type) {
1865 case FIB_EVENT_NH_ADD:
1866 if (nh->fib_nh_flags & RTNH_F_DEAD)
1867 break;
1868 if (ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN)
1869 break;
1870 return call_fib4_notifiers(dev_net(nh->fib_nh_dev), event_type,
1871 &info.info);
1872 case FIB_EVENT_NH_DEL:
1873 if ((ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) ||
1874 (nh->fib_nh_flags & RTNH_F_DEAD))
1875 return call_fib4_notifiers(dev_net(nh->fib_nh_dev),
1876 event_type, &info.info);
1877 break;
1878 default:
1879 break;
1880 }
1881
1882 return NOTIFY_DONE;
1883}
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895void fib_nhc_update_mtu(struct fib_nh_common *nhc, u32 new, u32 orig)
1896{
1897 struct fnhe_hash_bucket *bucket;
1898 int i;
1899
1900 bucket = rcu_dereference_protected(nhc->nhc_exceptions, 1);
1901 if (!bucket)
1902 return;
1903
1904 for (i = 0; i < FNHE_HASH_SIZE; i++) {
1905 struct fib_nh_exception *fnhe;
1906
1907 for (fnhe = rcu_dereference_protected(bucket[i].chain, 1);
1908 fnhe;
1909 fnhe = rcu_dereference_protected(fnhe->fnhe_next, 1)) {
1910 if (fnhe->fnhe_mtu_locked) {
1911 if (new <= fnhe->fnhe_pmtu) {
1912 fnhe->fnhe_pmtu = new;
1913 fnhe->fnhe_mtu_locked = false;
1914 }
1915 } else if (new < fnhe->fnhe_pmtu ||
1916 orig == fnhe->fnhe_pmtu) {
1917 fnhe->fnhe_pmtu = new;
1918 }
1919 }
1920 }
1921}
1922
1923void fib_sync_mtu(struct net_device *dev, u32 orig_mtu)
1924{
1925 unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1926 struct hlist_head *head = &fib_info_devhash[hash];
1927 struct fib_nh *nh;
1928
1929 hlist_for_each_entry(nh, head, nh_hash) {
1930 if (nh->fib_nh_dev == dev)
1931 fib_nhc_update_mtu(&nh->nh_common, dev->mtu, orig_mtu);
1932 }
1933}
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force)
1944{
1945 int ret = 0;
1946 int scope = RT_SCOPE_NOWHERE;
1947 struct fib_info *prev_fi = NULL;
1948 unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1949 struct hlist_head *head = &fib_info_devhash[hash];
1950 struct fib_nh *nh;
1951
1952 if (force)
1953 scope = -1;
1954
1955 hlist_for_each_entry(nh, head, nh_hash) {
1956 struct fib_info *fi = nh->nh_parent;
1957 int dead;
1958
1959 BUG_ON(!fi->fib_nhs);
1960 if (nh->fib_nh_dev != dev || fi == prev_fi)
1961 continue;
1962 prev_fi = fi;
1963 dead = 0;
1964 change_nexthops(fi) {
1965 if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD)
1966 dead++;
1967 else if (nexthop_nh->fib_nh_dev == dev &&
1968 nexthop_nh->fib_nh_scope != scope) {
1969 switch (event) {
1970 case NETDEV_DOWN:
1971 case NETDEV_UNREGISTER:
1972 nexthop_nh->fib_nh_flags |= RTNH_F_DEAD;
1973 fallthrough;
1974 case NETDEV_CHANGE:
1975 nexthop_nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1976 break;
1977 }
1978 call_fib_nh_notifiers(nexthop_nh,
1979 FIB_EVENT_NH_DEL);
1980 dead++;
1981 }
1982#ifdef CONFIG_IP_ROUTE_MULTIPATH
1983 if (event == NETDEV_UNREGISTER &&
1984 nexthop_nh->fib_nh_dev == dev) {
1985 dead = fi->fib_nhs;
1986 break;
1987 }
1988#endif
1989 } endfor_nexthops(fi)
1990 if (dead == fi->fib_nhs) {
1991 switch (event) {
1992 case NETDEV_DOWN:
1993 case NETDEV_UNREGISTER:
1994 fi->fib_flags |= RTNH_F_DEAD;
1995 fallthrough;
1996 case NETDEV_CHANGE:
1997 fi->fib_flags |= RTNH_F_LINKDOWN;
1998 break;
1999 }
2000 ret++;
2001 }
2002
2003 fib_rebalance(fi);
2004 }
2005
2006 return ret;
2007}
2008
2009
2010static void fib_select_default(const struct flowi4 *flp, struct fib_result *res)
2011{
2012 struct fib_info *fi = NULL, *last_resort = NULL;
2013 struct hlist_head *fa_head = res->fa_head;
2014 struct fib_table *tb = res->table;
2015 u8 slen = 32 - res->prefixlen;
2016 int order = -1, last_idx = -1;
2017 struct fib_alias *fa, *fa1 = NULL;
2018 u32 last_prio = res->fi->fib_priority;
2019 u8 last_tos = 0;
2020
2021 hlist_for_each_entry_rcu(fa, fa_head, fa_list) {
2022 struct fib_info *next_fi = fa->fa_info;
2023 struct fib_nh_common *nhc;
2024
2025 if (fa->fa_slen != slen)
2026 continue;
2027 if (fa->fa_tos && fa->fa_tos != flp->flowi4_tos)
2028 continue;
2029 if (fa->tb_id != tb->tb_id)
2030 continue;
2031 if (next_fi->fib_priority > last_prio &&
2032 fa->fa_tos == last_tos) {
2033 if (last_tos)
2034 continue;
2035 break;
2036 }
2037 if (next_fi->fib_flags & RTNH_F_DEAD)
2038 continue;
2039 last_tos = fa->fa_tos;
2040 last_prio = next_fi->fib_priority;
2041
2042 if (next_fi->fib_scope != res->scope ||
2043 fa->fa_type != RTN_UNICAST)
2044 continue;
2045
2046 nhc = fib_info_nhc(next_fi, 0);
2047 if (!nhc->nhc_gw_family || nhc->nhc_scope != RT_SCOPE_LINK)
2048 continue;
2049
2050 fib_alias_accessed(fa);
2051
2052 if (!fi) {
2053 if (next_fi != res->fi)
2054 break;
2055 fa1 = fa;
2056 } else if (!fib_detect_death(fi, order, &last_resort,
2057 &last_idx, fa1->fa_default)) {
2058 fib_result_assign(res, fi);
2059 fa1->fa_default = order;
2060 goto out;
2061 }
2062 fi = next_fi;
2063 order++;
2064 }
2065
2066 if (order <= 0 || !fi) {
2067 if (fa1)
2068 fa1->fa_default = -1;
2069 goto out;
2070 }
2071
2072 if (!fib_detect_death(fi, order, &last_resort, &last_idx,
2073 fa1->fa_default)) {
2074 fib_result_assign(res, fi);
2075 fa1->fa_default = order;
2076 goto out;
2077 }
2078
2079 if (last_idx >= 0)
2080 fib_result_assign(res, last_resort);
2081 fa1->fa_default = last_idx;
2082out:
2083 return;
2084}
2085
2086
2087
2088
2089
2090
2091
2092int fib_sync_up(struct net_device *dev, unsigned char nh_flags)
2093{
2094 struct fib_info *prev_fi;
2095 unsigned int hash;
2096 struct hlist_head *head;
2097 struct fib_nh *nh;
2098 int ret;
2099
2100 if (!(dev->flags & IFF_UP))
2101 return 0;
2102
2103 if (nh_flags & RTNH_F_DEAD) {
2104 unsigned int flags = dev_get_flags(dev);
2105
2106 if (flags & (IFF_RUNNING | IFF_LOWER_UP))
2107 nh_flags |= RTNH_F_LINKDOWN;
2108 }
2109
2110 prev_fi = NULL;
2111 hash = fib_devindex_hashfn(dev->ifindex);
2112 head = &fib_info_devhash[hash];
2113 ret = 0;
2114
2115 hlist_for_each_entry(nh, head, nh_hash) {
2116 struct fib_info *fi = nh->nh_parent;
2117 int alive;
2118
2119 BUG_ON(!fi->fib_nhs);
2120 if (nh->fib_nh_dev != dev || fi == prev_fi)
2121 continue;
2122
2123 prev_fi = fi;
2124 alive = 0;
2125 change_nexthops(fi) {
2126 if (!(nexthop_nh->fib_nh_flags & nh_flags)) {
2127 alive++;
2128 continue;
2129 }
2130 if (!nexthop_nh->fib_nh_dev ||
2131 !(nexthop_nh->fib_nh_dev->flags & IFF_UP))
2132 continue;
2133 if (nexthop_nh->fib_nh_dev != dev ||
2134 !__in_dev_get_rtnl(dev))
2135 continue;
2136 alive++;
2137 nexthop_nh->fib_nh_flags &= ~nh_flags;
2138 call_fib_nh_notifiers(nexthop_nh, FIB_EVENT_NH_ADD);
2139 } endfor_nexthops(fi)
2140
2141 if (alive > 0) {
2142 fi->fib_flags &= ~nh_flags;
2143 ret++;
2144 }
2145
2146 fib_rebalance(fi);
2147 }
2148
2149 return ret;
2150}
2151
2152#ifdef CONFIG_IP_ROUTE_MULTIPATH
2153static bool fib_good_nh(const struct fib_nh *nh)
2154{
2155 int state = NUD_REACHABLE;
2156
2157 if (nh->fib_nh_scope == RT_SCOPE_LINK) {
2158 struct neighbour *n;
2159
2160 rcu_read_lock_bh();
2161
2162 if (likely(nh->fib_nh_gw_family == AF_INET))
2163 n = __ipv4_neigh_lookup_noref(nh->fib_nh_dev,
2164 (__force u32)nh->fib_nh_gw4);
2165 else if (nh->fib_nh_gw_family == AF_INET6)
2166 n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev,
2167 &nh->fib_nh_gw6);
2168 else
2169 n = NULL;
2170 if (n)
2171 state = n->nud_state;
2172
2173 rcu_read_unlock_bh();
2174 }
2175
2176 return !!(state & NUD_VALID);
2177}
2178
2179void fib_select_multipath(struct fib_result *res, int hash)
2180{
2181 struct fib_info *fi = res->fi;
2182 struct net *net = fi->fib_net;
2183 bool first = false;
2184
2185 if (unlikely(res->fi->nh)) {
2186 nexthop_path_fib_result(res, hash);
2187 return;
2188 }
2189
2190 change_nexthops(fi) {
2191 if (net->ipv4.sysctl_fib_multipath_use_neigh) {
2192 if (!fib_good_nh(nexthop_nh))
2193 continue;
2194 if (!first) {
2195 res->nh_sel = nhsel;
2196 res->nhc = &nexthop_nh->nh_common;
2197 first = true;
2198 }
2199 }
2200
2201 if (hash > atomic_read(&nexthop_nh->fib_nh_upper_bound))
2202 continue;
2203
2204 res->nh_sel = nhsel;
2205 res->nhc = &nexthop_nh->nh_common;
2206 return;
2207 } endfor_nexthops(fi);
2208}
2209#endif
2210
2211void fib_select_path(struct net *net, struct fib_result *res,
2212 struct flowi4 *fl4, const struct sk_buff *skb)
2213{
2214 if (fl4->flowi4_oif && !(fl4->flowi4_flags & FLOWI_FLAG_SKIP_NH_OIF))
2215 goto check_saddr;
2216
2217#ifdef CONFIG_IP_ROUTE_MULTIPATH
2218 if (fib_info_num_path(res->fi) > 1) {
2219 int h = fib_multipath_hash(net, fl4, skb, NULL);
2220
2221 fib_select_multipath(res, h);
2222 }
2223 else
2224#endif
2225 if (!res->prefixlen &&
2226 res->table->tb_num_default > 1 &&
2227 res->type == RTN_UNICAST)
2228 fib_select_default(fl4, res);
2229
2230check_saddr:
2231 if (!fl4->saddr)
2232 fl4->saddr = fib_result_prefsrc(net, res);
2233}
2234
