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 if (nhc->nhc_dev)
212 dev_put(nhc->nhc_dev);
213
214 lwtstate_put(nhc->nhc_lwtstate);
215 rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
216 rt_fibinfo_free(&nhc->nhc_rth_input);
217 free_nh_exceptions(nhc);
218}
219EXPORT_SYMBOL_GPL(fib_nh_common_release);
220
221void fib_nh_release(struct net *net, struct fib_nh *fib_nh)
222{
223#ifdef CONFIG_IP_ROUTE_CLASSID
224 if (fib_nh->nh_tclassid)
225 net->ipv4.fib_num_tclassid_users--;
226#endif
227 fib_nh_common_release(&fib_nh->nh_common);
228}
229
230
231static void free_fib_info_rcu(struct rcu_head *head)
232{
233 struct fib_info *fi = container_of(head, struct fib_info, rcu);
234
235 if (fi->nh) {
236 nexthop_put(fi->nh);
237 } else {
238 change_nexthops(fi) {
239 fib_nh_release(fi->fib_net, nexthop_nh);
240 } endfor_nexthops(fi);
241 }
242
243 ip_fib_metrics_put(fi->fib_metrics);
244
245 kfree(fi);
246}
247
248void free_fib_info(struct fib_info *fi)
249{
250 if (fi->fib_dead == 0) {
251 pr_warn("Freeing alive fib_info %p\n", fi);
252 return;
253 }
254 fib_info_cnt--;
255
256 call_rcu(&fi->rcu, free_fib_info_rcu);
257}
258EXPORT_SYMBOL_GPL(free_fib_info);
259
260void fib_release_info(struct fib_info *fi)
261{
262 spin_lock_bh(&fib_info_lock);
263 if (fi && --fi->fib_treeref == 0) {
264 hlist_del(&fi->fib_hash);
265 if (fi->fib_prefsrc)
266 hlist_del(&fi->fib_lhash);
267 if (fi->nh) {
268 list_del(&fi->nh_list);
269 } else {
270 change_nexthops(fi) {
271 if (!nexthop_nh->fib_nh_dev)
272 continue;
273 hlist_del(&nexthop_nh->nh_hash);
274 } endfor_nexthops(fi)
275 }
276 fi->fib_dead = 1;
277 fib_info_put(fi);
278 }
279 spin_unlock_bh(&fib_info_lock);
280}
281
282static inline int nh_comp(struct fib_info *fi, struct fib_info *ofi)
283{
284 const struct fib_nh *onh;
285
286 if (fi->nh || ofi->nh)
287 return nexthop_cmp(fi->nh, ofi->nh) ? 0 : -1;
288
289 if (ofi->fib_nhs == 0)
290 return 0;
291
292 for_nexthops(fi) {
293 onh = fib_info_nh(ofi, nhsel);
294
295 if (nh->fib_nh_oif != onh->fib_nh_oif ||
296 nh->fib_nh_gw_family != onh->fib_nh_gw_family ||
297 nh->fib_nh_scope != onh->fib_nh_scope ||
298#ifdef CONFIG_IP_ROUTE_MULTIPATH
299 nh->fib_nh_weight != onh->fib_nh_weight ||
300#endif
301#ifdef CONFIG_IP_ROUTE_CLASSID
302 nh->nh_tclassid != onh->nh_tclassid ||
303#endif
304 lwtunnel_cmp_encap(nh->fib_nh_lws, onh->fib_nh_lws) ||
305 ((nh->fib_nh_flags ^ onh->fib_nh_flags) & ~RTNH_COMPARE_MASK))
306 return -1;
307
308 if (nh->fib_nh_gw_family == AF_INET &&
309 nh->fib_nh_gw4 != onh->fib_nh_gw4)
310 return -1;
311
312 if (nh->fib_nh_gw_family == AF_INET6 &&
313 ipv6_addr_cmp(&nh->fib_nh_gw6, &onh->fib_nh_gw6))
314 return -1;
315 } endfor_nexthops(fi);
316 return 0;
317}
318
319static inline unsigned int fib_devindex_hashfn(unsigned int val)
320{
321 unsigned int mask = DEVINDEX_HASHSIZE - 1;
322
323 return (val ^
324 (val >> DEVINDEX_HASHBITS) ^
325 (val >> (DEVINDEX_HASHBITS * 2))) & mask;
326}
327
328static unsigned int fib_info_hashfn_1(int init_val, u8 protocol, u8 scope,
329 u32 prefsrc, u32 priority)
330{
331 unsigned int val = init_val;
332
333 val ^= (protocol << 8) | scope;
334 val ^= prefsrc;
335 val ^= priority;
336
337 return val;
338}
339
340static unsigned int fib_info_hashfn_result(unsigned int val)
341{
342 unsigned int mask = (fib_info_hash_size - 1);
343
344 return (val ^ (val >> 7) ^ (val >> 12)) & mask;
345}
346
347static inline unsigned int fib_info_hashfn(struct fib_info *fi)
348{
349 unsigned int val;
350
351 val = fib_info_hashfn_1(fi->fib_nhs, fi->fib_protocol,
352 fi->fib_scope, (__force u32)fi->fib_prefsrc,
353 fi->fib_priority);
354
355 if (fi->nh) {
356 val ^= fib_devindex_hashfn(fi->nh->id);
357 } else {
358 for_nexthops(fi) {
359 val ^= fib_devindex_hashfn(nh->fib_nh_oif);
360 } endfor_nexthops(fi)
361 }
362
363 return fib_info_hashfn_result(val);
364}
365
366
367static struct fib_info *fib_find_info_nh(struct net *net,
368 const struct fib_config *cfg)
369{
370 struct hlist_head *head;
371 struct fib_info *fi;
372 unsigned int hash;
373
374 hash = fib_info_hashfn_1(fib_devindex_hashfn(cfg->fc_nh_id),
375 cfg->fc_protocol, cfg->fc_scope,
376 (__force u32)cfg->fc_prefsrc,
377 cfg->fc_priority);
378 hash = fib_info_hashfn_result(hash);
379 head = &fib_info_hash[hash];
380
381 hlist_for_each_entry(fi, head, fib_hash) {
382 if (!net_eq(fi->fib_net, net))
383 continue;
384 if (!fi->nh || fi->nh->id != cfg->fc_nh_id)
385 continue;
386 if (cfg->fc_protocol == fi->fib_protocol &&
387 cfg->fc_scope == fi->fib_scope &&
388 cfg->fc_prefsrc == fi->fib_prefsrc &&
389 cfg->fc_priority == fi->fib_priority &&
390 cfg->fc_type == fi->fib_type &&
391 cfg->fc_table == fi->fib_tb_id &&
392 !((cfg->fc_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK))
393 return fi;
394 }
395
396 return NULL;
397}
398
399static struct fib_info *fib_find_info(struct fib_info *nfi)
400{
401 struct hlist_head *head;
402 struct fib_info *fi;
403 unsigned int hash;
404
405 hash = fib_info_hashfn(nfi);
406 head = &fib_info_hash[hash];
407
408 hlist_for_each_entry(fi, head, fib_hash) {
409 if (!net_eq(fi->fib_net, nfi->fib_net))
410 continue;
411 if (fi->fib_nhs != nfi->fib_nhs)
412 continue;
413 if (nfi->fib_protocol == fi->fib_protocol &&
414 nfi->fib_scope == fi->fib_scope &&
415 nfi->fib_prefsrc == fi->fib_prefsrc &&
416 nfi->fib_priority == fi->fib_priority &&
417 nfi->fib_type == fi->fib_type &&
418 memcmp(nfi->fib_metrics, fi->fib_metrics,
419 sizeof(u32) * RTAX_MAX) == 0 &&
420 !((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) &&
421 nh_comp(fi, nfi) == 0)
422 return fi;
423 }
424
425 return NULL;
426}
427
428
429
430
431int ip_fib_check_default(__be32 gw, struct net_device *dev)
432{
433 struct hlist_head *head;
434 struct fib_nh *nh;
435 unsigned int hash;
436
437 spin_lock(&fib_info_lock);
438
439 hash = fib_devindex_hashfn(dev->ifindex);
440 head = &fib_info_devhash[hash];
441 hlist_for_each_entry(nh, head, nh_hash) {
442 if (nh->fib_nh_dev == dev &&
443 nh->fib_nh_gw4 == gw &&
444 !(nh->fib_nh_flags & RTNH_F_DEAD)) {
445 spin_unlock(&fib_info_lock);
446 return 0;
447 }
448 }
449
450 spin_unlock(&fib_info_lock);
451
452 return -1;
453}
454
455size_t fib_nlmsg_size(struct fib_info *fi)
456{
457 size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg))
458 + nla_total_size(4)
459 + nla_total_size(4)
460 + nla_total_size(4)
461 + nla_total_size(4)
462 + nla_total_size(TCP_CA_NAME_MAX);
463 unsigned int nhs = fib_info_num_path(fi);
464
465
466 payload += nla_total_size((RTAX_MAX * nla_total_size(4)));
467
468 if (fi->nh)
469 payload += nla_total_size(4);
470
471 if (nhs) {
472 size_t nh_encapsize = 0;
473
474
475
476 size_t nhsize = nla_total_size(sizeof(struct rtnexthop));
477 unsigned int i;
478
479
480 nhsize += 2 * nla_total_size(4);
481
482
483 for (i = 0; i < fib_info_num_path(fi); i++) {
484 struct fib_nh_common *nhc = fib_info_nhc(fi, i);
485
486 if (nhc->nhc_lwtstate) {
487
488 nh_encapsize += lwtunnel_get_encap_size(
489 nhc->nhc_lwtstate);
490
491 nh_encapsize += nla_total_size(2);
492 }
493 }
494
495
496 payload += nla_total_size((nhs * nhsize) + nh_encapsize);
497
498 }
499
500 return payload;
501}
502
503void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
504 int dst_len, u32 tb_id, const struct nl_info *info,
505 unsigned int nlm_flags)
506{
507 struct fib_rt_info fri;
508 struct sk_buff *skb;
509 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
510 int err = -ENOBUFS;
511
512 skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
513 if (!skb)
514 goto errout;
515
516 fri.fi = fa->fa_info;
517 fri.tb_id = tb_id;
518 fri.dst = key;
519 fri.dst_len = dst_len;
520 fri.tos = fa->fa_tos;
521 fri.type = fa->fa_type;
522 fri.offload = fa->offload;
523 fri.trap = fa->trap;
524 fri.offload_failed = fa->offload_failed;
525 err = fib_dump_info(skb, info->portid, seq, event, &fri, nlm_flags);
526 if (err < 0) {
527
528 WARN_ON(err == -EMSGSIZE);
529 kfree_skb(skb);
530 goto errout;
531 }
532 rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV4_ROUTE,
533 info->nlh, GFP_KERNEL);
534 return;
535errout:
536 if (err < 0)
537 rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err);
538}
539
540static int fib_detect_death(struct fib_info *fi, int order,
541 struct fib_info **last_resort, int *last_idx,
542 int dflt)
543{
544 const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
545 struct neighbour *n;
546 int state = NUD_NONE;
547
548 if (likely(nhc->nhc_gw_family == AF_INET))
549 n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev);
550 else if (nhc->nhc_gw_family == AF_INET6)
551 n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6,
552 nhc->nhc_dev);
553 else
554 n = NULL;
555
556 if (n) {
557 state = n->nud_state;
558 neigh_release(n);
559 } else {
560 return 0;
561 }
562 if (state == NUD_REACHABLE)
563 return 0;
564 if ((state & NUD_VALID) && order != dflt)
565 return 0;
566 if ((state & NUD_VALID) ||
567 (*last_idx < 0 && order > dflt && state != NUD_INCOMPLETE)) {
568 *last_resort = fi;
569 *last_idx = order;
570 }
571 return 1;
572}
573
574int fib_nh_common_init(struct net *net, struct fib_nh_common *nhc,
575 struct nlattr *encap, u16 encap_type,
576 void *cfg, gfp_t gfp_flags,
577 struct netlink_ext_ack *extack)
578{
579 int err;
580
581 nhc->nhc_pcpu_rth_output = alloc_percpu_gfp(struct rtable __rcu *,
582 gfp_flags);
583 if (!nhc->nhc_pcpu_rth_output)
584 return -ENOMEM;
585
586 if (encap) {
587 struct lwtunnel_state *lwtstate;
588
589 if (encap_type == LWTUNNEL_ENCAP_NONE) {
590 NL_SET_ERR_MSG(extack, "LWT encap type not specified");
591 err = -EINVAL;
592 goto lwt_failure;
593 }
594 err = lwtunnel_build_state(net, encap_type, encap,
595 nhc->nhc_family, cfg, &lwtstate,
596 extack);
597 if (err)
598 goto lwt_failure;
599
600 nhc->nhc_lwtstate = lwtstate_get(lwtstate);
601 }
602
603 return 0;
604
605lwt_failure:
606 rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
607 nhc->nhc_pcpu_rth_output = NULL;
608 return err;
609}
610EXPORT_SYMBOL_GPL(fib_nh_common_init);
611
612int fib_nh_init(struct net *net, struct fib_nh *nh,
613 struct fib_config *cfg, int nh_weight,
614 struct netlink_ext_ack *extack)
615{
616 int err;
617
618 nh->fib_nh_family = AF_INET;
619
620 err = fib_nh_common_init(net, &nh->nh_common, cfg->fc_encap,
621 cfg->fc_encap_type, cfg, GFP_KERNEL, extack);
622 if (err)
623 return err;
624
625 nh->fib_nh_oif = cfg->fc_oif;
626 nh->fib_nh_gw_family = cfg->fc_gw_family;
627 if (cfg->fc_gw_family == AF_INET)
628 nh->fib_nh_gw4 = cfg->fc_gw4;
629 else if (cfg->fc_gw_family == AF_INET6)
630 nh->fib_nh_gw6 = cfg->fc_gw6;
631
632 nh->fib_nh_flags = cfg->fc_flags;
633
634#ifdef CONFIG_IP_ROUTE_CLASSID
635 nh->nh_tclassid = cfg->fc_flow;
636 if (nh->nh_tclassid)
637 net->ipv4.fib_num_tclassid_users++;
638#endif
639#ifdef CONFIG_IP_ROUTE_MULTIPATH
640 nh->fib_nh_weight = nh_weight;
641#endif
642 return 0;
643}
644
645#ifdef CONFIG_IP_ROUTE_MULTIPATH
646
647static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining,
648 struct netlink_ext_ack *extack)
649{
650 int nhs = 0;
651
652 while (rtnh_ok(rtnh, remaining)) {
653 nhs++;
654 rtnh = rtnh_next(rtnh, &remaining);
655 }
656
657
658 if (remaining > 0) {
659 NL_SET_ERR_MSG(extack,
660 "Invalid nexthop configuration - extra data after nexthops");
661 nhs = 0;
662 }
663
664 return nhs;
665}
666
667
668static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
669 int remaining, struct fib_config *cfg,
670 struct netlink_ext_ack *extack)
671{
672 struct net *net = fi->fib_net;
673 struct fib_config fib_cfg;
674 struct fib_nh *nh;
675 int ret;
676
677 change_nexthops(fi) {
678 int attrlen;
679
680 memset(&fib_cfg, 0, sizeof(fib_cfg));
681
682 if (!rtnh_ok(rtnh, remaining)) {
683 NL_SET_ERR_MSG(extack,
684 "Invalid nexthop configuration - extra data after nexthop");
685 return -EINVAL;
686 }
687
688 if (rtnh->rtnh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
689 NL_SET_ERR_MSG(extack,
690 "Invalid flags for nexthop - can not contain DEAD or LINKDOWN");
691 return -EINVAL;
692 }
693
694 fib_cfg.fc_flags = (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags;
695 fib_cfg.fc_oif = rtnh->rtnh_ifindex;
696
697 attrlen = rtnh_attrlen(rtnh);
698 if (attrlen > 0) {
699 struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh);
700
701 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
702 nlav = nla_find(attrs, attrlen, RTA_VIA);
703 if (nla && nlav) {
704 NL_SET_ERR_MSG(extack,
705 "Nexthop configuration can not contain both GATEWAY and VIA");
706 return -EINVAL;
707 }
708 if (nla) {
709 fib_cfg.fc_gw4 = nla_get_in_addr(nla);
710 if (fib_cfg.fc_gw4)
711 fib_cfg.fc_gw_family = AF_INET;
712 } else if (nlav) {
713 ret = fib_gw_from_via(&fib_cfg, nlav, extack);
714 if (ret)
715 goto errout;
716 }
717
718 nla = nla_find(attrs, attrlen, RTA_FLOW);
719 if (nla)
720 fib_cfg.fc_flow = nla_get_u32(nla);
721
722 fib_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
723 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
724 if (nla)
725 fib_cfg.fc_encap_type = nla_get_u16(nla);
726 }
727
728 ret = fib_nh_init(net, nexthop_nh, &fib_cfg,
729 rtnh->rtnh_hops + 1, extack);
730 if (ret)
731 goto errout;
732
733 rtnh = rtnh_next(rtnh, &remaining);
734 } endfor_nexthops(fi);
735
736 ret = -EINVAL;
737 nh = fib_info_nh(fi, 0);
738 if (cfg->fc_oif && nh->fib_nh_oif != cfg->fc_oif) {
739 NL_SET_ERR_MSG(extack,
740 "Nexthop device index does not match RTA_OIF");
741 goto errout;
742 }
743 if (cfg->fc_gw_family) {
744 if (cfg->fc_gw_family != nh->fib_nh_gw_family ||
745 (cfg->fc_gw_family == AF_INET &&
746 nh->fib_nh_gw4 != cfg->fc_gw4) ||
747 (cfg->fc_gw_family == AF_INET6 &&
748 ipv6_addr_cmp(&nh->fib_nh_gw6, &cfg->fc_gw6))) {
749 NL_SET_ERR_MSG(extack,
750 "Nexthop gateway does not match RTA_GATEWAY or RTA_VIA");
751 goto errout;
752 }
753 }
754#ifdef CONFIG_IP_ROUTE_CLASSID
755 if (cfg->fc_flow && nh->nh_tclassid != cfg->fc_flow) {
756 NL_SET_ERR_MSG(extack,
757 "Nexthop class id does not match RTA_FLOW");
758 goto errout;
759 }
760#endif
761 ret = 0;
762errout:
763 return ret;
764}
765
766
767static void fib_rebalance(struct fib_info *fi)
768{
769 int total;
770 int w;
771
772 if (fib_info_num_path(fi) < 2)
773 return;
774
775 total = 0;
776 for_nexthops(fi) {
777 if (nh->fib_nh_flags & RTNH_F_DEAD)
778 continue;
779
780 if (ip_ignore_linkdown(nh->fib_nh_dev) &&
781 nh->fib_nh_flags & RTNH_F_LINKDOWN)
782 continue;
783
784 total += nh->fib_nh_weight;
785 } endfor_nexthops(fi);
786
787 w = 0;
788 change_nexthops(fi) {
789 int upper_bound;
790
791 if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) {
792 upper_bound = -1;
793 } else if (ip_ignore_linkdown(nexthop_nh->fib_nh_dev) &&
794 nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) {
795 upper_bound = -1;
796 } else {
797 w += nexthop_nh->fib_nh_weight;
798 upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31,
799 total) - 1;
800 }
801
802 atomic_set(&nexthop_nh->fib_nh_upper_bound, upper_bound);
803 } endfor_nexthops(fi);
804}
805#else
806
807static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
808 int remaining, struct fib_config *cfg,
809 struct netlink_ext_ack *extack)
810{
811 NL_SET_ERR_MSG(extack, "Multipath support not enabled in kernel");
812
813 return -EINVAL;
814}
815
816#define fib_rebalance(fi) do { } while (0)
817
818#endif
819
820static int fib_encap_match(struct net *net, u16 encap_type,
821 struct nlattr *encap,
822 const struct fib_nh *nh,
823 const struct fib_config *cfg,
824 struct netlink_ext_ack *extack)
825{
826 struct lwtunnel_state *lwtstate;
827 int ret, result = 0;
828
829 if (encap_type == LWTUNNEL_ENCAP_NONE)
830 return 0;
831
832 ret = lwtunnel_build_state(net, encap_type, encap, AF_INET,
833 cfg, &lwtstate, extack);
834 if (!ret) {
835 result = lwtunnel_cmp_encap(lwtstate, nh->fib_nh_lws);
836 lwtstate_free(lwtstate);
837 }
838
839 return result;
840}
841
842int fib_nh_match(struct net *net, struct fib_config *cfg, struct fib_info *fi,
843 struct netlink_ext_ack *extack)
844{
845#ifdef CONFIG_IP_ROUTE_MULTIPATH
846 struct rtnexthop *rtnh;
847 int remaining;
848#endif
849
850 if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority)
851 return 1;
852
853 if (cfg->fc_nh_id) {
854 if (fi->nh && cfg->fc_nh_id == fi->nh->id)
855 return 0;
856 return 1;
857 }
858
859 if (cfg->fc_oif || cfg->fc_gw_family) {
860 struct fib_nh *nh = fib_info_nh(fi, 0);
861
862 if (cfg->fc_encap) {
863 if (fib_encap_match(net, cfg->fc_encap_type,
864 cfg->fc_encap, nh, cfg, extack))
865 return 1;
866 }
867#ifdef CONFIG_IP_ROUTE_CLASSID
868 if (cfg->fc_flow &&
869 cfg->fc_flow != nh->nh_tclassid)
870 return 1;
871#endif
872 if ((cfg->fc_oif && cfg->fc_oif != nh->fib_nh_oif) ||
873 (cfg->fc_gw_family &&
874 cfg->fc_gw_family != nh->fib_nh_gw_family))
875 return 1;
876
877 if (cfg->fc_gw_family == AF_INET &&
878 cfg->fc_gw4 != nh->fib_nh_gw4)
879 return 1;
880
881 if (cfg->fc_gw_family == AF_INET6 &&
882 ipv6_addr_cmp(&cfg->fc_gw6, &nh->fib_nh_gw6))
883 return 1;
884
885 return 0;
886 }
887
888#ifdef CONFIG_IP_ROUTE_MULTIPATH
889 if (!cfg->fc_mp)
890 return 0;
891
892 rtnh = cfg->fc_mp;
893 remaining = cfg->fc_mp_len;
894
895 for_nexthops(fi) {
896 int attrlen;
897
898 if (!rtnh_ok(rtnh, remaining))
899 return -EINVAL;
900
901 if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->fib_nh_oif)
902 return 1;
903
904 attrlen = rtnh_attrlen(rtnh);
905 if (attrlen > 0) {
906 struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh);
907
908 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
909 nlav = nla_find(attrs, attrlen, RTA_VIA);
910 if (nla && nlav) {
911 NL_SET_ERR_MSG(extack,
912 "Nexthop configuration can not contain both GATEWAY and VIA");
913 return -EINVAL;
914 }
915
916 if (nla) {
917 if (nh->fib_nh_gw_family != AF_INET ||
918 nla_get_in_addr(nla) != nh->fib_nh_gw4)
919 return 1;
920 } else if (nlav) {
921 struct fib_config cfg2;
922 int err;
923
924 err = fib_gw_from_via(&cfg2, nlav, extack);
925 if (err)
926 return err;
927
928 switch (nh->fib_nh_gw_family) {
929 case AF_INET:
930 if (cfg2.fc_gw_family != AF_INET ||
931 cfg2.fc_gw4 != nh->fib_nh_gw4)
932 return 1;
933 break;
934 case AF_INET6:
935 if (cfg2.fc_gw_family != AF_INET6 ||
936 ipv6_addr_cmp(&cfg2.fc_gw6,
937 &nh->fib_nh_gw6))
938 return 1;
939 break;
940 }
941 }
942
943#ifdef CONFIG_IP_ROUTE_CLASSID
944 nla = nla_find(attrs, attrlen, RTA_FLOW);
945 if (nla && nla_get_u32(nla) != nh->nh_tclassid)
946 return 1;
947#endif
948 }
949
950 rtnh = rtnh_next(rtnh, &remaining);
951 } endfor_nexthops(fi);
952#endif
953 return 0;
954}
955
956bool fib_metrics_match(struct fib_config *cfg, struct fib_info *fi)
957{
958 struct nlattr *nla;
959 int remaining;
960
961 if (!cfg->fc_mx)
962 return true;
963
964 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
965 int type = nla_type(nla);
966 u32 fi_val, val;
967
968 if (!type)
969 continue;
970 if (type > RTAX_MAX)
971 return false;
972
973 if (type == RTAX_CC_ALGO) {
974 char tmp[TCP_CA_NAME_MAX];
975 bool ecn_ca = false;
976
977 nla_strscpy(tmp, nla, sizeof(tmp));
978 val = tcp_ca_get_key_by_name(fi->fib_net, tmp, &ecn_ca);
979 } else {
980 if (nla_len(nla) != sizeof(u32))
981 return false;
982 val = nla_get_u32(nla);
983 }
984
985 fi_val = fi->fib_metrics->metrics[type - 1];
986 if (type == RTAX_FEATURES)
987 fi_val &= ~DST_FEATURE_ECN_CA;
988
989 if (fi_val != val)
990 return false;
991 }
992
993 return true;
994}
995
996static int fib_check_nh_v6_gw(struct net *net, struct fib_nh *nh,
997 u32 table, struct netlink_ext_ack *extack)
998{
999 struct fib6_config cfg = {
1000 .fc_table = table,
1001 .fc_flags = nh->fib_nh_flags | RTF_GATEWAY,
1002 .fc_ifindex = nh->fib_nh_oif,
1003 .fc_gateway = nh->fib_nh_gw6,
1004 };
1005 struct fib6_nh fib6_nh = {};
1006 int err;
1007
1008 err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack);
1009 if (!err) {
1010 nh->fib_nh_dev = fib6_nh.fib_nh_dev;
1011 dev_hold(nh->fib_nh_dev);
1012 nh->fib_nh_oif = nh->fib_nh_dev->ifindex;
1013 nh->fib_nh_scope = RT_SCOPE_LINK;
1014
1015 ipv6_stub->fib6_nh_release(&fib6_nh);
1016 }
1017
1018 return err;
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
1062
1063
1064static int fib_check_nh_v4_gw(struct net *net, struct fib_nh *nh, u32 table,
1065 u8 scope, struct netlink_ext_ack *extack)
1066{
1067 struct net_device *dev;
1068 struct fib_result res;
1069 int err = 0;
1070
1071 if (nh->fib_nh_flags & RTNH_F_ONLINK) {
1072 unsigned int addr_type;
1073
1074 if (scope >= RT_SCOPE_LINK) {
1075 NL_SET_ERR_MSG(extack, "Nexthop has invalid scope");
1076 return -EINVAL;
1077 }
1078 dev = __dev_get_by_index(net, nh->fib_nh_oif);
1079 if (!dev) {
1080 NL_SET_ERR_MSG(extack, "Nexthop device required for onlink");
1081 return -ENODEV;
1082 }
1083 if (!(dev->flags & IFF_UP)) {
1084 NL_SET_ERR_MSG(extack, "Nexthop device is not up");
1085 return -ENETDOWN;
1086 }
1087 addr_type = inet_addr_type_dev_table(net, dev, nh->fib_nh_gw4);
1088 if (addr_type != RTN_UNICAST) {
1089 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1090 return -EINVAL;
1091 }
1092 if (!netif_carrier_ok(dev))
1093 nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1094 nh->fib_nh_dev = dev;
1095 dev_hold(dev);
1096 nh->fib_nh_scope = RT_SCOPE_LINK;
1097 return 0;
1098 }
1099 rcu_read_lock();
1100 {
1101 struct fib_table *tbl = NULL;
1102 struct flowi4 fl4 = {
1103 .daddr = nh->fib_nh_gw4,
1104 .flowi4_scope = scope + 1,
1105 .flowi4_oif = nh->fib_nh_oif,
1106 .flowi4_iif = LOOPBACK_IFINDEX,
1107 };
1108
1109
1110 if (fl4.flowi4_scope < RT_SCOPE_LINK)
1111 fl4.flowi4_scope = RT_SCOPE_LINK;
1112
1113 if (table && table != RT_TABLE_MAIN)
1114 tbl = fib_get_table(net, table);
1115
1116 if (tbl)
1117 err = fib_table_lookup(tbl, &fl4, &res,
1118 FIB_LOOKUP_IGNORE_LINKSTATE |
1119 FIB_LOOKUP_NOREF);
1120
1121
1122
1123
1124
1125 if (!tbl || err) {
1126 err = fib_lookup(net, &fl4, &res,
1127 FIB_LOOKUP_IGNORE_LINKSTATE);
1128 }
1129
1130 if (err) {
1131 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1132 goto out;
1133 }
1134 }
1135
1136 err = -EINVAL;
1137 if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) {
1138 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1139 goto out;
1140 }
1141 nh->fib_nh_scope = res.scope;
1142 nh->fib_nh_oif = FIB_RES_OIF(res);
1143 nh->fib_nh_dev = dev = FIB_RES_DEV(res);
1144 if (!dev) {
1145 NL_SET_ERR_MSG(extack,
1146 "No egress device for nexthop gateway");
1147 goto out;
1148 }
1149 dev_hold(dev);
1150 if (!netif_carrier_ok(dev))
1151 nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1152 err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN;
1153out:
1154 rcu_read_unlock();
1155 return err;
1156}
1157
1158static int fib_check_nh_nongw(struct net *net, struct fib_nh *nh,
1159 struct netlink_ext_ack *extack)
1160{
1161 struct in_device *in_dev;
1162 int err;
1163
1164 if (nh->fib_nh_flags & (RTNH_F_PERVASIVE | RTNH_F_ONLINK)) {
1165 NL_SET_ERR_MSG(extack,
1166 "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set");
1167 return -EINVAL;
1168 }
1169
1170 rcu_read_lock();
1171
1172 err = -ENODEV;
1173 in_dev = inetdev_by_index(net, nh->fib_nh_oif);
1174 if (!in_dev)
1175 goto out;
1176 err = -ENETDOWN;
1177 if (!(in_dev->dev->flags & IFF_UP)) {
1178 NL_SET_ERR_MSG(extack, "Device for nexthop is not up");
1179 goto out;
1180 }
1181
1182 nh->fib_nh_dev = in_dev->dev;
1183 dev_hold(nh->fib_nh_dev);
1184 nh->fib_nh_scope = RT_SCOPE_HOST;
1185 if (!netif_carrier_ok(nh->fib_nh_dev))
1186 nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1187 err = 0;
1188out:
1189 rcu_read_unlock();
1190 return err;
1191}
1192
1193int fib_check_nh(struct net *net, struct fib_nh *nh, u32 table, u8 scope,
1194 struct netlink_ext_ack *extack)
1195{
1196 int err;
1197
1198 if (nh->fib_nh_gw_family == AF_INET)
1199 err = fib_check_nh_v4_gw(net, nh, table, scope, extack);
1200 else if (nh->fib_nh_gw_family == AF_INET6)
1201 err = fib_check_nh_v6_gw(net, nh, table, extack);
1202 else
1203 err = fib_check_nh_nongw(net, nh, extack);
1204
1205 return err;
1206}
1207
1208static inline unsigned int fib_laddr_hashfn(__be32 val)
1209{
1210 unsigned int mask = (fib_info_hash_size - 1);
1211
1212 return ((__force u32)val ^
1213 ((__force u32)val >> 7) ^
1214 ((__force u32)val >> 14)) & mask;
1215}
1216
1217static struct hlist_head *fib_info_hash_alloc(int bytes)
1218{
1219 if (bytes <= PAGE_SIZE)
1220 return kzalloc(bytes, GFP_KERNEL);
1221 else
1222 return (struct hlist_head *)
1223 __get_free_pages(GFP_KERNEL | __GFP_ZERO,
1224 get_order(bytes));
1225}
1226
1227static void fib_info_hash_free(struct hlist_head *hash, int bytes)
1228{
1229 if (!hash)
1230 return;
1231
1232 if (bytes <= PAGE_SIZE)
1233 kfree(hash);
1234 else
1235 free_pages((unsigned long) hash, get_order(bytes));
1236}
1237
1238static void fib_info_hash_move(struct hlist_head *new_info_hash,
1239 struct hlist_head *new_laddrhash,
1240 unsigned int new_size)
1241{
1242 struct hlist_head *old_info_hash, *old_laddrhash;
1243 unsigned int old_size = fib_info_hash_size;
1244 unsigned int i, bytes;
1245
1246 spin_lock_bh(&fib_info_lock);
1247 old_info_hash = fib_info_hash;
1248 old_laddrhash = fib_info_laddrhash;
1249 fib_info_hash_size = new_size;
1250
1251 for (i = 0; i < old_size; i++) {
1252 struct hlist_head *head = &fib_info_hash[i];
1253 struct hlist_node *n;
1254 struct fib_info *fi;
1255
1256 hlist_for_each_entry_safe(fi, n, head, fib_hash) {
1257 struct hlist_head *dest;
1258 unsigned int new_hash;
1259
1260 new_hash = fib_info_hashfn(fi);
1261 dest = &new_info_hash[new_hash];
1262 hlist_add_head(&fi->fib_hash, dest);
1263 }
1264 }
1265 fib_info_hash = new_info_hash;
1266
1267 for (i = 0; i < old_size; i++) {
1268 struct hlist_head *lhead = &fib_info_laddrhash[i];
1269 struct hlist_node *n;
1270 struct fib_info *fi;
1271
1272 hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) {
1273 struct hlist_head *ldest;
1274 unsigned int new_hash;
1275
1276 new_hash = fib_laddr_hashfn(fi->fib_prefsrc);
1277 ldest = &new_laddrhash[new_hash];
1278 hlist_add_head(&fi->fib_lhash, ldest);
1279 }
1280 }
1281 fib_info_laddrhash = new_laddrhash;
1282
1283 spin_unlock_bh(&fib_info_lock);
1284
1285 bytes = old_size * sizeof(struct hlist_head *);
1286 fib_info_hash_free(old_info_hash, bytes);
1287 fib_info_hash_free(old_laddrhash, bytes);
1288}
1289
1290__be32 fib_info_update_nhc_saddr(struct net *net, struct fib_nh_common *nhc,
1291 unsigned char scope)
1292{
1293 struct fib_nh *nh;
1294
1295 if (nhc->nhc_family != AF_INET)
1296 return inet_select_addr(nhc->nhc_dev, 0, scope);
1297
1298 nh = container_of(nhc, struct fib_nh, nh_common);
1299 nh->nh_saddr = inet_select_addr(nh->fib_nh_dev, nh->fib_nh_gw4, scope);
1300 nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid);
1301
1302 return nh->nh_saddr;
1303}
1304
1305__be32 fib_result_prefsrc(struct net *net, struct fib_result *res)
1306{
1307 struct fib_nh_common *nhc = res->nhc;
1308
1309 if (res->fi->fib_prefsrc)
1310 return res->fi->fib_prefsrc;
1311
1312 if (nhc->nhc_family == AF_INET) {
1313 struct fib_nh *nh;
1314
1315 nh = container_of(nhc, struct fib_nh, nh_common);
1316 if (nh->nh_saddr_genid == atomic_read(&net->ipv4.dev_addr_genid))
1317 return nh->nh_saddr;
1318 }
1319
1320 return fib_info_update_nhc_saddr(net, nhc, res->fi->fib_scope);
1321}
1322
1323static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc)
1324{
1325 if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst ||
1326 fib_prefsrc != cfg->fc_dst) {
1327 u32 tb_id = cfg->fc_table;
1328 int rc;
1329
1330 if (tb_id == RT_TABLE_MAIN)
1331 tb_id = RT_TABLE_LOCAL;
1332
1333 rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1334 fib_prefsrc, tb_id);
1335
1336 if (rc != RTN_LOCAL && tb_id != RT_TABLE_LOCAL) {
1337 rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1338 fib_prefsrc, RT_TABLE_LOCAL);
1339 }
1340
1341 if (rc != RTN_LOCAL)
1342 return false;
1343 }
1344 return true;
1345}
1346
1347struct fib_info *fib_create_info(struct fib_config *cfg,
1348 struct netlink_ext_ack *extack)
1349{
1350 int err;
1351 struct fib_info *fi = NULL;
1352 struct nexthop *nh = NULL;
1353 struct fib_info *ofi;
1354 int nhs = 1;
1355 struct net *net = cfg->fc_nlinfo.nl_net;
1356
1357 if (cfg->fc_type > RTN_MAX)
1358 goto err_inval;
1359
1360
1361 if (fib_props[cfg->fc_type].scope > cfg->fc_scope) {
1362 NL_SET_ERR_MSG(extack, "Invalid scope");
1363 goto err_inval;
1364 }
1365
1366 if (cfg->fc_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
1367 NL_SET_ERR_MSG(extack,
1368 "Invalid rtm_flags - can not contain DEAD or LINKDOWN");
1369 goto err_inval;
1370 }
1371
1372 if (cfg->fc_nh_id) {
1373 if (!cfg->fc_mx) {
1374 fi = fib_find_info_nh(net, cfg);
1375 if (fi) {
1376 fi->fib_treeref++;
1377 return fi;
1378 }
1379 }
1380
1381 nh = nexthop_find_by_id(net, cfg->fc_nh_id);
1382 if (!nh) {
1383 NL_SET_ERR_MSG(extack, "Nexthop id does not exist");
1384 goto err_inval;
1385 }
1386 nhs = 0;
1387 }
1388
1389#ifdef CONFIG_IP_ROUTE_MULTIPATH
1390 if (cfg->fc_mp) {
1391 nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack);
1392 if (nhs == 0)
1393 goto err_inval;
1394 }
1395#endif
1396
1397 err = -ENOBUFS;
1398 if (fib_info_cnt >= fib_info_hash_size) {
1399 unsigned int new_size = fib_info_hash_size << 1;
1400 struct hlist_head *new_info_hash;
1401 struct hlist_head *new_laddrhash;
1402 unsigned int bytes;
1403
1404 if (!new_size)
1405 new_size = 16;
1406 bytes = new_size * sizeof(struct hlist_head *);
1407 new_info_hash = fib_info_hash_alloc(bytes);
1408 new_laddrhash = fib_info_hash_alloc(bytes);
1409 if (!new_info_hash || !new_laddrhash) {
1410 fib_info_hash_free(new_info_hash, bytes);
1411 fib_info_hash_free(new_laddrhash, bytes);
1412 } else
1413 fib_info_hash_move(new_info_hash, new_laddrhash, new_size);
1414
1415 if (!fib_info_hash_size)
1416 goto failure;
1417 }
1418
1419 fi = kzalloc(struct_size(fi, fib_nh, nhs), GFP_KERNEL);
1420 if (!fi)
1421 goto failure;
1422 fi->fib_metrics = ip_fib_metrics_init(fi->fib_net, cfg->fc_mx,
1423 cfg->fc_mx_len, extack);
1424 if (IS_ERR(fi->fib_metrics)) {
1425 err = PTR_ERR(fi->fib_metrics);
1426 kfree(fi);
1427 return ERR_PTR(err);
1428 }
1429
1430 fib_info_cnt++;
1431 fi->fib_net = net;
1432 fi->fib_protocol = cfg->fc_protocol;
1433 fi->fib_scope = cfg->fc_scope;
1434 fi->fib_flags = cfg->fc_flags;
1435 fi->fib_priority = cfg->fc_priority;
1436 fi->fib_prefsrc = cfg->fc_prefsrc;
1437 fi->fib_type = cfg->fc_type;
1438 fi->fib_tb_id = cfg->fc_table;
1439
1440 fi->fib_nhs = nhs;
1441 if (nh) {
1442 if (!nexthop_get(nh)) {
1443 NL_SET_ERR_MSG(extack, "Nexthop has been deleted");
1444 err = -EINVAL;
1445 } else {
1446 err = 0;
1447 fi->nh = nh;
1448 }
1449 } else {
1450 change_nexthops(fi) {
1451 nexthop_nh->nh_parent = fi;
1452 } endfor_nexthops(fi)
1453
1454 if (cfg->fc_mp)
1455 err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg,
1456 extack);
1457 else
1458 err = fib_nh_init(net, fi->fib_nh, cfg, 1, extack);
1459 }
1460
1461 if (err != 0)
1462 goto failure;
1463
1464 if (fib_props[cfg->fc_type].error) {
1465 if (cfg->fc_gw_family || cfg->fc_oif || cfg->fc_mp) {
1466 NL_SET_ERR_MSG(extack,
1467 "Gateway, device and multipath can not be specified for this route type");
1468 goto err_inval;
1469 }
1470 goto link_it;
1471 } else {
1472 switch (cfg->fc_type) {
1473 case RTN_UNICAST:
1474 case RTN_LOCAL:
1475 case RTN_BROADCAST:
1476 case RTN_ANYCAST:
1477 case RTN_MULTICAST:
1478 break;
1479 default:
1480 NL_SET_ERR_MSG(extack, "Invalid route type");
1481 goto err_inval;
1482 }
1483 }
1484
1485 if (cfg->fc_scope > RT_SCOPE_HOST) {
1486 NL_SET_ERR_MSG(extack, "Invalid scope");
1487 goto err_inval;
1488 }
1489
1490 if (fi->nh) {
1491 err = fib_check_nexthop(fi->nh, cfg->fc_scope, extack);
1492 if (err)
1493 goto failure;
1494 } else if (cfg->fc_scope == RT_SCOPE_HOST) {
1495 struct fib_nh *nh = fi->fib_nh;
1496
1497
1498 if (nhs != 1) {
1499 NL_SET_ERR_MSG(extack,
1500 "Route with host scope can not have multiple nexthops");
1501 goto err_inval;
1502 }
1503 if (nh->fib_nh_gw_family) {
1504 NL_SET_ERR_MSG(extack,
1505 "Route with host scope can not have a gateway");
1506 goto err_inval;
1507 }
1508 nh->fib_nh_scope = RT_SCOPE_NOWHERE;
1509 nh->fib_nh_dev = dev_get_by_index(net, nh->fib_nh_oif);
1510 err = -ENODEV;
1511 if (!nh->fib_nh_dev)
1512 goto failure;
1513 } else {
1514 int linkdown = 0;
1515
1516 change_nexthops(fi) {
1517 err = fib_check_nh(cfg->fc_nlinfo.nl_net, nexthop_nh,
1518 cfg->fc_table, cfg->fc_scope,
1519 extack);
1520 if (err != 0)
1521 goto failure;
1522 if (nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN)
1523 linkdown++;
1524 } endfor_nexthops(fi)
1525 if (linkdown == fi->fib_nhs)
1526 fi->fib_flags |= RTNH_F_LINKDOWN;
1527 }
1528
1529 if (fi->fib_prefsrc && !fib_valid_prefsrc(cfg, fi->fib_prefsrc)) {
1530 NL_SET_ERR_MSG(extack, "Invalid prefsrc address");
1531 goto err_inval;
1532 }
1533
1534 if (!fi->nh) {
1535 change_nexthops(fi) {
1536 fib_info_update_nhc_saddr(net, &nexthop_nh->nh_common,
1537 fi->fib_scope);
1538 if (nexthop_nh->fib_nh_gw_family == AF_INET6)
1539 fi->fib_nh_is_v6 = true;
1540 } endfor_nexthops(fi)
1541
1542 fib_rebalance(fi);
1543 }
1544
1545link_it:
1546 ofi = fib_find_info(fi);
1547 if (ofi) {
1548 fi->fib_dead = 1;
1549 free_fib_info(fi);
1550 ofi->fib_treeref++;
1551 return ofi;
1552 }
1553
1554 fi->fib_treeref++;
1555 refcount_set(&fi->fib_clntref, 1);
1556 spin_lock_bh(&fib_info_lock);
1557 hlist_add_head(&fi->fib_hash,
1558 &fib_info_hash[fib_info_hashfn(fi)]);
1559 if (fi->fib_prefsrc) {
1560 struct hlist_head *head;
1561
1562 head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)];
1563 hlist_add_head(&fi->fib_lhash, head);
1564 }
1565 if (fi->nh) {
1566 list_add(&fi->nh_list, &nh->fi_list);
1567 } else {
1568 change_nexthops(fi) {
1569 struct hlist_head *head;
1570 unsigned int hash;
1571
1572 if (!nexthop_nh->fib_nh_dev)
1573 continue;
1574 hash = fib_devindex_hashfn(nexthop_nh->fib_nh_dev->ifindex);
1575 head = &fib_info_devhash[hash];
1576 hlist_add_head(&nexthop_nh->nh_hash, head);
1577 } endfor_nexthops(fi)
1578 }
1579 spin_unlock_bh(&fib_info_lock);
1580 return fi;
1581
1582err_inval:
1583 err = -EINVAL;
1584
1585failure:
1586 if (fi) {
1587 fi->fib_dead = 1;
1588 free_fib_info(fi);
1589 }
1590
1591 return ERR_PTR(err);
1592}
1593
1594int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nhc,
1595 u8 rt_family, unsigned char *flags, bool skip_oif)
1596{
1597 if (nhc->nhc_flags & RTNH_F_DEAD)
1598 *flags |= RTNH_F_DEAD;
1599
1600 if (nhc->nhc_flags & RTNH_F_LINKDOWN) {
1601 *flags |= RTNH_F_LINKDOWN;
1602
1603 rcu_read_lock();
1604 switch (nhc->nhc_family) {
1605 case AF_INET:
1606 if (ip_ignore_linkdown(nhc->nhc_dev))
1607 *flags |= RTNH_F_DEAD;
1608 break;
1609 case AF_INET6:
1610 if (ip6_ignore_linkdown(nhc->nhc_dev))
1611 *flags |= RTNH_F_DEAD;
1612 break;
1613 }
1614 rcu_read_unlock();
1615 }
1616
1617 switch (nhc->nhc_gw_family) {
1618 case AF_INET:
1619 if (nla_put_in_addr(skb, RTA_GATEWAY, nhc->nhc_gw.ipv4))
1620 goto nla_put_failure;
1621 break;
1622 case AF_INET6:
1623
1624
1625
1626 if (rt_family != nhc->nhc_gw_family) {
1627 int alen = sizeof(struct in6_addr);
1628 struct nlattr *nla;
1629 struct rtvia *via;
1630
1631 nla = nla_reserve(skb, RTA_VIA, alen + 2);
1632 if (!nla)
1633 goto nla_put_failure;
1634
1635 via = nla_data(nla);
1636 via->rtvia_family = AF_INET6;
1637 memcpy(via->rtvia_addr, &nhc->nhc_gw.ipv6, alen);
1638 } else if (nla_put_in6_addr(skb, RTA_GATEWAY,
1639 &nhc->nhc_gw.ipv6) < 0) {
1640 goto nla_put_failure;
1641 }
1642 break;
1643 }
1644
1645 *flags |= (nhc->nhc_flags &
1646 (RTNH_F_ONLINK | RTNH_F_OFFLOAD | RTNH_F_TRAP));
1647
1648 if (!skip_oif && nhc->nhc_dev &&
1649 nla_put_u32(skb, RTA_OIF, nhc->nhc_dev->ifindex))
1650 goto nla_put_failure;
1651
1652 if (nhc->nhc_lwtstate &&
1653 lwtunnel_fill_encap(skb, nhc->nhc_lwtstate,
1654 RTA_ENCAP, RTA_ENCAP_TYPE) < 0)
1655 goto nla_put_failure;
1656
1657 return 0;
1658
1659nla_put_failure:
1660 return -EMSGSIZE;
1661}
1662EXPORT_SYMBOL_GPL(fib_nexthop_info);
1663
1664#if IS_ENABLED(CONFIG_IP_ROUTE_MULTIPATH) || IS_ENABLED(CONFIG_IPV6)
1665int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nhc,
1666 int nh_weight, u8 rt_family)
1667{
1668 const struct net_device *dev = nhc->nhc_dev;
1669 struct rtnexthop *rtnh;
1670 unsigned char flags = 0;
1671
1672 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
1673 if (!rtnh)
1674 goto nla_put_failure;
1675
1676 rtnh->rtnh_hops = nh_weight - 1;
1677 rtnh->rtnh_ifindex = dev ? dev->ifindex : 0;
1678
1679 if (fib_nexthop_info(skb, nhc, rt_family, &flags, true) < 0)
1680 goto nla_put_failure;
1681
1682 rtnh->rtnh_flags = flags;
1683
1684
1685 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
1686
1687 return 0;
1688
1689nla_put_failure:
1690 return -EMSGSIZE;
1691}
1692EXPORT_SYMBOL_GPL(fib_add_nexthop);
1693#endif
1694
1695#ifdef CONFIG_IP_ROUTE_MULTIPATH
1696static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi)
1697{
1698 struct nlattr *mp;
1699
1700 mp = nla_nest_start_noflag(skb, RTA_MULTIPATH);
1701 if (!mp)
1702 goto nla_put_failure;
1703
1704 if (unlikely(fi->nh)) {
1705 if (nexthop_mpath_fill_node(skb, fi->nh, AF_INET) < 0)
1706 goto nla_put_failure;
1707 goto mp_end;
1708 }
1709
1710 for_nexthops(fi) {
1711 if (fib_add_nexthop(skb, &nh->nh_common, nh->fib_nh_weight,
1712 AF_INET) < 0)
1713 goto nla_put_failure;
1714#ifdef CONFIG_IP_ROUTE_CLASSID
1715 if (nh->nh_tclassid &&
1716 nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid))
1717 goto nla_put_failure;
1718#endif
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
