12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * INET An implementation of the TCP/IP protocol suite for the LINUX 41da177e4SLinus Torvalds * operating system. INET is implemented using the BSD Socket 51da177e4SLinus Torvalds * interface as the means of communication with the user level. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * IPv4 Forwarding Information Base: semantics. 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 101da177e4SLinus Torvalds */ 111da177e4SLinus Torvalds 127c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 131da177e4SLinus Torvalds #include <linux/bitops.h> 141da177e4SLinus Torvalds #include <linux/types.h> 151da177e4SLinus Torvalds #include <linux/kernel.h> 161da177e4SLinus Torvalds #include <linux/jiffies.h> 171da177e4SLinus Torvalds #include <linux/mm.h> 181da177e4SLinus Torvalds #include <linux/string.h> 191da177e4SLinus Torvalds #include <linux/socket.h> 201da177e4SLinus Torvalds #include <linux/sockios.h> 211da177e4SLinus Torvalds #include <linux/errno.h> 221da177e4SLinus Torvalds #include <linux/in.h> 231da177e4SLinus Torvalds #include <linux/inet.h> 2414c85021SArnaldo Carvalho de Melo #include <linux/inetdevice.h> 251da177e4SLinus Torvalds #include <linux/netdevice.h> 261da177e4SLinus Torvalds #include <linux/if_arp.h> 271da177e4SLinus Torvalds #include <linux/proc_fs.h> 281da177e4SLinus Torvalds #include <linux/skbuff.h> 291da177e4SLinus Torvalds #include <linux/init.h> 305a0e3ad6STejun Heo #include <linux/slab.h> 31c3ab2b4eSDavid Ahern #include <linux/netlink.h> 32d07418afSEric Dumazet #include <linux/hash.h> 331da177e4SLinus Torvalds 3414c85021SArnaldo Carvalho de Melo #include <net/arp.h> 35*32ccf110SGuillaume Nault #include <net/inet_dscp.h> 361da177e4SLinus Torvalds #include <net/ip.h> 371da177e4SLinus Torvalds #include <net/protocol.h> 381da177e4SLinus Torvalds #include <net/route.h> 391da177e4SLinus Torvalds #include <net/tcp.h> 401da177e4SLinus Torvalds #include <net/sock.h> 411da177e4SLinus Torvalds #include <net/ip_fib.h> 42717a8f5bSDavid Ahern #include <net/ip6_fib.h> 435481d73fSDavid Ahern #include <net/nexthop.h> 44f21c7bc5SThomas Graf #include <net/netlink.h> 453c618c1dSDavid Ahern #include <net/rtnh.h> 46571e7226SRoopa Prabhu #include <net/lwtunnel.h> 4704b1d4e5SIdo Schimmel #include <net/fib_notifier.h> 48c0a72077SDavid Ahern #include <net/addrconf.h> 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include "fib_lookup.h" 511da177e4SLinus Torvalds 52832b4c5eSStephen Hemminger static DEFINE_SPINLOCK(fib_info_lock); 531da177e4SLinus Torvalds static struct hlist_head *fib_info_hash; 541da177e4SLinus Torvalds static struct hlist_head *fib_info_laddrhash; 55123b9731SDavid S. Miller static unsigned int fib_info_hash_size; 5679eb15daSEric Dumazet static unsigned int fib_info_hash_bits; 571da177e4SLinus Torvalds static unsigned int fib_info_cnt; 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds #define DEVINDEX_HASHBITS 8 601da177e4SLinus Torvalds #define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS) 611da177e4SLinus Torvalds static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE]; 621da177e4SLinus Torvalds 63dcb1ecb5SDavid Ahern /* for_nexthops and change_nexthops only used when nexthop object 64dcb1ecb5SDavid Ahern * is not set in a fib_info. The logic within can reference fib_nh. 65dcb1ecb5SDavid Ahern */ 661da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 671da177e4SLinus Torvalds 686a31d2a9SEric Dumazet #define for_nexthops(fi) { \ 696a31d2a9SEric Dumazet int nhsel; const struct fib_nh *nh; \ 706a31d2a9SEric Dumazet for (nhsel = 0, nh = (fi)->fib_nh; \ 715481d73fSDavid Ahern nhsel < fib_info_num_path((fi)); \ 726a31d2a9SEric Dumazet nh++, nhsel++) 731da177e4SLinus Torvalds 746a31d2a9SEric Dumazet #define change_nexthops(fi) { \ 756a31d2a9SEric Dumazet int nhsel; struct fib_nh *nexthop_nh; \ 766a31d2a9SEric Dumazet for (nhsel = 0, nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \ 775481d73fSDavid Ahern nhsel < fib_info_num_path((fi)); \ 786a31d2a9SEric Dumazet nexthop_nh++, nhsel++) 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds #else /* CONFIG_IP_ROUTE_MULTIPATH */ 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds /* Hope, that gcc will optimize it to get rid of dummy loop */ 831da177e4SLinus Torvalds 846a31d2a9SEric Dumazet #define for_nexthops(fi) { \ 856a31d2a9SEric Dumazet int nhsel; const struct fib_nh *nh = (fi)->fib_nh; \ 861da177e4SLinus Torvalds for (nhsel = 0; nhsel < 1; nhsel++) 871da177e4SLinus Torvalds 886a31d2a9SEric Dumazet #define change_nexthops(fi) { \ 896a31d2a9SEric Dumazet int nhsel; \ 906a31d2a9SEric Dumazet struct fib_nh *nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \ 911da177e4SLinus Torvalds for (nhsel = 0; nhsel < 1; nhsel++) 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds #endif /* CONFIG_IP_ROUTE_MULTIPATH */ 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds #define endfor_nexthops(fi) } 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds 983be0686bSDavid S. Miller const struct fib_prop fib_props[RTN_MAX + 1] = { 996a31d2a9SEric Dumazet [RTN_UNSPEC] = { 1001da177e4SLinus Torvalds .error = 0, 1011da177e4SLinus Torvalds .scope = RT_SCOPE_NOWHERE, 1026a31d2a9SEric Dumazet }, 1036a31d2a9SEric Dumazet [RTN_UNICAST] = { 1041da177e4SLinus Torvalds .error = 0, 1051da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1066a31d2a9SEric Dumazet }, 1076a31d2a9SEric Dumazet [RTN_LOCAL] = { 1081da177e4SLinus Torvalds .error = 0, 1091da177e4SLinus Torvalds .scope = RT_SCOPE_HOST, 1106a31d2a9SEric Dumazet }, 1116a31d2a9SEric Dumazet [RTN_BROADCAST] = { 1121da177e4SLinus Torvalds .error = 0, 1131da177e4SLinus Torvalds .scope = RT_SCOPE_LINK, 1146a31d2a9SEric Dumazet }, 1156a31d2a9SEric Dumazet [RTN_ANYCAST] = { 1161da177e4SLinus Torvalds .error = 0, 1171da177e4SLinus Torvalds .scope = RT_SCOPE_LINK, 1186a31d2a9SEric Dumazet }, 1196a31d2a9SEric Dumazet [RTN_MULTICAST] = { 1201da177e4SLinus Torvalds .error = 0, 1211da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1226a31d2a9SEric Dumazet }, 1236a31d2a9SEric Dumazet [RTN_BLACKHOLE] = { 1241da177e4SLinus Torvalds .error = -EINVAL, 1251da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1266a31d2a9SEric Dumazet }, 1276a31d2a9SEric Dumazet [RTN_UNREACHABLE] = { 1281da177e4SLinus Torvalds .error = -EHOSTUNREACH, 1291da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1306a31d2a9SEric Dumazet }, 1316a31d2a9SEric Dumazet [RTN_PROHIBIT] = { 1321da177e4SLinus Torvalds .error = -EACCES, 1331da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1346a31d2a9SEric Dumazet }, 1356a31d2a9SEric Dumazet [RTN_THROW] = { 1361da177e4SLinus Torvalds .error = -EAGAIN, 1371da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1386a31d2a9SEric Dumazet }, 1396a31d2a9SEric Dumazet [RTN_NAT] = { 1401da177e4SLinus Torvalds .error = -EINVAL, 1411da177e4SLinus Torvalds .scope = RT_SCOPE_NOWHERE, 1426a31d2a9SEric Dumazet }, 1436a31d2a9SEric Dumazet [RTN_XRESOLVE] = { 1441da177e4SLinus Torvalds .error = -EINVAL, 1451da177e4SLinus Torvalds .scope = RT_SCOPE_NOWHERE, 1466a31d2a9SEric Dumazet }, 1471da177e4SLinus Torvalds }; 1481da177e4SLinus Torvalds 149c5038a83SDavid S. Miller static void rt_fibinfo_free(struct rtable __rcu **rtp) 15054764bb6SEric Dumazet { 15154764bb6SEric Dumazet struct rtable *rt = rcu_dereference_protected(*rtp, 1); 15254764bb6SEric Dumazet 15354764bb6SEric Dumazet if (!rt) 15454764bb6SEric Dumazet return; 15554764bb6SEric Dumazet 15654764bb6SEric Dumazet /* Not even needed : RCU_INIT_POINTER(*rtp, NULL); 15754764bb6SEric Dumazet * because we waited an RCU grace period before calling 15854764bb6SEric Dumazet * free_fib_info_rcu() 15954764bb6SEric Dumazet */ 16054764bb6SEric Dumazet 16195c47f9cSWei Wang dst_dev_put(&rt->dst); 162b838d5e1SWei Wang dst_release_immediate(&rt->dst); 16354764bb6SEric Dumazet } 16454764bb6SEric Dumazet 165a5995e71SDavid Ahern static void free_nh_exceptions(struct fib_nh_common *nhc) 166c5038a83SDavid S. Miller { 167caa41527SEric Dumazet struct fnhe_hash_bucket *hash; 168c5038a83SDavid S. Miller int i; 169c5038a83SDavid S. Miller 170a5995e71SDavid Ahern hash = rcu_dereference_protected(nhc->nhc_exceptions, 1); 171caa41527SEric Dumazet if (!hash) 172caa41527SEric Dumazet return; 173c5038a83SDavid S. Miller for (i = 0; i < FNHE_HASH_SIZE; i++) { 174c5038a83SDavid S. Miller struct fib_nh_exception *fnhe; 175c5038a83SDavid S. Miller 176c5038a83SDavid S. Miller fnhe = rcu_dereference_protected(hash[i].chain, 1); 177c5038a83SDavid S. Miller while (fnhe) { 178c5038a83SDavid S. Miller struct fib_nh_exception *next; 179c5038a83SDavid S. Miller 180c5038a83SDavid S. Miller next = rcu_dereference_protected(fnhe->fnhe_next, 1); 181c5038a83SDavid S. Miller 1822ffae99dSTimo Teräs rt_fibinfo_free(&fnhe->fnhe_rth_input); 1832ffae99dSTimo Teräs rt_fibinfo_free(&fnhe->fnhe_rth_output); 184c5038a83SDavid S. Miller 185c5038a83SDavid S. Miller kfree(fnhe); 186c5038a83SDavid S. Miller 187c5038a83SDavid S. Miller fnhe = next; 188c5038a83SDavid S. Miller } 189c5038a83SDavid S. Miller } 190c5038a83SDavid S. Miller kfree(hash); 191c5038a83SDavid S. Miller } 192c5038a83SDavid S. Miller 193c5038a83SDavid S. Miller static void rt_fibinfo_free_cpus(struct rtable __rcu * __percpu *rtp) 194d26b3a7cSEric Dumazet { 195d26b3a7cSEric Dumazet int cpu; 196d26b3a7cSEric Dumazet 197d26b3a7cSEric Dumazet if (!rtp) 198d26b3a7cSEric Dumazet return; 199d26b3a7cSEric Dumazet 200d26b3a7cSEric Dumazet for_each_possible_cpu(cpu) { 201d26b3a7cSEric Dumazet struct rtable *rt; 202d26b3a7cSEric Dumazet 203d26b3a7cSEric Dumazet rt = rcu_dereference_protected(*per_cpu_ptr(rtp, cpu), 1); 2040830106cSWei Wang if (rt) { 20595c47f9cSWei Wang dst_dev_put(&rt->dst); 206b838d5e1SWei Wang dst_release_immediate(&rt->dst); 207d26b3a7cSEric Dumazet } 2080830106cSWei Wang } 209d26b3a7cSEric Dumazet free_percpu(rtp); 210d26b3a7cSEric Dumazet } 211d26b3a7cSEric Dumazet 212979e276eSDavid Ahern void fib_nh_common_release(struct fib_nh_common *nhc) 213979e276eSDavid Ahern { 214e44b14ebSEric Dumazet dev_put_track(nhc->nhc_dev, &nhc->nhc_dev_tracker); 215979e276eSDavid Ahern lwtstate_put(nhc->nhc_lwtstate); 2160f457a36SDavid Ahern rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output); 2170f457a36SDavid Ahern rt_fibinfo_free(&nhc->nhc_rth_input); 218a5995e71SDavid Ahern free_nh_exceptions(nhc); 219979e276eSDavid Ahern } 220979e276eSDavid Ahern EXPORT_SYMBOL_GPL(fib_nh_common_release); 221979e276eSDavid Ahern 222faa041a4SDavid Ahern void fib_nh_release(struct net *net, struct fib_nh *fib_nh) 223faa041a4SDavid Ahern { 224faa041a4SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 225faa041a4SDavid Ahern if (fib_nh->nh_tclassid) 226213f5f8fSEric Dumazet atomic_dec(&net->ipv4.fib_num_tclassid_users); 227faa041a4SDavid Ahern #endif 228979e276eSDavid Ahern fib_nh_common_release(&fib_nh->nh_common); 229faa041a4SDavid Ahern } 230faa041a4SDavid Ahern 2311da177e4SLinus Torvalds /* Release a nexthop info record */ 23219c1ea14SYan, Zheng static void free_fib_info_rcu(struct rcu_head *head) 23319c1ea14SYan, Zheng { 23419c1ea14SYan, Zheng struct fib_info *fi = container_of(head, struct fib_info, rcu); 23519c1ea14SYan, Zheng 2364c7e8084SDavid Ahern if (fi->nh) { 2374c7e8084SDavid Ahern nexthop_put(fi->nh); 2384c7e8084SDavid Ahern } else { 239e49cc0daSYanmin Zhang change_nexthops(fi) { 240faa041a4SDavid Ahern fib_nh_release(fi->fib_net, nexthop_nh); 241e49cc0daSYanmin Zhang } endfor_nexthops(fi); 2424c7e8084SDavid Ahern } 243e49cc0daSYanmin Zhang 244cc5f0eb2SDavid Ahern ip_fib_metrics_put(fi->fib_metrics); 245cc5f0eb2SDavid Ahern 24619c1ea14SYan, Zheng kfree(fi); 24719c1ea14SYan, Zheng } 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds void free_fib_info(struct fib_info *fi) 2501da177e4SLinus Torvalds { 2511da177e4SLinus Torvalds if (fi->fib_dead == 0) { 252058bd4d2SJoe Perches pr_warn("Freeing alive fib_info %p\n", fi); 2531da177e4SLinus Torvalds return; 2541da177e4SLinus Torvalds } 255faa041a4SDavid Ahern 25619c1ea14SYan, Zheng call_rcu(&fi->rcu, free_fib_info_rcu); 2571da177e4SLinus Torvalds } 258b423cb10SIdo Schimmel EXPORT_SYMBOL_GPL(free_fib_info); 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds void fib_release_info(struct fib_info *fi) 2611da177e4SLinus Torvalds { 262832b4c5eSStephen Hemminger spin_lock_bh(&fib_info_lock); 26379976892SYajun Deng if (fi && refcount_dec_and_test(&fi->fib_treeref)) { 2641da177e4SLinus Torvalds hlist_del(&fi->fib_hash); 2650a6e6b3cSEric Dumazet 2660a6e6b3cSEric Dumazet /* Paired with READ_ONCE() in fib_create_info(). */ 2670a6e6b3cSEric Dumazet WRITE_ONCE(fib_info_cnt, fib_info_cnt - 1); 2680a6e6b3cSEric Dumazet 2691da177e4SLinus Torvalds if (fi->fib_prefsrc) 2701da177e4SLinus Torvalds hlist_del(&fi->fib_lhash); 2714c7e8084SDavid Ahern if (fi->nh) { 2724c7e8084SDavid Ahern list_del(&fi->nh_list); 2734c7e8084SDavid Ahern } else { 2741da177e4SLinus Torvalds change_nexthops(fi) { 275b75ed8b1SDavid Ahern if (!nexthop_nh->fib_nh_dev) 2761da177e4SLinus Torvalds continue; 27771fceff0SDavid S. Miller hlist_del(&nexthop_nh->nh_hash); 2781da177e4SLinus Torvalds } endfor_nexthops(fi) 2794c7e8084SDavid Ahern } 2801da177e4SLinus Torvalds fi->fib_dead = 1; 2811da177e4SLinus Torvalds fib_info_put(fi); 2821da177e4SLinus Torvalds } 283832b4c5eSStephen Hemminger spin_unlock_bh(&fib_info_lock); 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2865481d73fSDavid Ahern static inline int nh_comp(struct fib_info *fi, struct fib_info *ofi) 2871da177e4SLinus Torvalds { 2885481d73fSDavid Ahern const struct fib_nh *onh; 2891da177e4SLinus Torvalds 2904c7e8084SDavid Ahern if (fi->nh || ofi->nh) 2914c7e8084SDavid Ahern return nexthop_cmp(fi->nh, ofi->nh) ? 0 : -1; 2924c7e8084SDavid Ahern 2934c7e8084SDavid Ahern if (ofi->fib_nhs == 0) 2944c7e8084SDavid Ahern return 0; 2954c7e8084SDavid Ahern 2961da177e4SLinus Torvalds for_nexthops(fi) { 2975481d73fSDavid Ahern onh = fib_info_nh(ofi, nhsel); 2985481d73fSDavid Ahern 299b75ed8b1SDavid Ahern if (nh->fib_nh_oif != onh->fib_nh_oif || 300a4ea5d43SDavid Ahern nh->fib_nh_gw_family != onh->fib_nh_gw_family || 301b75ed8b1SDavid Ahern nh->fib_nh_scope != onh->fib_nh_scope || 3021da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 303b75ed8b1SDavid Ahern nh->fib_nh_weight != onh->fib_nh_weight || 3041da177e4SLinus Torvalds #endif 305c7066f70SPatrick McHardy #ifdef CONFIG_IP_ROUTE_CLASSID 3061da177e4SLinus Torvalds nh->nh_tclassid != onh->nh_tclassid || 3071da177e4SLinus Torvalds #endif 308b75ed8b1SDavid Ahern lwtunnel_cmp_encap(nh->fib_nh_lws, onh->fib_nh_lws) || 309b75ed8b1SDavid Ahern ((nh->fib_nh_flags ^ onh->fib_nh_flags) & ~RTNH_COMPARE_MASK)) 3101da177e4SLinus Torvalds return -1; 311a4ea5d43SDavid Ahern 312a4ea5d43SDavid Ahern if (nh->fib_nh_gw_family == AF_INET && 313a4ea5d43SDavid Ahern nh->fib_nh_gw4 != onh->fib_nh_gw4) 314a4ea5d43SDavid Ahern return -1; 315a4ea5d43SDavid Ahern 316a4ea5d43SDavid Ahern if (nh->fib_nh_gw_family == AF_INET6 && 317a4ea5d43SDavid Ahern ipv6_addr_cmp(&nh->fib_nh_gw6, &onh->fib_nh_gw6)) 318a4ea5d43SDavid Ahern return -1; 3191da177e4SLinus Torvalds } endfor_nexthops(fi); 3201da177e4SLinus Torvalds return 0; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds 32388ebc72fSDavid S. Miller static inline unsigned int fib_devindex_hashfn(unsigned int val) 32488ebc72fSDavid S. Miller { 325d07418afSEric Dumazet return hash_32(val, DEVINDEX_HASHBITS); 326d07418afSEric Dumazet } 32788ebc72fSDavid S. Miller 328d07418afSEric Dumazet static struct hlist_head * 329d07418afSEric Dumazet fib_info_devhash_bucket(const struct net_device *dev) 330d07418afSEric Dumazet { 331d07418afSEric Dumazet u32 val = net_hash_mix(dev_net(dev)) ^ dev->ifindex; 332d07418afSEric Dumazet 333d07418afSEric Dumazet return &fib_info_devhash[fib_devindex_hashfn(val)]; 33488ebc72fSDavid S. Miller } 33588ebc72fSDavid S. Miller 3366c48ea5fSDavid Ahern static unsigned int fib_info_hashfn_1(int init_val, u8 protocol, u8 scope, 3376c48ea5fSDavid Ahern u32 prefsrc, u32 priority) 3386c48ea5fSDavid Ahern { 3396c48ea5fSDavid Ahern unsigned int val = init_val; 3406c48ea5fSDavid Ahern 3416c48ea5fSDavid Ahern val ^= (protocol << 8) | scope; 3426c48ea5fSDavid Ahern val ^= prefsrc; 3436c48ea5fSDavid Ahern val ^= priority; 3446c48ea5fSDavid Ahern 3456c48ea5fSDavid Ahern return val; 3466c48ea5fSDavid Ahern } 3476c48ea5fSDavid Ahern 3486c48ea5fSDavid Ahern static unsigned int fib_info_hashfn_result(unsigned int val) 3491da177e4SLinus Torvalds { 350123b9731SDavid S. Miller unsigned int mask = (fib_info_hash_size - 1); 3511da177e4SLinus Torvalds 3526c48ea5fSDavid Ahern return (val ^ (val >> 7) ^ (val >> 12)) & mask; 3536c48ea5fSDavid Ahern } 3546c48ea5fSDavid Ahern 3556c48ea5fSDavid Ahern static inline unsigned int fib_info_hashfn(struct fib_info *fi) 3566c48ea5fSDavid Ahern { 3576c48ea5fSDavid Ahern unsigned int val; 3586c48ea5fSDavid Ahern 3596c48ea5fSDavid Ahern val = fib_info_hashfn_1(fi->fib_nhs, fi->fib_protocol, 3606c48ea5fSDavid Ahern fi->fib_scope, (__force u32)fi->fib_prefsrc, 3616c48ea5fSDavid Ahern fi->fib_priority); 3624c7e8084SDavid Ahern 3634c7e8084SDavid Ahern if (fi->nh) { 3644c7e8084SDavid Ahern val ^= fib_devindex_hashfn(fi->nh->id); 3654c7e8084SDavid Ahern } else { 36688ebc72fSDavid S. Miller for_nexthops(fi) { 367b75ed8b1SDavid Ahern val ^= fib_devindex_hashfn(nh->fib_nh_oif); 36888ebc72fSDavid S. Miller } endfor_nexthops(fi) 3694c7e8084SDavid Ahern } 3701da177e4SLinus Torvalds 3716c48ea5fSDavid Ahern return fib_info_hashfn_result(val); 3726c48ea5fSDavid Ahern } 3736c48ea5fSDavid Ahern 3746c48ea5fSDavid Ahern /* no metrics, only nexthop id */ 3756c48ea5fSDavid Ahern static struct fib_info *fib_find_info_nh(struct net *net, 3766c48ea5fSDavid Ahern const struct fib_config *cfg) 3776c48ea5fSDavid Ahern { 3786c48ea5fSDavid Ahern struct hlist_head *head; 3796c48ea5fSDavid Ahern struct fib_info *fi; 3806c48ea5fSDavid Ahern unsigned int hash; 3816c48ea5fSDavid Ahern 3826c48ea5fSDavid Ahern hash = fib_info_hashfn_1(fib_devindex_hashfn(cfg->fc_nh_id), 3836c48ea5fSDavid Ahern cfg->fc_protocol, cfg->fc_scope, 3846c48ea5fSDavid Ahern (__force u32)cfg->fc_prefsrc, 3856c48ea5fSDavid Ahern cfg->fc_priority); 3866c48ea5fSDavid Ahern hash = fib_info_hashfn_result(hash); 3876c48ea5fSDavid Ahern head = &fib_info_hash[hash]; 3886c48ea5fSDavid Ahern 3896c48ea5fSDavid Ahern hlist_for_each_entry(fi, head, fib_hash) { 3906c48ea5fSDavid Ahern if (!net_eq(fi->fib_net, net)) 3916c48ea5fSDavid Ahern continue; 3926c48ea5fSDavid Ahern if (!fi->nh || fi->nh->id != cfg->fc_nh_id) 3936c48ea5fSDavid Ahern continue; 3946c48ea5fSDavid Ahern if (cfg->fc_protocol == fi->fib_protocol && 3956c48ea5fSDavid Ahern cfg->fc_scope == fi->fib_scope && 3966c48ea5fSDavid Ahern cfg->fc_prefsrc == fi->fib_prefsrc && 3976c48ea5fSDavid Ahern cfg->fc_priority == fi->fib_priority && 3986c48ea5fSDavid Ahern cfg->fc_type == fi->fib_type && 3996c48ea5fSDavid Ahern cfg->fc_table == fi->fib_tb_id && 4006c48ea5fSDavid Ahern !((cfg->fc_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK)) 4016c48ea5fSDavid Ahern return fi; 4026c48ea5fSDavid Ahern } 4036c48ea5fSDavid Ahern 4046c48ea5fSDavid Ahern return NULL; 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4075481d73fSDavid Ahern static struct fib_info *fib_find_info(struct fib_info *nfi) 4081da177e4SLinus Torvalds { 4091da177e4SLinus Torvalds struct hlist_head *head; 4101da177e4SLinus Torvalds struct fib_info *fi; 4111da177e4SLinus Torvalds unsigned int hash; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds hash = fib_info_hashfn(nfi); 4141da177e4SLinus Torvalds head = &fib_info_hash[hash]; 4151da177e4SLinus Torvalds 416b67bfe0dSSasha Levin hlist_for_each_entry(fi, head, fib_hash) { 41709ad9bc7SOctavian Purdila if (!net_eq(fi->fib_net, nfi->fib_net)) 4184814bdbdSDenis V. Lunev continue; 4191da177e4SLinus Torvalds if (fi->fib_nhs != nfi->fib_nhs) 4201da177e4SLinus Torvalds continue; 4211da177e4SLinus Torvalds if (nfi->fib_protocol == fi->fib_protocol && 42237e826c5SDavid S. Miller nfi->fib_scope == fi->fib_scope && 4231da177e4SLinus Torvalds nfi->fib_prefsrc == fi->fib_prefsrc && 4241da177e4SLinus Torvalds nfi->fib_priority == fi->fib_priority && 425f4ef85bbSEric Dumazet nfi->fib_type == fi->fib_type && 4261da177e4SLinus Torvalds memcmp(nfi->fib_metrics, fi->fib_metrics, 427fcd13f42SEric Dumazet sizeof(u32) * RTAX_MAX) == 0 && 4288a3d0316SAndy Gospodarek !((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) && 4294c7e8084SDavid Ahern nh_comp(fi, nfi) == 0) 4301da177e4SLinus Torvalds return fi; 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds return NULL; 4341da177e4SLinus Torvalds } 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds /* Check, that the gateway is already configured. 4376a31d2a9SEric Dumazet * Used only by redirect accept routine. 4381da177e4SLinus Torvalds */ 439d878e72eSAl Viro int ip_fib_check_default(__be32 gw, struct net_device *dev) 4401da177e4SLinus Torvalds { 4411da177e4SLinus Torvalds struct hlist_head *head; 4421da177e4SLinus Torvalds struct fib_nh *nh; 4431da177e4SLinus Torvalds 444832b4c5eSStephen Hemminger spin_lock(&fib_info_lock); 4451da177e4SLinus Torvalds 446d07418afSEric Dumazet head = fib_info_devhash_bucket(dev); 447d07418afSEric Dumazet 448b67bfe0dSSasha Levin hlist_for_each_entry(nh, head, nh_hash) { 449b75ed8b1SDavid Ahern if (nh->fib_nh_dev == dev && 450b75ed8b1SDavid Ahern nh->fib_nh_gw4 == gw && 451b75ed8b1SDavid Ahern !(nh->fib_nh_flags & RTNH_F_DEAD)) { 452832b4c5eSStephen Hemminger spin_unlock(&fib_info_lock); 4531da177e4SLinus Torvalds return 0; 4541da177e4SLinus Torvalds } 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds 457832b4c5eSStephen Hemminger spin_unlock(&fib_info_lock); 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds return -1; 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds 4621e7bdec6SAmit Cohen size_t fib_nlmsg_size(struct fib_info *fi) 463339bf98fSThomas Graf { 464339bf98fSThomas Graf size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg)) 465339bf98fSThomas Graf + nla_total_size(4) /* RTA_TABLE */ 466339bf98fSThomas Graf + nla_total_size(4) /* RTA_DST */ 467339bf98fSThomas Graf + nla_total_size(4) /* RTA_PRIORITY */ 468ea697639SDaniel Borkmann + nla_total_size(4) /* RTA_PREFSRC */ 469ea697639SDaniel Borkmann + nla_total_size(TCP_CA_NAME_MAX); /* RTAX_CC_ALGO */ 4705481d73fSDavid Ahern unsigned int nhs = fib_info_num_path(fi); 471339bf98fSThomas Graf 472339bf98fSThomas Graf /* space for nested metrics */ 473339bf98fSThomas Graf payload += nla_total_size((RTAX_MAX * nla_total_size(4))); 474339bf98fSThomas Graf 4754c7e8084SDavid Ahern if (fi->nh) 4764c7e8084SDavid Ahern payload += nla_total_size(4); /* RTA_NH_ID */ 4774c7e8084SDavid Ahern 4785481d73fSDavid Ahern if (nhs) { 479571e7226SRoopa Prabhu size_t nh_encapsize = 0; 4805481d73fSDavid Ahern /* Also handles the special case nhs == 1 */ 481339bf98fSThomas Graf 482339bf98fSThomas Graf /* each nexthop is packed in an attribute */ 483339bf98fSThomas Graf size_t nhsize = nla_total_size(sizeof(struct rtnexthop)); 484dcb1ecb5SDavid Ahern unsigned int i; 485339bf98fSThomas Graf 486339bf98fSThomas Graf /* may contain flow and gateway attribute */ 487339bf98fSThomas Graf nhsize += 2 * nla_total_size(4); 488339bf98fSThomas Graf 489571e7226SRoopa Prabhu /* grab encap info */ 490dcb1ecb5SDavid Ahern for (i = 0; i < fib_info_num_path(fi); i++) { 491dcb1ecb5SDavid Ahern struct fib_nh_common *nhc = fib_info_nhc(fi, i); 492dcb1ecb5SDavid Ahern 493dcb1ecb5SDavid Ahern if (nhc->nhc_lwtstate) { 494571e7226SRoopa Prabhu /* RTA_ENCAP_TYPE */ 495571e7226SRoopa Prabhu nh_encapsize += lwtunnel_get_encap_size( 496dcb1ecb5SDavid Ahern nhc->nhc_lwtstate); 497571e7226SRoopa Prabhu /* RTA_ENCAP */ 498571e7226SRoopa Prabhu nh_encapsize += nla_total_size(2); 499571e7226SRoopa Prabhu } 500dcb1ecb5SDavid Ahern } 501571e7226SRoopa Prabhu 502339bf98fSThomas Graf /* all nexthops are packed in a nested attribute */ 5035481d73fSDavid Ahern payload += nla_total_size((nhs * nhsize) + nh_encapsize); 504571e7226SRoopa Prabhu 505339bf98fSThomas Graf } 506339bf98fSThomas Graf 507339bf98fSThomas Graf return payload; 508339bf98fSThomas Graf } 509339bf98fSThomas Graf 51081f7bf6cSAl Viro void rtmsg_fib(int event, __be32 key, struct fib_alias *fa, 5119877b253SJoe Perches int dst_len, u32 tb_id, const struct nl_info *info, 512b8f55831SMilan Kocian unsigned int nlm_flags) 5131da177e4SLinus Torvalds { 5141e301fd0SIdo Schimmel struct fib_rt_info fri; 5151da177e4SLinus Torvalds struct sk_buff *skb; 5164e902c57SThomas Graf u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0; 517f21c7bc5SThomas Graf int err = -ENOBUFS; 5181da177e4SLinus Torvalds 519339bf98fSThomas Graf skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL); 52051456b29SIan Morris if (!skb) 521f21c7bc5SThomas Graf goto errout; 5221da177e4SLinus Torvalds 5231e301fd0SIdo Schimmel fri.fi = fa->fa_info; 5241e301fd0SIdo Schimmel fri.tb_id = tb_id; 5251e301fd0SIdo Schimmel fri.dst = key; 5261e301fd0SIdo Schimmel fri.dst_len = dst_len; 527*32ccf110SGuillaume Nault fri.tos = inet_dscp_to_dsfield(fa->fa_dscp); 5281e301fd0SIdo Schimmel fri.type = fa->fa_type; 52990b93f1bSIdo Schimmel fri.offload = fa->offload; 53090b93f1bSIdo Schimmel fri.trap = fa->trap; 53136c5100eSAmit Cohen fri.offload_failed = fa->offload_failed; 5321e301fd0SIdo Schimmel err = fib_dump_info(skb, info->portid, seq, event, &fri, nlm_flags); 53326932566SPatrick McHardy if (err < 0) { 53426932566SPatrick McHardy /* -EMSGSIZE implies BUG in fib_nlmsg_size() */ 53526932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 53626932566SPatrick McHardy kfree_skb(skb); 53726932566SPatrick McHardy goto errout; 53826932566SPatrick McHardy } 53915e47304SEric W. Biederman rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV4_ROUTE, 5404e902c57SThomas Graf info->nlh, GFP_KERNEL); 5411ce85fe4SPablo Neira Ayuso return; 542f21c7bc5SThomas Graf errout: 543f21c7bc5SThomas Graf if (err < 0) 5444d1169c1SDenis V. Lunev rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err); 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 547c9cb6b6eSStephen Hemminger static int fib_detect_death(struct fib_info *fi, int order, 548c9cb6b6eSStephen Hemminger struct fib_info **last_resort, int *last_idx, 549c9cb6b6eSStephen Hemminger int dflt) 5501da177e4SLinus Torvalds { 551619d1826SDavid Ahern const struct fib_nh_common *nhc = fib_info_nhc(fi, 0); 5521da177e4SLinus Torvalds struct neighbour *n; 5531da177e4SLinus Torvalds int state = NUD_NONE; 5541da177e4SLinus Torvalds 555619d1826SDavid Ahern if (likely(nhc->nhc_gw_family == AF_INET)) 556619d1826SDavid Ahern n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev); 557619d1826SDavid Ahern else if (nhc->nhc_gw_family == AF_INET6) 558619d1826SDavid Ahern n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6, 559619d1826SDavid Ahern nhc->nhc_dev); 560619d1826SDavid Ahern else 561619d1826SDavid Ahern n = NULL; 562619d1826SDavid Ahern 5631da177e4SLinus Torvalds if (n) { 5641da177e4SLinus Torvalds state = n->nud_state; 5651da177e4SLinus Torvalds neigh_release(n); 56688f64320SJulian Anastasov } else { 56788f64320SJulian Anastasov return 0; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds if (state == NUD_REACHABLE) 5701da177e4SLinus Torvalds return 0; 571c17860a0SDenis V. Lunev if ((state & NUD_VALID) && order != dflt) 5721da177e4SLinus Torvalds return 0; 5731da177e4SLinus Torvalds if ((state & NUD_VALID) || 57488f64320SJulian Anastasov (*last_idx < 0 && order > dflt && state != NUD_INCOMPLETE)) { 5751da177e4SLinus Torvalds *last_resort = fi; 5761da177e4SLinus Torvalds *last_idx = order; 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds return 1; 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds 581faee6769SAlexander Aring int fib_nh_common_init(struct net *net, struct fib_nh_common *nhc, 582faee6769SAlexander Aring struct nlattr *encap, u16 encap_type, 583faee6769SAlexander Aring void *cfg, gfp_t gfp_flags, 584979e276eSDavid Ahern struct netlink_ext_ack *extack) 585979e276eSDavid Ahern { 5860f457a36SDavid Ahern int err; 5870f457a36SDavid Ahern 5880f457a36SDavid Ahern nhc->nhc_pcpu_rth_output = alloc_percpu_gfp(struct rtable __rcu *, 5890f457a36SDavid Ahern gfp_flags); 5900f457a36SDavid Ahern if (!nhc->nhc_pcpu_rth_output) 5910f457a36SDavid Ahern return -ENOMEM; 5920f457a36SDavid Ahern 593979e276eSDavid Ahern if (encap) { 594979e276eSDavid Ahern struct lwtunnel_state *lwtstate; 595979e276eSDavid Ahern 596979e276eSDavid Ahern if (encap_type == LWTUNNEL_ENCAP_NONE) { 597979e276eSDavid Ahern NL_SET_ERR_MSG(extack, "LWT encap type not specified"); 5980f457a36SDavid Ahern err = -EINVAL; 5990f457a36SDavid Ahern goto lwt_failure; 600979e276eSDavid Ahern } 601faee6769SAlexander Aring err = lwtunnel_build_state(net, encap_type, encap, 602faee6769SAlexander Aring nhc->nhc_family, cfg, &lwtstate, 603faee6769SAlexander Aring extack); 604979e276eSDavid Ahern if (err) 6050f457a36SDavid Ahern goto lwt_failure; 606979e276eSDavid Ahern 607979e276eSDavid Ahern nhc->nhc_lwtstate = lwtstate_get(lwtstate); 608979e276eSDavid Ahern } 609979e276eSDavid Ahern 610979e276eSDavid Ahern return 0; 6110f457a36SDavid Ahern 6120f457a36SDavid Ahern lwt_failure: 6130f457a36SDavid Ahern rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output); 6140f457a36SDavid Ahern nhc->nhc_pcpu_rth_output = NULL; 6150f457a36SDavid Ahern return err; 616979e276eSDavid Ahern } 617979e276eSDavid Ahern EXPORT_SYMBOL_GPL(fib_nh_common_init); 618979e276eSDavid Ahern 619e4516ef6SDavid Ahern int fib_nh_init(struct net *net, struct fib_nh *nh, 620e4516ef6SDavid Ahern struct fib_config *cfg, int nh_weight, 621e4516ef6SDavid Ahern struct netlink_ext_ack *extack) 622e4516ef6SDavid Ahern { 6230f457a36SDavid Ahern int err; 624e4516ef6SDavid Ahern 625f1741730SDavid Ahern nh->fib_nh_family = AF_INET; 626f1741730SDavid Ahern 627faee6769SAlexander Aring err = fib_nh_common_init(net, &nh->nh_common, cfg->fc_encap, 628979e276eSDavid Ahern cfg->fc_encap_type, cfg, GFP_KERNEL, extack); 629e4516ef6SDavid Ahern if (err) 6300f457a36SDavid Ahern return err; 631e4516ef6SDavid Ahern 632b75ed8b1SDavid Ahern nh->fib_nh_oif = cfg->fc_oif; 633a4ea5d43SDavid Ahern nh->fib_nh_gw_family = cfg->fc_gw_family; 634a4ea5d43SDavid Ahern if (cfg->fc_gw_family == AF_INET) 635f35b794bSDavid Ahern nh->fib_nh_gw4 = cfg->fc_gw4; 636a4ea5d43SDavid Ahern else if (cfg->fc_gw_family == AF_INET6) 637a4ea5d43SDavid Ahern nh->fib_nh_gw6 = cfg->fc_gw6; 638a4ea5d43SDavid Ahern 639b75ed8b1SDavid Ahern nh->fib_nh_flags = cfg->fc_flags; 640e4516ef6SDavid Ahern 641e4516ef6SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 642e4516ef6SDavid Ahern nh->nh_tclassid = cfg->fc_flow; 643e4516ef6SDavid Ahern if (nh->nh_tclassid) 644213f5f8fSEric Dumazet atomic_inc(&net->ipv4.fib_num_tclassid_users); 645e4516ef6SDavid Ahern #endif 646e4516ef6SDavid Ahern #ifdef CONFIG_IP_ROUTE_MULTIPATH 647b75ed8b1SDavid Ahern nh->fib_nh_weight = nh_weight; 648e4516ef6SDavid Ahern #endif 649e4516ef6SDavid Ahern return 0; 650e4516ef6SDavid Ahern } 651e4516ef6SDavid Ahern 6521da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 6531da177e4SLinus Torvalds 6546d8422a1SDavid Ahern static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining, 6556d8422a1SDavid Ahern struct netlink_ext_ack *extack) 6561da177e4SLinus Torvalds { 6571da177e4SLinus Torvalds int nhs = 0; 6581da177e4SLinus Torvalds 6594e902c57SThomas Graf while (rtnh_ok(rtnh, remaining)) { 6601da177e4SLinus Torvalds nhs++; 6614e902c57SThomas Graf rtnh = rtnh_next(rtnh, &remaining); 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds 6644e902c57SThomas Graf /* leftover implies invalid nexthop configuration, discard it */ 665c3ab2b4eSDavid Ahern if (remaining > 0) { 666c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 667c3ab2b4eSDavid Ahern "Invalid nexthop configuration - extra data after nexthops"); 668c3ab2b4eSDavid Ahern nhs = 0; 669c3ab2b4eSDavid Ahern } 670c3ab2b4eSDavid Ahern 671c3ab2b4eSDavid Ahern return nhs; 6724e902c57SThomas Graf } 6731da177e4SLinus Torvalds 6747a3429baSDavid Ahern static int fib_gw_from_attr(__be32 *gw, struct nlattr *nla, 6757a3429baSDavid Ahern struct netlink_ext_ack *extack) 6767a3429baSDavid Ahern { 6777a3429baSDavid Ahern if (nla_len(nla) < sizeof(*gw)) { 6787a3429baSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid IPv4 address in RTA_GATEWAY"); 6797a3429baSDavid Ahern return -EINVAL; 6807a3429baSDavid Ahern } 6817a3429baSDavid Ahern 6827a3429baSDavid Ahern *gw = nla_get_in_addr(nla); 6837a3429baSDavid Ahern 6847a3429baSDavid Ahern return 0; 6857a3429baSDavid Ahern } 6867a3429baSDavid Ahern 6874c7e8084SDavid Ahern /* only called when fib_nh is integrated into fib_info */ 6884e902c57SThomas Graf static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh, 6896d8422a1SDavid Ahern int remaining, struct fib_config *cfg, 6906d8422a1SDavid Ahern struct netlink_ext_ack *extack) 6914e902c57SThomas Graf { 692e4516ef6SDavid Ahern struct net *net = fi->fib_net; 693e4516ef6SDavid Ahern struct fib_config fib_cfg; 6945481d73fSDavid Ahern struct fib_nh *nh; 695571e7226SRoopa Prabhu int ret; 696571e7226SRoopa Prabhu 6971da177e4SLinus Torvalds change_nexthops(fi) { 6984e902c57SThomas Graf int attrlen; 6994e902c57SThomas Graf 700e4516ef6SDavid Ahern memset(&fib_cfg, 0, sizeof(fib_cfg)); 701e4516ef6SDavid Ahern 702c3ab2b4eSDavid Ahern if (!rtnh_ok(rtnh, remaining)) { 703c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 704c3ab2b4eSDavid Ahern "Invalid nexthop configuration - extra data after nexthop"); 7051da177e4SLinus Torvalds return -EINVAL; 706c3ab2b4eSDavid Ahern } 7074e902c57SThomas Graf 708c3ab2b4eSDavid Ahern if (rtnh->rtnh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) { 709c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 710c3ab2b4eSDavid Ahern "Invalid flags for nexthop - can not contain DEAD or LINKDOWN"); 71180610229SJulian Anastasov return -EINVAL; 712c3ab2b4eSDavid Ahern } 71380610229SJulian Anastasov 714e4516ef6SDavid Ahern fib_cfg.fc_flags = (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags; 715e4516ef6SDavid Ahern fib_cfg.fc_oif = rtnh->rtnh_ifindex; 7164e902c57SThomas Graf 7174e902c57SThomas Graf attrlen = rtnh_attrlen(rtnh); 7184e902c57SThomas Graf if (attrlen > 0) { 719d1566268SDavid Ahern struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh); 7204e902c57SThomas Graf 7214e902c57SThomas Graf nla = nla_find(attrs, attrlen, RTA_GATEWAY); 722d1566268SDavid Ahern nlav = nla_find(attrs, attrlen, RTA_VIA); 723d1566268SDavid Ahern if (nla && nlav) { 724d1566268SDavid Ahern NL_SET_ERR_MSG(extack, 725d1566268SDavid Ahern "Nexthop configuration can not contain both GATEWAY and VIA"); 726d1566268SDavid Ahern return -EINVAL; 727d1566268SDavid Ahern } 728f35b794bSDavid Ahern if (nla) { 7297a3429baSDavid Ahern ret = fib_gw_from_attr(&fib_cfg.fc_gw4, nla, 7307a3429baSDavid Ahern extack); 7317a3429baSDavid Ahern if (ret) 7327a3429baSDavid Ahern goto errout; 7337a3429baSDavid Ahern 734d73f80f9SDavid Ahern if (fib_cfg.fc_gw4) 735d73f80f9SDavid Ahern fib_cfg.fc_gw_family = AF_INET; 736d1566268SDavid Ahern } else if (nlav) { 737d1566268SDavid Ahern ret = fib_gw_from_via(&fib_cfg, nlav, extack); 738d1566268SDavid Ahern if (ret) 739d1566268SDavid Ahern goto errout; 740f35b794bSDavid Ahern } 741571e7226SRoopa Prabhu 742e4516ef6SDavid Ahern nla = nla_find(attrs, attrlen, RTA_FLOW); 743664b9c4bSDavid Ahern if (nla) { 744664b9c4bSDavid Ahern if (nla_len(nla) < sizeof(u32)) { 745664b9c4bSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid RTA_FLOW"); 746664b9c4bSDavid Ahern return -EINVAL; 747664b9c4bSDavid Ahern } 748e4516ef6SDavid Ahern fib_cfg.fc_flow = nla_get_u32(nla); 749664b9c4bSDavid Ahern } 750e4516ef6SDavid Ahern 751e4516ef6SDavid Ahern fib_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP); 7528bda81a4SDavid Ahern /* RTA_ENCAP_TYPE length checked in 7538bda81a4SDavid Ahern * lwtunnel_valid_encap_type_attr 7548bda81a4SDavid Ahern */ 755e4516ef6SDavid Ahern nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE); 756e4516ef6SDavid Ahern if (nla) 757e4516ef6SDavid Ahern fib_cfg.fc_encap_type = nla_get_u16(nla); 758c3ab2b4eSDavid Ahern } 75930357d7dSDavid Ahern 760e4516ef6SDavid Ahern ret = fib_nh_init(net, nexthop_nh, &fib_cfg, 761e4516ef6SDavid Ahern rtnh->rtnh_hops + 1, extack); 762571e7226SRoopa Prabhu if (ret) 763571e7226SRoopa Prabhu goto errout; 7644e902c57SThomas Graf 7654e902c57SThomas Graf rtnh = rtnh_next(rtnh, &remaining); 7661da177e4SLinus Torvalds } endfor_nexthops(fi); 7674e902c57SThomas Graf 768571e7226SRoopa Prabhu ret = -EINVAL; 7695481d73fSDavid Ahern nh = fib_info_nh(fi, 0); 7705481d73fSDavid Ahern if (cfg->fc_oif && nh->fib_nh_oif != cfg->fc_oif) { 771e4516ef6SDavid Ahern NL_SET_ERR_MSG(extack, 772e4516ef6SDavid Ahern "Nexthop device index does not match RTA_OIF"); 773e4516ef6SDavid Ahern goto errout; 774e4516ef6SDavid Ahern } 775f35b794bSDavid Ahern if (cfg->fc_gw_family) { 7765481d73fSDavid Ahern if (cfg->fc_gw_family != nh->fib_nh_gw_family || 777f35b794bSDavid Ahern (cfg->fc_gw_family == AF_INET && 7785481d73fSDavid Ahern nh->fib_nh_gw4 != cfg->fc_gw4) || 779a4ea5d43SDavid Ahern (cfg->fc_gw_family == AF_INET6 && 7805481d73fSDavid Ahern ipv6_addr_cmp(&nh->fib_nh_gw6, &cfg->fc_gw6))) { 781e4516ef6SDavid Ahern NL_SET_ERR_MSG(extack, 782a4ea5d43SDavid Ahern "Nexthop gateway does not match RTA_GATEWAY or RTA_VIA"); 783e4516ef6SDavid Ahern goto errout; 784e4516ef6SDavid Ahern } 785f35b794bSDavid Ahern } 786e4516ef6SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 7875481d73fSDavid Ahern if (cfg->fc_flow && nh->nh_tclassid != cfg->fc_flow) { 788e4516ef6SDavid Ahern NL_SET_ERR_MSG(extack, 789e4516ef6SDavid Ahern "Nexthop class id does not match RTA_FLOW"); 790e4516ef6SDavid Ahern goto errout; 791e4516ef6SDavid Ahern } 792e4516ef6SDavid Ahern #endif 793e4516ef6SDavid Ahern ret = 0; 794571e7226SRoopa Prabhu errout: 795571e7226SRoopa Prabhu return ret; 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds 7984c7e8084SDavid Ahern /* only called when fib_nh is integrated into fib_info */ 7990e884c78SPeter Nørlund static void fib_rebalance(struct fib_info *fi) 8000e884c78SPeter Nørlund { 8010e884c78SPeter Nørlund int total; 8020e884c78SPeter Nørlund int w; 8030e884c78SPeter Nørlund 8045481d73fSDavid Ahern if (fib_info_num_path(fi) < 2) 8050e884c78SPeter Nørlund return; 8060e884c78SPeter Nørlund 8070e884c78SPeter Nørlund total = 0; 8080e884c78SPeter Nørlund for_nexthops(fi) { 809b75ed8b1SDavid Ahern if (nh->fib_nh_flags & RTNH_F_DEAD) 8100e884c78SPeter Nørlund continue; 8110e884c78SPeter Nørlund 812b75ed8b1SDavid Ahern if (ip_ignore_linkdown(nh->fib_nh_dev) && 813b75ed8b1SDavid Ahern nh->fib_nh_flags & RTNH_F_LINKDOWN) 8140e884c78SPeter Nørlund continue; 8150e884c78SPeter Nørlund 816b75ed8b1SDavid Ahern total += nh->fib_nh_weight; 8170e884c78SPeter Nørlund } endfor_nexthops(fi); 8180e884c78SPeter Nørlund 8190e884c78SPeter Nørlund w = 0; 8200e884c78SPeter Nørlund change_nexthops(fi) { 8210e884c78SPeter Nørlund int upper_bound; 8220e884c78SPeter Nørlund 823b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) { 8240e884c78SPeter Nørlund upper_bound = -1; 825b75ed8b1SDavid Ahern } else if (ip_ignore_linkdown(nexthop_nh->fib_nh_dev) && 826b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) { 8270e884c78SPeter Nørlund upper_bound = -1; 8280e884c78SPeter Nørlund } else { 829b75ed8b1SDavid Ahern w += nexthop_nh->fib_nh_weight; 8300a837fe4SPeter Nørlund upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31, 8310e884c78SPeter Nørlund total) - 1; 8320e884c78SPeter Nørlund } 8330e884c78SPeter Nørlund 834b75ed8b1SDavid Ahern atomic_set(&nexthop_nh->fib_nh_upper_bound, upper_bound); 8350e884c78SPeter Nørlund } endfor_nexthops(fi); 8360e884c78SPeter Nørlund } 8370e884c78SPeter Nørlund #else /* CONFIG_IP_ROUTE_MULTIPATH */ 8380e884c78SPeter Nørlund 8398373c6c8SDavid Ahern static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh, 8408373c6c8SDavid Ahern int remaining, struct fib_config *cfg, 8418373c6c8SDavid Ahern struct netlink_ext_ack *extack) 8428373c6c8SDavid Ahern { 8438373c6c8SDavid Ahern NL_SET_ERR_MSG(extack, "Multipath support not enabled in kernel"); 8448373c6c8SDavid Ahern 8458373c6c8SDavid Ahern return -EINVAL; 8468373c6c8SDavid Ahern } 8478373c6c8SDavid Ahern 8480e884c78SPeter Nørlund #define fib_rebalance(fi) do { } while (0) 8490e884c78SPeter Nørlund 8500e884c78SPeter Nørlund #endif /* CONFIG_IP_ROUTE_MULTIPATH */ 8511da177e4SLinus Torvalds 852faee6769SAlexander Aring static int fib_encap_match(struct net *net, u16 encap_type, 853571e7226SRoopa Prabhu struct nlattr *encap, 85430357d7dSDavid Ahern const struct fib_nh *nh, 8559ae28727SDavid Ahern const struct fib_config *cfg, 8569ae28727SDavid Ahern struct netlink_ext_ack *extack) 857571e7226SRoopa Prabhu { 858571e7226SRoopa Prabhu struct lwtunnel_state *lwtstate; 859df383e62SJiri Benc int ret, result = 0; 860571e7226SRoopa Prabhu 861571e7226SRoopa Prabhu if (encap_type == LWTUNNEL_ENCAP_NONE) 862571e7226SRoopa Prabhu return 0; 863571e7226SRoopa Prabhu 864faee6769SAlexander Aring ret = lwtunnel_build_state(net, encap_type, encap, AF_INET, 8659ae28727SDavid Ahern cfg, &lwtstate, extack); 866df383e62SJiri Benc if (!ret) { 867b75ed8b1SDavid Ahern result = lwtunnel_cmp_encap(lwtstate, nh->fib_nh_lws); 868df383e62SJiri Benc lwtstate_free(lwtstate); 869df383e62SJiri Benc } 870571e7226SRoopa Prabhu 871df383e62SJiri Benc return result; 872571e7226SRoopa Prabhu } 873571e7226SRoopa Prabhu 874faee6769SAlexander Aring int fib_nh_match(struct net *net, struct fib_config *cfg, struct fib_info *fi, 8759ae28727SDavid Ahern struct netlink_ext_ack *extack) 8761da177e4SLinus Torvalds { 8771da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 8784e902c57SThomas Graf struct rtnexthop *rtnh; 8794e902c57SThomas Graf int remaining; 8801da177e4SLinus Torvalds #endif 8811da177e4SLinus Torvalds 8824e902c57SThomas Graf if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority) 8831da177e4SLinus Torvalds return 1; 8841da177e4SLinus Torvalds 885493ced1aSDavid Ahern if (cfg->fc_nh_id) { 886493ced1aSDavid Ahern if (fi->nh && cfg->fc_nh_id == fi->nh->id) 887493ced1aSDavid Ahern return 0; 888493ced1aSDavid Ahern return 1; 889493ced1aSDavid Ahern } 890493ced1aSDavid Ahern 891f35b794bSDavid Ahern if (cfg->fc_oif || cfg->fc_gw_family) { 8925481d73fSDavid Ahern struct fib_nh *nh = fib_info_nh(fi, 0); 8935481d73fSDavid Ahern 894571e7226SRoopa Prabhu if (cfg->fc_encap) { 895faee6769SAlexander Aring if (fib_encap_match(net, cfg->fc_encap_type, 896faee6769SAlexander Aring cfg->fc_encap, nh, cfg, extack)) 897571e7226SRoopa Prabhu return 1; 898571e7226SRoopa Prabhu } 899a8c6db1dSStefano Brivio #ifdef CONFIG_IP_ROUTE_CLASSID 900a8c6db1dSStefano Brivio if (cfg->fc_flow && 9015481d73fSDavid Ahern cfg->fc_flow != nh->nh_tclassid) 902a8c6db1dSStefano Brivio return 1; 903a8c6db1dSStefano Brivio #endif 9045481d73fSDavid Ahern if ((cfg->fc_oif && cfg->fc_oif != nh->fib_nh_oif) || 905f35b794bSDavid Ahern (cfg->fc_gw_family && 9065481d73fSDavid Ahern cfg->fc_gw_family != nh->fib_nh_gw_family)) 9071da177e4SLinus Torvalds return 1; 908f35b794bSDavid Ahern 909f35b794bSDavid Ahern if (cfg->fc_gw_family == AF_INET && 9105481d73fSDavid Ahern cfg->fc_gw4 != nh->fib_nh_gw4) 911f35b794bSDavid Ahern return 1; 912f35b794bSDavid Ahern 913a4ea5d43SDavid Ahern if (cfg->fc_gw_family == AF_INET6 && 9145481d73fSDavid Ahern ipv6_addr_cmp(&cfg->fc_gw6, &nh->fib_nh_gw6)) 915a4ea5d43SDavid Ahern return 1; 916a4ea5d43SDavid Ahern 917f35b794bSDavid Ahern return 0; 9181da177e4SLinus Torvalds } 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 92151456b29SIan Morris if (!cfg->fc_mp) 9221da177e4SLinus Torvalds return 0; 9234e902c57SThomas Graf 9244e902c57SThomas Graf rtnh = cfg->fc_mp; 9254e902c57SThomas Graf remaining = cfg->fc_mp_len; 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds for_nexthops(fi) { 9284e902c57SThomas Graf int attrlen; 9291da177e4SLinus Torvalds 9304e902c57SThomas Graf if (!rtnh_ok(rtnh, remaining)) 9311da177e4SLinus Torvalds return -EINVAL; 9324e902c57SThomas Graf 933b75ed8b1SDavid Ahern if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->fib_nh_oif) 9341da177e4SLinus Torvalds return 1; 9354e902c57SThomas Graf 9364e902c57SThomas Graf attrlen = rtnh_attrlen(rtnh); 937f76936d0SJiri Pirko if (attrlen > 0) { 938d1566268SDavid Ahern struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh); 9397a3429baSDavid Ahern int err; 9404e902c57SThomas Graf 9414e902c57SThomas Graf nla = nla_find(attrs, attrlen, RTA_GATEWAY); 942d1566268SDavid Ahern nlav = nla_find(attrs, attrlen, RTA_VIA); 943d1566268SDavid Ahern if (nla && nlav) { 944d1566268SDavid Ahern NL_SET_ERR_MSG(extack, 945d1566268SDavid Ahern "Nexthop configuration can not contain both GATEWAY and VIA"); 946d1566268SDavid Ahern return -EINVAL; 947d1566268SDavid Ahern } 948d1566268SDavid Ahern 949d1566268SDavid Ahern if (nla) { 9507a3429baSDavid Ahern __be32 gw; 9517a3429baSDavid Ahern 9527a3429baSDavid Ahern err = fib_gw_from_attr(&gw, nla, extack); 9537a3429baSDavid Ahern if (err) 9547a3429baSDavid Ahern return err; 9557a3429baSDavid Ahern 956d1566268SDavid Ahern if (nh->fib_nh_gw_family != AF_INET || 9577a3429baSDavid Ahern gw != nh->fib_nh_gw4) 9581da177e4SLinus Torvalds return 1; 959d1566268SDavid Ahern } else if (nlav) { 960d1566268SDavid Ahern struct fib_config cfg2; 961d1566268SDavid Ahern 962d1566268SDavid Ahern err = fib_gw_from_via(&cfg2, nlav, extack); 963d1566268SDavid Ahern if (err) 964d1566268SDavid Ahern return err; 965d1566268SDavid Ahern 966d1566268SDavid Ahern switch (nh->fib_nh_gw_family) { 967d1566268SDavid Ahern case AF_INET: 968d1566268SDavid Ahern if (cfg2.fc_gw_family != AF_INET || 969d1566268SDavid Ahern cfg2.fc_gw4 != nh->fib_nh_gw4) 970d1566268SDavid Ahern return 1; 971d1566268SDavid Ahern break; 972d1566268SDavid Ahern case AF_INET6: 973d1566268SDavid Ahern if (cfg2.fc_gw_family != AF_INET6 || 974d1566268SDavid Ahern ipv6_addr_cmp(&cfg2.fc_gw6, 975d1566268SDavid Ahern &nh->fib_nh_gw6)) 976d1566268SDavid Ahern return 1; 977d1566268SDavid Ahern break; 978d1566268SDavid Ahern } 979d1566268SDavid Ahern } 980d1566268SDavid Ahern 981c7066f70SPatrick McHardy #ifdef CONFIG_IP_ROUTE_CLASSID 9824e902c57SThomas Graf nla = nla_find(attrs, attrlen, RTA_FLOW); 983664b9c4bSDavid Ahern if (nla) { 984664b9c4bSDavid Ahern if (nla_len(nla) < sizeof(u32)) { 985664b9c4bSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid RTA_FLOW"); 986664b9c4bSDavid Ahern return -EINVAL; 987664b9c4bSDavid Ahern } 988664b9c4bSDavid Ahern if (nla_get_u32(nla) != nh->nh_tclassid) 9891da177e4SLinus Torvalds return 1; 990664b9c4bSDavid Ahern } 9911da177e4SLinus Torvalds #endif 9921da177e4SLinus Torvalds } 9934e902c57SThomas Graf 9944e902c57SThomas Graf rtnh = rtnh_next(rtnh, &remaining); 9951da177e4SLinus Torvalds } endfor_nexthops(fi); 9961da177e4SLinus Torvalds #endif 9971da177e4SLinus Torvalds return 0; 9981da177e4SLinus Torvalds } 9991da177e4SLinus Torvalds 10005f9ae3d9SXin Long bool fib_metrics_match(struct fib_config *cfg, struct fib_info *fi) 10015f9ae3d9SXin Long { 10025f9ae3d9SXin Long struct nlattr *nla; 10035f9ae3d9SXin Long int remaining; 10045f9ae3d9SXin Long 10055f9ae3d9SXin Long if (!cfg->fc_mx) 10065f9ae3d9SXin Long return true; 10075f9ae3d9SXin Long 10085f9ae3d9SXin Long nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) { 10095f9ae3d9SXin Long int type = nla_type(nla); 1010d03a4557SPhil Sutter u32 fi_val, val; 10115f9ae3d9SXin Long 10125f9ae3d9SXin Long if (!type) 10135f9ae3d9SXin Long continue; 10145f9ae3d9SXin Long if (type > RTAX_MAX) 10155f9ae3d9SXin Long return false; 10165f9ae3d9SXin Long 10175f9ae3d9SXin Long if (type == RTAX_CC_ALGO) { 10185f9ae3d9SXin Long char tmp[TCP_CA_NAME_MAX]; 10195f9ae3d9SXin Long bool ecn_ca = false; 10205f9ae3d9SXin Long 1021872f6903SFrancis Laniel nla_strscpy(tmp, nla, sizeof(tmp)); 10226670e152SStephen Hemminger val = tcp_ca_get_key_by_name(fi->fib_net, tmp, &ecn_ca); 10235f9ae3d9SXin Long } else { 10245b5e7a0dSEric Dumazet if (nla_len(nla) != sizeof(u32)) 10255b5e7a0dSEric Dumazet return false; 10265f9ae3d9SXin Long val = nla_get_u32(nla); 10275f9ae3d9SXin Long } 10285f9ae3d9SXin Long 1029d03a4557SPhil Sutter fi_val = fi->fib_metrics->metrics[type - 1]; 1030d03a4557SPhil Sutter if (type == RTAX_FEATURES) 1031d03a4557SPhil Sutter fi_val &= ~DST_FEATURE_ECN_CA; 1032d03a4557SPhil Sutter 1033d03a4557SPhil Sutter if (fi_val != val) 10345f9ae3d9SXin Long return false; 10355f9ae3d9SXin Long } 10365f9ae3d9SXin Long 10375f9ae3d9SXin Long return true; 10385f9ae3d9SXin Long } 10395f9ae3d9SXin Long 1040717a8f5bSDavid Ahern static int fib_check_nh_v6_gw(struct net *net, struct fib_nh *nh, 1041717a8f5bSDavid Ahern u32 table, struct netlink_ext_ack *extack) 1042717a8f5bSDavid Ahern { 1043717a8f5bSDavid Ahern struct fib6_config cfg = { 1044717a8f5bSDavid Ahern .fc_table = table, 1045717a8f5bSDavid Ahern .fc_flags = nh->fib_nh_flags | RTF_GATEWAY, 1046717a8f5bSDavid Ahern .fc_ifindex = nh->fib_nh_oif, 1047717a8f5bSDavid Ahern .fc_gateway = nh->fib_nh_gw6, 1048717a8f5bSDavid Ahern }; 1049717a8f5bSDavid Ahern struct fib6_nh fib6_nh = {}; 1050717a8f5bSDavid Ahern int err; 1051717a8f5bSDavid Ahern 1052717a8f5bSDavid Ahern err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack); 1053717a8f5bSDavid Ahern if (!err) { 1054717a8f5bSDavid Ahern nh->fib_nh_dev = fib6_nh.fib_nh_dev; 1055e44b14ebSEric Dumazet dev_hold_track(nh->fib_nh_dev, &nh->fib_nh_dev_tracker, GFP_KERNEL); 1056717a8f5bSDavid Ahern nh->fib_nh_oif = nh->fib_nh_dev->ifindex; 1057717a8f5bSDavid Ahern nh->fib_nh_scope = RT_SCOPE_LINK; 1058717a8f5bSDavid Ahern 1059717a8f5bSDavid Ahern ipv6_stub->fib6_nh_release(&fib6_nh); 1060717a8f5bSDavid Ahern } 1061717a8f5bSDavid Ahern 1062717a8f5bSDavid Ahern return err; 1063717a8f5bSDavid Ahern } 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds /* 10666a31d2a9SEric Dumazet * Picture 10676a31d2a9SEric Dumazet * ------- 10686a31d2a9SEric Dumazet * 10696a31d2a9SEric Dumazet * Semantics of nexthop is very messy by historical reasons. 10706a31d2a9SEric Dumazet * We have to take into account, that: 10716a31d2a9SEric Dumazet * a) gateway can be actually local interface address, 10726a31d2a9SEric Dumazet * so that gatewayed route is direct. 10736a31d2a9SEric Dumazet * b) gateway must be on-link address, possibly 10746a31d2a9SEric Dumazet * described not by an ifaddr, but also by a direct route. 10756a31d2a9SEric Dumazet * c) If both gateway and interface are specified, they should not 10766a31d2a9SEric Dumazet * contradict. 10776a31d2a9SEric Dumazet * d) If we use tunnel routes, gateway could be not on-link. 10786a31d2a9SEric Dumazet * 10796a31d2a9SEric Dumazet * Attempt to reconcile all of these (alas, self-contradictory) conditions 10806a31d2a9SEric Dumazet * results in pretty ugly and hairy code with obscure logic. 10816a31d2a9SEric Dumazet * 10826a31d2a9SEric Dumazet * I chose to generalized it instead, so that the size 10836a31d2a9SEric Dumazet * of code does not increase practically, but it becomes 10846a31d2a9SEric Dumazet * much more general. 10856a31d2a9SEric Dumazet * Every prefix is assigned a "scope" value: "host" is local address, 10866a31d2a9SEric Dumazet * "link" is direct route, 10876a31d2a9SEric Dumazet * [ ... "site" ... "interior" ... ] 10886a31d2a9SEric Dumazet * and "universe" is true gateway route with global meaning. 10896a31d2a9SEric Dumazet * 10906a31d2a9SEric Dumazet * Every prefix refers to a set of "nexthop"s (gw, oif), 10916a31d2a9SEric Dumazet * where gw must have narrower scope. This recursion stops 10926a31d2a9SEric Dumazet * when gw has LOCAL scope or if "nexthop" is declared ONLINK, 10936a31d2a9SEric Dumazet * which means that gw is forced to be on link. 10946a31d2a9SEric Dumazet * 10956a31d2a9SEric Dumazet * Code is still hairy, but now it is apparently logically 10966a31d2a9SEric Dumazet * consistent and very flexible. F.e. as by-product it allows 10976a31d2a9SEric Dumazet * to co-exists in peace independent exterior and interior 10986a31d2a9SEric Dumazet * routing processes. 10996a31d2a9SEric Dumazet * 11006a31d2a9SEric Dumazet * Normally it looks as following. 11016a31d2a9SEric Dumazet * 11026a31d2a9SEric Dumazet * {universe prefix} -> (gw, oif) [scope link] 11036a31d2a9SEric Dumazet * | 11046a31d2a9SEric Dumazet * |-> {link prefix} -> (gw, oif) [scope local] 11056a31d2a9SEric Dumazet * | 11066a31d2a9SEric Dumazet * |-> {local prefix} (terminal node) 11071da177e4SLinus Torvalds */ 1108448d7248SDavid Ahern static int fib_check_nh_v4_gw(struct net *net, struct fib_nh *nh, u32 table, 1109448d7248SDavid Ahern u8 scope, struct netlink_ext_ack *extack) 11101da177e4SLinus Torvalds { 11116a31d2a9SEric Dumazet struct net_device *dev; 11121da177e4SLinus Torvalds struct fib_result res; 1113c3fee640SEnrico Weigelt int err = 0; 11141da177e4SLinus Torvalds 1115b75ed8b1SDavid Ahern if (nh->fib_nh_flags & RTNH_F_ONLINK) { 111630bbaa19SDavid Ahern unsigned int addr_type; 11171da177e4SLinus Torvalds 1118448d7248SDavid Ahern if (scope >= RT_SCOPE_LINK) { 1119448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid scope"); 11201da177e4SLinus Torvalds return -EINVAL; 1121c3ab2b4eSDavid Ahern } 1122b75ed8b1SDavid Ahern dev = __dev_get_by_index(net, nh->fib_nh_oif); 1123066b1030SDavid Ahern if (!dev) { 1124066b1030SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop device required for onlink"); 11251da177e4SLinus Torvalds return -ENODEV; 1126066b1030SDavid Ahern } 1127c3ab2b4eSDavid Ahern if (!(dev->flags & IFF_UP)) { 1128448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop device is not up"); 11291da177e4SLinus Torvalds return -ENETDOWN; 1130c3ab2b4eSDavid Ahern } 1131448d7248SDavid Ahern addr_type = inet_addr_type_dev_table(net, dev, nh->fib_nh_gw4); 1132c3ab2b4eSDavid Ahern if (addr_type != RTN_UNICAST) { 1133448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway"); 113430bbaa19SDavid Ahern return -EINVAL; 1135c3ab2b4eSDavid Ahern } 11368a3d0316SAndy Gospodarek if (!netif_carrier_ok(dev)) 1137b75ed8b1SDavid Ahern nh->fib_nh_flags |= RTNH_F_LINKDOWN; 1138b75ed8b1SDavid Ahern nh->fib_nh_dev = dev; 1139e44b14ebSEric Dumazet dev_hold_track(dev, &nh->fib_nh_dev_tracker, GFP_ATOMIC); 1140b75ed8b1SDavid Ahern nh->fib_nh_scope = RT_SCOPE_LINK; 11411da177e4SLinus Torvalds return 0; 11421da177e4SLinus Torvalds } 1143ebc0ffaeSEric Dumazet rcu_read_lock(); 11441da177e4SLinus Torvalds { 11453bfd8472SDavid Ahern struct fib_table *tbl = NULL; 11469ade2286SDavid S. Miller struct flowi4 fl4 = { 1147b75ed8b1SDavid Ahern .daddr = nh->fib_nh_gw4, 1148448d7248SDavid Ahern .flowi4_scope = scope + 1, 1149b75ed8b1SDavid Ahern .flowi4_oif = nh->fib_nh_oif, 11506a662719SCong Wang .flowi4_iif = LOOPBACK_IFINDEX, 11514e902c57SThomas Graf }; 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds /* It is not necessary, but requires a bit of thinking */ 11549ade2286SDavid S. Miller if (fl4.flowi4_scope < RT_SCOPE_LINK) 11559ade2286SDavid S. Miller fl4.flowi4_scope = RT_SCOPE_LINK; 11563bfd8472SDavid Ahern 11575eea3a63Sguodeqing if (table && table != RT_TABLE_MAIN) 1158448d7248SDavid Ahern tbl = fib_get_table(net, table); 11593bfd8472SDavid Ahern 11603bfd8472SDavid Ahern if (tbl) 11613bfd8472SDavid Ahern err = fib_table_lookup(tbl, &fl4, &res, 11621e313678SEric Dumazet FIB_LOOKUP_IGNORE_LINKSTATE | 11631e313678SEric Dumazet FIB_LOOKUP_NOREF); 11644c9bcd11SDavid Ahern 11654c9bcd11SDavid Ahern /* on error or if no table given do full lookup. This 11664c9bcd11SDavid Ahern * is needed for example when nexthops are in the local 11674c9bcd11SDavid Ahern * table rather than the given table 11684c9bcd11SDavid Ahern */ 11694c9bcd11SDavid Ahern if (!tbl || err) { 11700eeb075fSAndy Gospodarek err = fib_lookup(net, &fl4, &res, 11710eeb075fSAndy Gospodarek FIB_LOOKUP_IGNORE_LINKSTATE); 11724c9bcd11SDavid Ahern } 11734c9bcd11SDavid Ahern 1174ebc0ffaeSEric Dumazet if (err) { 1175448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway"); 1176448d7248SDavid Ahern goto out; 11771da177e4SLinus Torvalds } 1178ebc0ffaeSEric Dumazet } 1179448d7248SDavid Ahern 11801da177e4SLinus Torvalds err = -EINVAL; 1181c3ab2b4eSDavid Ahern if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) { 1182c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway"); 11831da177e4SLinus Torvalds goto out; 1184c3ab2b4eSDavid Ahern } 1185b75ed8b1SDavid Ahern nh->fib_nh_scope = res.scope; 1186b75ed8b1SDavid Ahern nh->fib_nh_oif = FIB_RES_OIF(res); 1187b75ed8b1SDavid Ahern nh->fib_nh_dev = dev = FIB_RES_DEV(res); 1188c3ab2b4eSDavid Ahern if (!dev) { 1189c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1190c3ab2b4eSDavid Ahern "No egress device for nexthop gateway"); 11911da177e4SLinus Torvalds goto out; 1192c3ab2b4eSDavid Ahern } 1193e44b14ebSEric Dumazet dev_hold_track(dev, &nh->fib_nh_dev_tracker, GFP_ATOMIC); 11948a3d0316SAndy Gospodarek if (!netif_carrier_ok(dev)) 1195b75ed8b1SDavid Ahern nh->fib_nh_flags |= RTNH_F_LINKDOWN; 11968723e1b4SEric Dumazet err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN; 1197448d7248SDavid Ahern out: 1198448d7248SDavid Ahern rcu_read_unlock(); 1199448d7248SDavid Ahern return err; 1200448d7248SDavid Ahern } 1201448d7248SDavid Ahern 1202448d7248SDavid Ahern static int fib_check_nh_nongw(struct net *net, struct fib_nh *nh, 1203448d7248SDavid Ahern struct netlink_ext_ack *extack) 1204448d7248SDavid Ahern { 12051da177e4SLinus Torvalds struct in_device *in_dev; 1206448d7248SDavid Ahern int err; 12071da177e4SLinus Torvalds 1208b75ed8b1SDavid Ahern if (nh->fib_nh_flags & (RTNH_F_PERVASIVE | RTNH_F_ONLINK)) { 1209c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1210c3ab2b4eSDavid Ahern "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set"); 12111da177e4SLinus Torvalds return -EINVAL; 1212c3ab2b4eSDavid Ahern } 1213448d7248SDavid Ahern 12148723e1b4SEric Dumazet rcu_read_lock(); 1215448d7248SDavid Ahern 12168723e1b4SEric Dumazet err = -ENODEV; 1217b75ed8b1SDavid Ahern in_dev = inetdev_by_index(net, nh->fib_nh_oif); 121851456b29SIan Morris if (!in_dev) 12198723e1b4SEric Dumazet goto out; 12208723e1b4SEric Dumazet err = -ENETDOWN; 1221c3ab2b4eSDavid Ahern if (!(in_dev->dev->flags & IFF_UP)) { 1222c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Device for nexthop is not up"); 12238723e1b4SEric Dumazet goto out; 1224c3ab2b4eSDavid Ahern } 1225448d7248SDavid Ahern 1226b75ed8b1SDavid Ahern nh->fib_nh_dev = in_dev->dev; 1227e44b14ebSEric Dumazet dev_hold_track(nh->fib_nh_dev, &nh->fib_nh_dev_tracker, GFP_ATOMIC); 1228b75ed8b1SDavid Ahern nh->fib_nh_scope = RT_SCOPE_HOST; 1229b75ed8b1SDavid Ahern if (!netif_carrier_ok(nh->fib_nh_dev)) 1230b75ed8b1SDavid Ahern nh->fib_nh_flags |= RTNH_F_LINKDOWN; 12318723e1b4SEric Dumazet err = 0; 12328723e1b4SEric Dumazet out: 12338723e1b4SEric Dumazet rcu_read_unlock(); 12348723e1b4SEric Dumazet return err; 12351da177e4SLinus Torvalds } 12361da177e4SLinus Torvalds 1237ac1fab2dSDavid Ahern int fib_check_nh(struct net *net, struct fib_nh *nh, u32 table, u8 scope, 1238448d7248SDavid Ahern struct netlink_ext_ack *extack) 1239448d7248SDavid Ahern { 1240448d7248SDavid Ahern int err; 1241448d7248SDavid Ahern 1242448d7248SDavid Ahern if (nh->fib_nh_gw_family == AF_INET) 1243ac1fab2dSDavid Ahern err = fib_check_nh_v4_gw(net, nh, table, scope, extack); 1244717a8f5bSDavid Ahern else if (nh->fib_nh_gw_family == AF_INET6) 1245717a8f5bSDavid Ahern err = fib_check_nh_v6_gw(net, nh, table, extack); 1246448d7248SDavid Ahern else 1247448d7248SDavid Ahern err = fib_check_nh_nongw(net, nh, extack); 1248448d7248SDavid Ahern 1249448d7248SDavid Ahern return err; 1250448d7248SDavid Ahern } 1251448d7248SDavid Ahern 125279eb15daSEric Dumazet static struct hlist_head * 125379eb15daSEric Dumazet fib_info_laddrhash_bucket(const struct net *net, __be32 val) 12541da177e4SLinus Torvalds { 125579eb15daSEric Dumazet u32 slot = hash_32(net_hash_mix(net) ^ (__force u32)val, 125679eb15daSEric Dumazet fib_info_hash_bits); 12571da177e4SLinus Torvalds 125879eb15daSEric Dumazet return &fib_info_laddrhash[slot]; 12591da177e4SLinus Torvalds } 12601da177e4SLinus Torvalds 1261123b9731SDavid S. Miller static void fib_info_hash_move(struct hlist_head *new_info_hash, 12621da177e4SLinus Torvalds struct hlist_head *new_laddrhash, 12631da177e4SLinus Torvalds unsigned int new_size) 12641da177e4SLinus Torvalds { 1265b7656e7fSDavid S. Miller struct hlist_head *old_info_hash, *old_laddrhash; 1266123b9731SDavid S. Miller unsigned int old_size = fib_info_hash_size; 1267ca73b68aSEric Dumazet unsigned int i; 12681da177e4SLinus Torvalds 1269832b4c5eSStephen Hemminger spin_lock_bh(&fib_info_lock); 1270b7656e7fSDavid S. Miller old_info_hash = fib_info_hash; 1271b7656e7fSDavid S. Miller old_laddrhash = fib_info_laddrhash; 1272123b9731SDavid S. Miller fib_info_hash_size = new_size; 127379eb15daSEric Dumazet fib_info_hash_bits = ilog2(new_size); 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds for (i = 0; i < old_size; i++) { 12761da177e4SLinus Torvalds struct hlist_head *head = &fib_info_hash[i]; 1277b67bfe0dSSasha Levin struct hlist_node *n; 12781da177e4SLinus Torvalds struct fib_info *fi; 12791da177e4SLinus Torvalds 1280b67bfe0dSSasha Levin hlist_for_each_entry_safe(fi, n, head, fib_hash) { 12811da177e4SLinus Torvalds struct hlist_head *dest; 12821da177e4SLinus Torvalds unsigned int new_hash; 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds new_hash = fib_info_hashfn(fi); 12851da177e4SLinus Torvalds dest = &new_info_hash[new_hash]; 12861da177e4SLinus Torvalds hlist_add_head(&fi->fib_hash, dest); 12871da177e4SLinus Torvalds } 12881da177e4SLinus Torvalds } 12891da177e4SLinus Torvalds fib_info_hash = new_info_hash; 12901da177e4SLinus Torvalds 129179eb15daSEric Dumazet fib_info_laddrhash = new_laddrhash; 12921da177e4SLinus Torvalds for (i = 0; i < old_size; i++) { 129379eb15daSEric Dumazet struct hlist_head *lhead = &old_laddrhash[i]; 1294b67bfe0dSSasha Levin struct hlist_node *n; 12951da177e4SLinus Torvalds struct fib_info *fi; 12961da177e4SLinus Torvalds 1297b67bfe0dSSasha Levin hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) { 12981da177e4SLinus Torvalds struct hlist_head *ldest; 12991da177e4SLinus Torvalds 130079eb15daSEric Dumazet ldest = fib_info_laddrhash_bucket(fi->fib_net, 130179eb15daSEric Dumazet fi->fib_prefsrc); 13021da177e4SLinus Torvalds hlist_add_head(&fi->fib_lhash, ldest); 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds } 13051da177e4SLinus Torvalds 1306832b4c5eSStephen Hemminger spin_unlock_bh(&fib_info_lock); 1307b7656e7fSDavid S. Miller 1308ca73b68aSEric Dumazet kvfree(old_info_hash); 1309ca73b68aSEric Dumazet kvfree(old_laddrhash); 13101da177e4SLinus Torvalds } 13111da177e4SLinus Torvalds 1312dcb1ecb5SDavid Ahern __be32 fib_info_update_nhc_saddr(struct net *net, struct fib_nh_common *nhc, 1313c3669486SDavid Ahern unsigned char scope) 1314436c3b66SDavid S. Miller { 1315dcb1ecb5SDavid Ahern struct fib_nh *nh; 1316dcb1ecb5SDavid Ahern 1317dcb1ecb5SDavid Ahern if (nhc->nhc_family != AF_INET) 1318dcb1ecb5SDavid Ahern return inet_select_addr(nhc->nhc_dev, 0, scope); 1319dcb1ecb5SDavid Ahern 1320dcb1ecb5SDavid Ahern nh = container_of(nhc, struct fib_nh, nh_common); 1321c3669486SDavid Ahern nh->nh_saddr = inet_select_addr(nh->fib_nh_dev, nh->fib_nh_gw4, scope); 1322436c3b66SDavid S. Miller nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid); 1323436c3b66SDavid S. Miller 1324436c3b66SDavid S. Miller return nh->nh_saddr; 1325436c3b66SDavid S. Miller } 1326436c3b66SDavid S. Miller 1327eba618abSDavid Ahern __be32 fib_result_prefsrc(struct net *net, struct fib_result *res) 1328eba618abSDavid Ahern { 1329eba618abSDavid Ahern struct fib_nh_common *nhc = res->nhc; 1330eba618abSDavid Ahern 1331eba618abSDavid Ahern if (res->fi->fib_prefsrc) 1332eba618abSDavid Ahern return res->fi->fib_prefsrc; 1333eba618abSDavid Ahern 1334dcb1ecb5SDavid Ahern if (nhc->nhc_family == AF_INET) { 1335dcb1ecb5SDavid Ahern struct fib_nh *nh; 1336dcb1ecb5SDavid Ahern 1337eba618abSDavid Ahern nh = container_of(nhc, struct fib_nh, nh_common); 1338eba618abSDavid Ahern if (nh->nh_saddr_genid == atomic_read(&net->ipv4.dev_addr_genid)) 1339eba618abSDavid Ahern return nh->nh_saddr; 1340dcb1ecb5SDavid Ahern } 1341eba618abSDavid Ahern 1342dcb1ecb5SDavid Ahern return fib_info_update_nhc_saddr(net, nhc, res->fi->fib_scope); 1343eba618abSDavid Ahern } 1344eba618abSDavid Ahern 1345021dd3b8SDavid Ahern static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc) 1346021dd3b8SDavid Ahern { 1347021dd3b8SDavid Ahern if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst || 1348021dd3b8SDavid Ahern fib_prefsrc != cfg->fc_dst) { 13499b8ff518SDavid Ahern u32 tb_id = cfg->fc_table; 1350e1b8d903SDavid Ahern int rc; 1351021dd3b8SDavid Ahern 1352021dd3b8SDavid Ahern if (tb_id == RT_TABLE_MAIN) 1353021dd3b8SDavid Ahern tb_id = RT_TABLE_LOCAL; 1354021dd3b8SDavid Ahern 1355e1b8d903SDavid Ahern rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net, 1356e1b8d903SDavid Ahern fib_prefsrc, tb_id); 1357e1b8d903SDavid Ahern 1358e1b8d903SDavid Ahern if (rc != RTN_LOCAL && tb_id != RT_TABLE_LOCAL) { 1359e1b8d903SDavid Ahern rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net, 1360e1b8d903SDavid Ahern fib_prefsrc, RT_TABLE_LOCAL); 1361021dd3b8SDavid Ahern } 1362e1b8d903SDavid Ahern 1363e1b8d903SDavid Ahern if (rc != RTN_LOCAL) 1364e1b8d903SDavid Ahern return false; 1365021dd3b8SDavid Ahern } 1366021dd3b8SDavid Ahern return true; 1367021dd3b8SDavid Ahern } 1368021dd3b8SDavid Ahern 13696d8422a1SDavid Ahern struct fib_info *fib_create_info(struct fib_config *cfg, 13706d8422a1SDavid Ahern struct netlink_ext_ack *extack) 13711da177e4SLinus Torvalds { 13721da177e4SLinus Torvalds int err; 13731da177e4SLinus Torvalds struct fib_info *fi = NULL; 13744c7e8084SDavid Ahern struct nexthop *nh = NULL; 13751da177e4SLinus Torvalds struct fib_info *ofi; 13761da177e4SLinus Torvalds int nhs = 1; 13777462bd74SDenis V. Lunev struct net *net = cfg->fc_nlinfo.nl_net; 13781da177e4SLinus Torvalds 13794c8237cdSDavid S. Miller if (cfg->fc_type > RTN_MAX) 13804c8237cdSDavid S. Miller goto err_inval; 13814c8237cdSDavid S. Miller 13821da177e4SLinus Torvalds /* Fast check to catch the most weird cases */ 1383c3ab2b4eSDavid Ahern if (fib_props[cfg->fc_type].scope > cfg->fc_scope) { 1384c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid scope"); 13851da177e4SLinus Torvalds goto err_inval; 1386c3ab2b4eSDavid Ahern } 13871da177e4SLinus Torvalds 1388c3ab2b4eSDavid Ahern if (cfg->fc_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) { 1389c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1390c3ab2b4eSDavid Ahern "Invalid rtm_flags - can not contain DEAD or LINKDOWN"); 139180610229SJulian Anastasov goto err_inval; 1392c3ab2b4eSDavid Ahern } 139380610229SJulian Anastasov 1394493ced1aSDavid Ahern if (cfg->fc_nh_id) { 13956c48ea5fSDavid Ahern if (!cfg->fc_mx) { 13966c48ea5fSDavid Ahern fi = fib_find_info_nh(net, cfg); 13976c48ea5fSDavid Ahern if (fi) { 139879976892SYajun Deng refcount_inc(&fi->fib_treeref); 13996c48ea5fSDavid Ahern return fi; 14006c48ea5fSDavid Ahern } 14016c48ea5fSDavid Ahern } 14026c48ea5fSDavid Ahern 1403493ced1aSDavid Ahern nh = nexthop_find_by_id(net, cfg->fc_nh_id); 1404493ced1aSDavid Ahern if (!nh) { 1405493ced1aSDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop id does not exist"); 1406493ced1aSDavid Ahern goto err_inval; 1407493ced1aSDavid Ahern } 1408493ced1aSDavid Ahern nhs = 0; 1409493ced1aSDavid Ahern } 1410493ced1aSDavid Ahern 14111da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 14124e902c57SThomas Graf if (cfg->fc_mp) { 14136d8422a1SDavid Ahern nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack); 14141da177e4SLinus Torvalds if (nhs == 0) 14151da177e4SLinus Torvalds goto err_inval; 14161da177e4SLinus Torvalds } 14171da177e4SLinus Torvalds #endif 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds err = -ENOBUFS; 14200a6e6b3cSEric Dumazet 14210a6e6b3cSEric Dumazet /* Paired with WRITE_ONCE() in fib_release_info() */ 14220a6e6b3cSEric Dumazet if (READ_ONCE(fib_info_cnt) >= fib_info_hash_size) { 1423123b9731SDavid S. Miller unsigned int new_size = fib_info_hash_size << 1; 14241da177e4SLinus Torvalds struct hlist_head *new_info_hash; 14251da177e4SLinus Torvalds struct hlist_head *new_laddrhash; 1426ca73b68aSEric Dumazet size_t bytes; 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if (!new_size) 1429d94ce9b2SEric Dumazet new_size = 16; 1430ca73b68aSEric Dumazet bytes = (size_t)new_size * sizeof(struct hlist_head *); 1431ca73b68aSEric Dumazet new_info_hash = kvzalloc(bytes, GFP_KERNEL); 1432ca73b68aSEric Dumazet new_laddrhash = kvzalloc(bytes, GFP_KERNEL); 14331da177e4SLinus Torvalds if (!new_info_hash || !new_laddrhash) { 1434ca73b68aSEric Dumazet kvfree(new_info_hash); 1435ca73b68aSEric Dumazet kvfree(new_laddrhash); 1436ca73b68aSEric Dumazet } else { 1437123b9731SDavid S. Miller fib_info_hash_move(new_info_hash, new_laddrhash, new_size); 1438ca73b68aSEric Dumazet } 1439123b9731SDavid S. Miller if (!fib_info_hash_size) 14401da177e4SLinus Torvalds goto failure; 14411da177e4SLinus Torvalds } 14421da177e4SLinus Torvalds 14431f533ba6SGustavo A. R. Silva fi = kzalloc(struct_size(fi, fib_nh, nhs), GFP_KERNEL); 144451456b29SIan Morris if (!fi) 14451da177e4SLinus Torvalds goto failure; 1446767a2217SDavid Ahern fi->fib_metrics = ip_fib_metrics_init(fi->fib_net, cfg->fc_mx, 1447d7e774f3SDavid Ahern cfg->fc_mx_len, extack); 144888e235b8SEnrico Weigelt if (IS_ERR(fi->fib_metrics)) { 1449767a2217SDavid Ahern err = PTR_ERR(fi->fib_metrics); 1450187e5b3aSEric Dumazet kfree(fi); 1451187e5b3aSEric Dumazet return ERR_PTR(err); 1452187e5b3aSEric Dumazet } 1453767a2217SDavid Ahern 1454efd7ef1cSEric W. Biederman fi->fib_net = net; 14554e902c57SThomas Graf fi->fib_protocol = cfg->fc_protocol; 145637e826c5SDavid S. Miller fi->fib_scope = cfg->fc_scope; 14574e902c57SThomas Graf fi->fib_flags = cfg->fc_flags; 14584e902c57SThomas Graf fi->fib_priority = cfg->fc_priority; 14594e902c57SThomas Graf fi->fib_prefsrc = cfg->fc_prefsrc; 1460f4ef85bbSEric Dumazet fi->fib_type = cfg->fc_type; 14615a56a0b3SMark Tomlinson fi->fib_tb_id = cfg->fc_table; 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds fi->fib_nhs = nhs; 14644c7e8084SDavid Ahern if (nh) { 14654c7e8084SDavid Ahern if (!nexthop_get(nh)) { 14664c7e8084SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has been deleted"); 14674c7e8084SDavid Ahern err = -EINVAL; 14684c7e8084SDavid Ahern } else { 14694c7e8084SDavid Ahern err = 0; 14704c7e8084SDavid Ahern fi->nh = nh; 14714c7e8084SDavid Ahern } 14724c7e8084SDavid Ahern } else { 14731da177e4SLinus Torvalds change_nexthops(fi) { 147471fceff0SDavid S. Miller nexthop_nh->nh_parent = fi; 14751da177e4SLinus Torvalds } endfor_nexthops(fi) 14761da177e4SLinus Torvalds 1477e4516ef6SDavid Ahern if (cfg->fc_mp) 14784c7e8084SDavid Ahern err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg, 14794c7e8084SDavid Ahern extack); 1480e4516ef6SDavid Ahern else 1481e4516ef6SDavid Ahern err = fib_nh_init(net, fi->fib_nh, cfg, 1, extack); 14824c7e8084SDavid Ahern } 1483e4516ef6SDavid Ahern 14844e902c57SThomas Graf if (err != 0) 14851da177e4SLinus Torvalds goto failure; 14861da177e4SLinus Torvalds 14874e902c57SThomas Graf if (fib_props[cfg->fc_type].error) { 1488f35b794bSDavid Ahern if (cfg->fc_gw_family || cfg->fc_oif || cfg->fc_mp) { 1489c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1490c3ab2b4eSDavid Ahern "Gateway, device and multipath can not be specified for this route type"); 14911da177e4SLinus Torvalds goto err_inval; 1492c3ab2b4eSDavid Ahern } 14931da177e4SLinus Torvalds goto link_it; 14944c8237cdSDavid S. Miller } else { 14954c8237cdSDavid S. Miller switch (cfg->fc_type) { 14964c8237cdSDavid S. Miller case RTN_UNICAST: 14974c8237cdSDavid S. Miller case RTN_LOCAL: 14984c8237cdSDavid S. Miller case RTN_BROADCAST: 14994c8237cdSDavid S. Miller case RTN_ANYCAST: 15004c8237cdSDavid S. Miller case RTN_MULTICAST: 15014c8237cdSDavid S. Miller break; 15024c8237cdSDavid S. Miller default: 1503c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid route type"); 15044c8237cdSDavid S. Miller goto err_inval; 15054c8237cdSDavid S. Miller } 15061da177e4SLinus Torvalds } 15071da177e4SLinus Torvalds 1508c3ab2b4eSDavid Ahern if (cfg->fc_scope > RT_SCOPE_HOST) { 1509c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid scope"); 15101da177e4SLinus Torvalds goto err_inval; 1511c3ab2b4eSDavid Ahern } 15121da177e4SLinus Torvalds 15134c7e8084SDavid Ahern if (fi->nh) { 15144c7e8084SDavid Ahern err = fib_check_nexthop(fi->nh, cfg->fc_scope, extack); 15154c7e8084SDavid Ahern if (err) 15164c7e8084SDavid Ahern goto failure; 15174c7e8084SDavid Ahern } else if (cfg->fc_scope == RT_SCOPE_HOST) { 15181da177e4SLinus Torvalds struct fib_nh *nh = fi->fib_nh; 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds /* Local address is added. */ 1521c3ab2b4eSDavid Ahern if (nhs != 1) { 1522c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1523c3ab2b4eSDavid Ahern "Route with host scope can not have multiple nexthops"); 15246d8422a1SDavid Ahern goto err_inval; 1525c3ab2b4eSDavid Ahern } 1526bdf00467SDavid Ahern if (nh->fib_nh_gw_family) { 1527c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1528c3ab2b4eSDavid Ahern "Route with host scope can not have a gateway"); 15291da177e4SLinus Torvalds goto err_inval; 1530c3ab2b4eSDavid Ahern } 1531b75ed8b1SDavid Ahern nh->fib_nh_scope = RT_SCOPE_NOWHERE; 15325481d73fSDavid Ahern nh->fib_nh_dev = dev_get_by_index(net, nh->fib_nh_oif); 15331da177e4SLinus Torvalds err = -ENODEV; 1534b75ed8b1SDavid Ahern if (!nh->fib_nh_dev) 15351da177e4SLinus Torvalds goto failure; 1536e44b14ebSEric Dumazet netdev_tracker_alloc(nh->fib_nh_dev, &nh->fib_nh_dev_tracker, 1537e44b14ebSEric Dumazet GFP_KERNEL); 15381da177e4SLinus Torvalds } else { 15398a3d0316SAndy Gospodarek int linkdown = 0; 15408a3d0316SAndy Gospodarek 15411da177e4SLinus Torvalds change_nexthops(fi) { 1542ac1fab2dSDavid Ahern err = fib_check_nh(cfg->fc_nlinfo.nl_net, nexthop_nh, 1543ac1fab2dSDavid Ahern cfg->fc_table, cfg->fc_scope, 1544ac1fab2dSDavid Ahern extack); 15456a31d2a9SEric Dumazet if (err != 0) 15461da177e4SLinus Torvalds goto failure; 1547b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) 15488a3d0316SAndy Gospodarek linkdown++; 15491da177e4SLinus Torvalds } endfor_nexthops(fi) 15508a3d0316SAndy Gospodarek if (linkdown == fi->fib_nhs) 15518a3d0316SAndy Gospodarek fi->fib_flags |= RTNH_F_LINKDOWN; 15521da177e4SLinus Torvalds } 15531da177e4SLinus Torvalds 1554c3ab2b4eSDavid Ahern if (fi->fib_prefsrc && !fib_valid_prefsrc(cfg, fi->fib_prefsrc)) { 1555c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid prefsrc address"); 15561da177e4SLinus Torvalds goto err_inval; 1557c3ab2b4eSDavid Ahern } 15581da177e4SLinus Torvalds 15594c7e8084SDavid Ahern if (!fi->nh) { 15601fc050a1SDavid S. Miller change_nexthops(fi) { 1561dcb1ecb5SDavid Ahern fib_info_update_nhc_saddr(net, &nexthop_nh->nh_common, 1562dcb1ecb5SDavid Ahern fi->fib_scope); 156319a9d136SDavid Ahern if (nexthop_nh->fib_nh_gw_family == AF_INET6) 156419a9d136SDavid Ahern fi->fib_nh_is_v6 = true; 15651fc050a1SDavid S. Miller } endfor_nexthops(fi) 15661fc050a1SDavid S. Miller 15670e884c78SPeter Nørlund fib_rebalance(fi); 15684c7e8084SDavid Ahern } 15690e884c78SPeter Nørlund 15701da177e4SLinus Torvalds link_it: 15716a31d2a9SEric Dumazet ofi = fib_find_info(fi); 15726a31d2a9SEric Dumazet if (ofi) { 15731da177e4SLinus Torvalds fi->fib_dead = 1; 15741da177e4SLinus Torvalds free_fib_info(fi); 157579976892SYajun Deng refcount_inc(&ofi->fib_treeref); 15761da177e4SLinus Torvalds return ofi; 15771da177e4SLinus Torvalds } 15781da177e4SLinus Torvalds 157928814cd1SDavid Ahern refcount_set(&fi->fib_treeref, 1); 15800029c0deSReshetova, Elena refcount_set(&fi->fib_clntref, 1); 1581832b4c5eSStephen Hemminger spin_lock_bh(&fib_info_lock); 15820a6e6b3cSEric Dumazet fib_info_cnt++; 15831da177e4SLinus Torvalds hlist_add_head(&fi->fib_hash, 15841da177e4SLinus Torvalds &fib_info_hash[fib_info_hashfn(fi)]); 15851da177e4SLinus Torvalds if (fi->fib_prefsrc) { 15861da177e4SLinus Torvalds struct hlist_head *head; 15871da177e4SLinus Torvalds 158879eb15daSEric Dumazet head = fib_info_laddrhash_bucket(net, fi->fib_prefsrc); 15891da177e4SLinus Torvalds hlist_add_head(&fi->fib_lhash, head); 15901da177e4SLinus Torvalds } 15914c7e8084SDavid Ahern if (fi->nh) { 15924c7e8084SDavid Ahern list_add(&fi->nh_list, &nh->fi_list); 15934c7e8084SDavid Ahern } else { 15941da177e4SLinus Torvalds change_nexthops(fi) { 15951da177e4SLinus Torvalds struct hlist_head *head; 15961da177e4SLinus Torvalds 1597b75ed8b1SDavid Ahern if (!nexthop_nh->fib_nh_dev) 15981da177e4SLinus Torvalds continue; 1599d07418afSEric Dumazet head = fib_info_devhash_bucket(nexthop_nh->fib_nh_dev); 160071fceff0SDavid S. Miller hlist_add_head(&nexthop_nh->nh_hash, head); 16011da177e4SLinus Torvalds } endfor_nexthops(fi) 16024c7e8084SDavid Ahern } 1603832b4c5eSStephen Hemminger spin_unlock_bh(&fib_info_lock); 16041da177e4SLinus Torvalds return fi; 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds err_inval: 16071da177e4SLinus Torvalds err = -EINVAL; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds failure: 16101da177e4SLinus Torvalds if (fi) { 16111da177e4SLinus Torvalds fi->fib_dead = 1; 16121da177e4SLinus Torvalds free_fib_info(fi); 16131da177e4SLinus Torvalds } 16144e902c57SThomas Graf 16154e902c57SThomas Graf return ERR_PTR(err); 16161da177e4SLinus Torvalds } 16171da177e4SLinus Torvalds 1618c0a72077SDavid Ahern int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nhc, 16197bdf4de1SDonald Sharp u8 rt_family, unsigned char *flags, bool skip_oif) 1620b0f60193SDavid Ahern { 1621c2364199SDavid Ahern if (nhc->nhc_flags & RTNH_F_DEAD) 1622b0f60193SDavid Ahern *flags |= RTNH_F_DEAD; 1623b0f60193SDavid Ahern 1624c2364199SDavid Ahern if (nhc->nhc_flags & RTNH_F_LINKDOWN) { 1625b0f60193SDavid Ahern *flags |= RTNH_F_LINKDOWN; 1626b0f60193SDavid Ahern 1627b0f60193SDavid Ahern rcu_read_lock(); 1628c2364199SDavid Ahern switch (nhc->nhc_family) { 1629c2364199SDavid Ahern case AF_INET: 1630c2364199SDavid Ahern if (ip_ignore_linkdown(nhc->nhc_dev)) 1631b0f60193SDavid Ahern *flags |= RTNH_F_DEAD; 1632c2364199SDavid Ahern break; 1633c0a72077SDavid Ahern case AF_INET6: 1634c0a72077SDavid Ahern if (ip6_ignore_linkdown(nhc->nhc_dev)) 1635c0a72077SDavid Ahern *flags |= RTNH_F_DEAD; 1636c0a72077SDavid Ahern break; 1637c2364199SDavid Ahern } 1638b0f60193SDavid Ahern rcu_read_unlock(); 1639b0f60193SDavid Ahern } 1640b0f60193SDavid Ahern 1641bdf00467SDavid Ahern switch (nhc->nhc_gw_family) { 1642c2364199SDavid Ahern case AF_INET: 1643c2364199SDavid Ahern if (nla_put_in_addr(skb, RTA_GATEWAY, nhc->nhc_gw.ipv4)) 1644b0f60193SDavid Ahern goto nla_put_failure; 1645c2364199SDavid Ahern break; 1646c0a72077SDavid Ahern case AF_INET6: 1647d1566268SDavid Ahern /* if gateway family does not match nexthop family 1648d1566268SDavid Ahern * gateway is encoded as RTA_VIA 1649d1566268SDavid Ahern */ 16507bdf4de1SDonald Sharp if (rt_family != nhc->nhc_gw_family) { 1651d1566268SDavid Ahern int alen = sizeof(struct in6_addr); 1652d1566268SDavid Ahern struct nlattr *nla; 1653d1566268SDavid Ahern struct rtvia *via; 1654d1566268SDavid Ahern 1655d1566268SDavid Ahern nla = nla_reserve(skb, RTA_VIA, alen + 2); 1656d1566268SDavid Ahern if (!nla) 1657c0a72077SDavid Ahern goto nla_put_failure; 1658d1566268SDavid Ahern 1659d1566268SDavid Ahern via = nla_data(nla); 1660d1566268SDavid Ahern via->rtvia_family = AF_INET6; 1661d1566268SDavid Ahern memcpy(via->rtvia_addr, &nhc->nhc_gw.ipv6, alen); 1662d1566268SDavid Ahern } else if (nla_put_in6_addr(skb, RTA_GATEWAY, 1663d1566268SDavid Ahern &nhc->nhc_gw.ipv6) < 0) { 1664d1566268SDavid Ahern goto nla_put_failure; 1665d1566268SDavid Ahern } 1666c0a72077SDavid Ahern break; 1667c2364199SDavid Ahern } 1668b0f60193SDavid Ahern 1669ca787e0bSIdo Schimmel *flags |= (nhc->nhc_flags & 1670ca787e0bSIdo Schimmel (RTNH_F_ONLINK | RTNH_F_OFFLOAD | RTNH_F_TRAP)); 1671b0f60193SDavid Ahern 1672c2364199SDavid Ahern if (!skip_oif && nhc->nhc_dev && 1673c2364199SDavid Ahern nla_put_u32(skb, RTA_OIF, nhc->nhc_dev->ifindex)) 1674b0f60193SDavid Ahern goto nla_put_failure; 1675b0f60193SDavid Ahern 1676c2364199SDavid Ahern if (nhc->nhc_lwtstate && 1677ffa8ce54SDavid Ahern lwtunnel_fill_encap(skb, nhc->nhc_lwtstate, 1678ffa8ce54SDavid Ahern RTA_ENCAP, RTA_ENCAP_TYPE) < 0) 1679b0f60193SDavid Ahern goto nla_put_failure; 1680b0f60193SDavid Ahern 1681b0f60193SDavid Ahern return 0; 1682b0f60193SDavid Ahern 1683b0f60193SDavid Ahern nla_put_failure: 1684b0f60193SDavid Ahern return -EMSGSIZE; 1685b0f60193SDavid Ahern } 1686c0a72077SDavid Ahern EXPORT_SYMBOL_GPL(fib_nexthop_info); 1687b0f60193SDavid Ahern 1688c0a72077SDavid Ahern #if IS_ENABLED(CONFIG_IP_ROUTE_MULTIPATH) || IS_ENABLED(CONFIG_IPV6) 1689c0a72077SDavid Ahern int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nhc, 1690597aa16cSXiao Liang int nh_weight, u8 rt_family, u32 nh_tclassid) 1691b0f60193SDavid Ahern { 1692c2364199SDavid Ahern const struct net_device *dev = nhc->nhc_dev; 1693b0f60193SDavid Ahern struct rtnexthop *rtnh; 1694ecc5663cSDavid Ahern unsigned char flags = 0; 1695b0f60193SDavid Ahern 1696b0f60193SDavid Ahern rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh)); 1697b0f60193SDavid Ahern if (!rtnh) 1698b0f60193SDavid Ahern goto nla_put_failure; 1699b0f60193SDavid Ahern 1700c2364199SDavid Ahern rtnh->rtnh_hops = nh_weight - 1; 1701b0f60193SDavid Ahern rtnh->rtnh_ifindex = dev ? dev->ifindex : 0; 1702b0f60193SDavid Ahern 17037bdf4de1SDonald Sharp if (fib_nexthop_info(skb, nhc, rt_family, &flags, true) < 0) 1704b0f60193SDavid Ahern goto nla_put_failure; 1705b0f60193SDavid Ahern 1706b0f60193SDavid Ahern rtnh->rtnh_flags = flags; 1707b0f60193SDavid Ahern 1708597aa16cSXiao Liang if (nh_tclassid && nla_put_u32(skb, RTA_FLOW, nh_tclassid)) 1709597aa16cSXiao Liang goto nla_put_failure; 1710597aa16cSXiao Liang 1711b0f60193SDavid Ahern /* length of rtnetlink header + attributes */ 1712b0f60193SDavid Ahern rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh; 1713b0f60193SDavid Ahern 1714b0f60193SDavid Ahern return 0; 1715b0f60193SDavid Ahern 1716b0f60193SDavid Ahern nla_put_failure: 1717b0f60193SDavid Ahern return -EMSGSIZE; 1718b0f60193SDavid Ahern } 1719c0a72077SDavid Ahern EXPORT_SYMBOL_GPL(fib_add_nexthop); 1720c2364199SDavid Ahern #endif 1721b0f60193SDavid Ahern 1722c2364199SDavid Ahern #ifdef CONFIG_IP_ROUTE_MULTIPATH 1723b0f60193SDavid Ahern static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi) 1724b0f60193SDavid Ahern { 1725b0f60193SDavid Ahern struct nlattr *mp; 1726b0f60193SDavid Ahern 1727ae0be8deSMichal Kubecek mp = nla_nest_start_noflag(skb, RTA_MULTIPATH); 1728b0f60193SDavid Ahern if (!mp) 1729b0f60193SDavid Ahern goto nla_put_failure; 1730b0f60193SDavid Ahern 17314c7e8084SDavid Ahern if (unlikely(fi->nh)) { 17327bdf4de1SDonald Sharp if (nexthop_mpath_fill_node(skb, fi->nh, AF_INET) < 0) 17334c7e8084SDavid Ahern goto nla_put_failure; 17344c7e8084SDavid Ahern goto mp_end; 17354c7e8084SDavid Ahern } 17364c7e8084SDavid Ahern 1737b0f60193SDavid Ahern for_nexthops(fi) { 1738597aa16cSXiao Liang u32 nh_tclassid = 0; 1739b0f60193SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 1740597aa16cSXiao Liang nh_tclassid = nh->nh_tclassid; 1741b0f60193SDavid Ahern #endif 1742597aa16cSXiao Liang if (fib_add_nexthop(skb, &nh->nh_common, nh->fib_nh_weight, 1743597aa16cSXiao Liang AF_INET, nh_tclassid) < 0) 1744597aa16cSXiao Liang goto nla_put_failure; 1745b0f60193SDavid Ahern } endfor_nexthops(fi); 1746b0f60193SDavid Ahern 17474c7e8084SDavid Ahern mp_end: 1748b0f60193SDavid Ahern nla_nest_end(skb, mp); 1749b0f60193SDavid Ahern 1750b0f60193SDavid Ahern return 0; 1751b0f60193SDavid Ahern 1752b0f60193SDavid Ahern nla_put_failure: 1753b0f60193SDavid Ahern return -EMSGSIZE; 1754b0f60193SDavid Ahern } 1755b0f60193SDavid Ahern #else 1756b0f60193SDavid Ahern static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi) 1757b0f60193SDavid Ahern { 1758b0f60193SDavid Ahern return 0; 1759b0f60193SDavid Ahern } 1760b0f60193SDavid Ahern #endif 1761b0f60193SDavid Ahern 176215e47304SEric W. Biederman int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event, 176308554789SAmit Cohen const struct fib_rt_info *fri, unsigned int flags) 17641da177e4SLinus Torvalds { 17651e301fd0SIdo Schimmel unsigned int nhs = fib_info_num_path(fri->fi); 17661e301fd0SIdo Schimmel struct fib_info *fi = fri->fi; 17671e301fd0SIdo Schimmel u32 tb_id = fri->tb_id; 17681da177e4SLinus Torvalds struct nlmsghdr *nlh; 1769be403ea1SThomas Graf struct rtmsg *rtm; 17701da177e4SLinus Torvalds 177115e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags); 177251456b29SIan Morris if (!nlh) 177326932566SPatrick McHardy return -EMSGSIZE; 1774be403ea1SThomas Graf 1775be403ea1SThomas Graf rtm = nlmsg_data(nlh); 17761da177e4SLinus Torvalds rtm->rtm_family = AF_INET; 17771e301fd0SIdo Schimmel rtm->rtm_dst_len = fri->dst_len; 17781da177e4SLinus Torvalds rtm->rtm_src_len = 0; 17791e301fd0SIdo Schimmel rtm->rtm_tos = fri->tos; 1780709772e6SKrzysztof Piotr Oledzki if (tb_id < 256) 17811da177e4SLinus Torvalds rtm->rtm_table = tb_id; 1782709772e6SKrzysztof Piotr Oledzki else 1783709772e6SKrzysztof Piotr Oledzki rtm->rtm_table = RT_TABLE_COMPAT; 1784f3756b79SDavid S. Miller if (nla_put_u32(skb, RTA_TABLE, tb_id)) 1785f3756b79SDavid S. Miller goto nla_put_failure; 17861e301fd0SIdo Schimmel rtm->rtm_type = fri->type; 17871da177e4SLinus Torvalds rtm->rtm_flags = fi->fib_flags; 178837e826c5SDavid S. Miller rtm->rtm_scope = fi->fib_scope; 17891da177e4SLinus Torvalds rtm->rtm_protocol = fi->fib_protocol; 1790be403ea1SThomas Graf 1791f3756b79SDavid S. Miller if (rtm->rtm_dst_len && 17921e301fd0SIdo Schimmel nla_put_in_addr(skb, RTA_DST, fri->dst)) 1793f3756b79SDavid S. Miller goto nla_put_failure; 1794f3756b79SDavid S. Miller if (fi->fib_priority && 1795f3756b79SDavid S. Miller nla_put_u32(skb, RTA_PRIORITY, fi->fib_priority)) 1796f3756b79SDavid S. Miller goto nla_put_failure; 17973fb07dafSEric Dumazet if (rtnetlink_put_metrics(skb, fi->fib_metrics->metrics) < 0) 1798be403ea1SThomas Graf goto nla_put_failure; 1799be403ea1SThomas Graf 1800f3756b79SDavid S. Miller if (fi->fib_prefsrc && 1801930345eaSJiri Benc nla_put_in_addr(skb, RTA_PREFSRC, fi->fib_prefsrc)) 1802f3756b79SDavid S. Miller goto nla_put_failure; 18034c7e8084SDavid Ahern 18044c7e8084SDavid Ahern if (fi->nh) { 18054c7e8084SDavid Ahern if (nla_put_u32(skb, RTA_NH_ID, fi->nh->id)) 18064c7e8084SDavid Ahern goto nla_put_failure; 18074c7e8084SDavid Ahern if (nexthop_is_blackhole(fi->nh)) 18084c7e8084SDavid Ahern rtm->rtm_type = RTN_BLACKHOLE; 18094f80116dSRoopa Prabhu if (!fi->fib_net->ipv4.sysctl_nexthop_compat_mode) 18104f80116dSRoopa Prabhu goto offload; 18114c7e8084SDavid Ahern } 18124c7e8084SDavid Ahern 18135481d73fSDavid Ahern if (nhs == 1) { 1814dcb1ecb5SDavid Ahern const struct fib_nh_common *nhc = fib_info_nhc(fi, 0); 1815ecc5663cSDavid Ahern unsigned char flags = 0; 1816be403ea1SThomas Graf 18177bdf4de1SDonald Sharp if (fib_nexthop_info(skb, nhc, AF_INET, &flags, false) < 0) 1818be403ea1SThomas Graf goto nla_put_failure; 18191da177e4SLinus Torvalds 1820b0f60193SDavid Ahern rtm->rtm_flags = flags; 1821c7066f70SPatrick McHardy #ifdef CONFIG_IP_ROUTE_CLASSID 1822dcb1ecb5SDavid Ahern if (nhc->nhc_family == AF_INET) { 1823dcb1ecb5SDavid Ahern struct fib_nh *nh; 1824dcb1ecb5SDavid Ahern 1825dcb1ecb5SDavid Ahern nh = container_of(nhc, struct fib_nh, nh_common); 1826f3756b79SDavid S. Miller if (nh->nh_tclassid && 1827f3756b79SDavid S. Miller nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid)) 1828f3756b79SDavid S. Miller goto nla_put_failure; 1829dcb1ecb5SDavid Ahern } 18308265abc0SPatrick McHardy #endif 1831b0f60193SDavid Ahern } else { 1832b0f60193SDavid Ahern if (fib_add_multipath(skb, fi) < 0) 1833ea7a8085SDavid Ahern goto nla_put_failure; 18341da177e4SLinus Torvalds } 1835b0f60193SDavid Ahern 18364f80116dSRoopa Prabhu offload: 183790b93f1bSIdo Schimmel if (fri->offload) 183890b93f1bSIdo Schimmel rtm->rtm_flags |= RTM_F_OFFLOAD; 183990b93f1bSIdo Schimmel if (fri->trap) 184090b93f1bSIdo Schimmel rtm->rtm_flags |= RTM_F_TRAP; 184136c5100eSAmit Cohen if (fri->offload_failed) 184236c5100eSAmit Cohen rtm->rtm_flags |= RTM_F_OFFLOAD_FAILED; 184390b93f1bSIdo Schimmel 1844053c095aSJohannes Berg nlmsg_end(skb, nlh); 1845053c095aSJohannes Berg return 0; 18461da177e4SLinus Torvalds 1847be403ea1SThomas Graf nla_put_failure: 184826932566SPatrick McHardy nlmsg_cancel(skb, nlh); 184926932566SPatrick McHardy return -EMSGSIZE; 18501da177e4SLinus Torvalds } 18511da177e4SLinus Torvalds 18521da177e4SLinus Torvalds /* 18536a31d2a9SEric Dumazet * Update FIB if: 18546a31d2a9SEric Dumazet * - local address disappeared -> we must delete all the entries 18556a31d2a9SEric Dumazet * referring to it. 18566a31d2a9SEric Dumazet * - device went down -> we must shutdown all nexthops going via it. 18571da177e4SLinus Torvalds */ 18585a56a0b3SMark Tomlinson int fib_sync_down_addr(struct net_device *dev, __be32 local) 18591da177e4SLinus Torvalds { 1860e0a31262SDavid Ahern int tb_id = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN; 18615a56a0b3SMark Tomlinson struct net *net = dev_net(dev); 186279eb15daSEric Dumazet struct hlist_head *head; 18631da177e4SLinus Torvalds struct fib_info *fi; 186479eb15daSEric Dumazet int ret = 0; 18651da177e4SLinus Torvalds 186651456b29SIan Morris if (!fib_info_laddrhash || local == 0) 186785326fa5SDenis V. Lunev return 0; 186885326fa5SDenis V. Lunev 186979eb15daSEric Dumazet head = fib_info_laddrhash_bucket(net, local); 1870b67bfe0dSSasha Levin hlist_for_each_entry(fi, head, fib_lhash) { 18715a56a0b3SMark Tomlinson if (!net_eq(fi->fib_net, net) || 18725a56a0b3SMark Tomlinson fi->fib_tb_id != tb_id) 18734814bdbdSDenis V. Lunev continue; 18741da177e4SLinus Torvalds if (fi->fib_prefsrc == local) { 18751da177e4SLinus Torvalds fi->fib_flags |= RTNH_F_DEAD; 18761da177e4SLinus Torvalds ret++; 18771da177e4SLinus Torvalds } 18781da177e4SLinus Torvalds } 187985326fa5SDenis V. Lunev return ret; 18801da177e4SLinus Torvalds } 18811da177e4SLinus Torvalds 1882b75ed8b1SDavid Ahern static int call_fib_nh_notifiers(struct fib_nh *nh, 1883982acb97SIdo Schimmel enum fib_event_type event_type) 1884982acb97SIdo Schimmel { 1885b75ed8b1SDavid Ahern bool ignore_link_down = ip_ignore_linkdown(nh->fib_nh_dev); 1886982acb97SIdo Schimmel struct fib_nh_notifier_info info = { 1887b75ed8b1SDavid Ahern .fib_nh = nh, 1888982acb97SIdo Schimmel }; 1889982acb97SIdo Schimmel 1890982acb97SIdo Schimmel switch (event_type) { 1891982acb97SIdo Schimmel case FIB_EVENT_NH_ADD: 1892b75ed8b1SDavid Ahern if (nh->fib_nh_flags & RTNH_F_DEAD) 1893982acb97SIdo Schimmel break; 1894b75ed8b1SDavid Ahern if (ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) 1895982acb97SIdo Schimmel break; 1896b75ed8b1SDavid Ahern return call_fib4_notifiers(dev_net(nh->fib_nh_dev), event_type, 1897982acb97SIdo Schimmel &info.info); 1898982acb97SIdo Schimmel case FIB_EVENT_NH_DEL: 1899b75ed8b1SDavid Ahern if ((ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) || 1900b75ed8b1SDavid Ahern (nh->fib_nh_flags & RTNH_F_DEAD)) 1901b75ed8b1SDavid Ahern return call_fib4_notifiers(dev_net(nh->fib_nh_dev), 1902982acb97SIdo Schimmel event_type, &info.info); 190379121184SGustavo A. R. Silva break; 1904982acb97SIdo Schimmel default: 1905982acb97SIdo Schimmel break; 1906982acb97SIdo Schimmel } 1907982acb97SIdo Schimmel 1908982acb97SIdo Schimmel return NOTIFY_DONE; 1909982acb97SIdo Schimmel } 1910982acb97SIdo Schimmel 1911af7d6cceSSabrina Dubroca /* Update the PMTU of exceptions when: 1912af7d6cceSSabrina Dubroca * - the new MTU of the first hop becomes smaller than the PMTU 1913af7d6cceSSabrina Dubroca * - the old MTU was the same as the PMTU, and it limited discovery of 1914af7d6cceSSabrina Dubroca * larger MTUs on the path. With that limit raised, we can now 1915af7d6cceSSabrina Dubroca * discover larger MTUs 1916af7d6cceSSabrina Dubroca * A special case is locked exceptions, for which the PMTU is smaller 1917af7d6cceSSabrina Dubroca * than the minimal accepted PMTU: 1918af7d6cceSSabrina Dubroca * - if the new MTU is greater than the PMTU, don't make any change 1919af7d6cceSSabrina Dubroca * - otherwise, unlock and set PMTU 1920af7d6cceSSabrina Dubroca */ 192106c77c3eSDavid Ahern void fib_nhc_update_mtu(struct fib_nh_common *nhc, u32 new, u32 orig) 1922af7d6cceSSabrina Dubroca { 1923af7d6cceSSabrina Dubroca struct fnhe_hash_bucket *bucket; 1924af7d6cceSSabrina Dubroca int i; 1925af7d6cceSSabrina Dubroca 1926a5995e71SDavid Ahern bucket = rcu_dereference_protected(nhc->nhc_exceptions, 1); 1927af7d6cceSSabrina Dubroca if (!bucket) 1928af7d6cceSSabrina Dubroca return; 1929af7d6cceSSabrina Dubroca 1930af7d6cceSSabrina Dubroca for (i = 0; i < FNHE_HASH_SIZE; i++) { 1931af7d6cceSSabrina Dubroca struct fib_nh_exception *fnhe; 1932af7d6cceSSabrina Dubroca 1933af7d6cceSSabrina Dubroca for (fnhe = rcu_dereference_protected(bucket[i].chain, 1); 1934af7d6cceSSabrina Dubroca fnhe; 1935af7d6cceSSabrina Dubroca fnhe = rcu_dereference_protected(fnhe->fnhe_next, 1)) { 1936af7d6cceSSabrina Dubroca if (fnhe->fnhe_mtu_locked) { 1937af7d6cceSSabrina Dubroca if (new <= fnhe->fnhe_pmtu) { 1938af7d6cceSSabrina Dubroca fnhe->fnhe_pmtu = new; 1939af7d6cceSSabrina Dubroca fnhe->fnhe_mtu_locked = false; 1940af7d6cceSSabrina Dubroca } 1941af7d6cceSSabrina Dubroca } else if (new < fnhe->fnhe_pmtu || 1942af7d6cceSSabrina Dubroca orig == fnhe->fnhe_pmtu) { 1943af7d6cceSSabrina Dubroca fnhe->fnhe_pmtu = new; 1944af7d6cceSSabrina Dubroca } 1945af7d6cceSSabrina Dubroca } 1946af7d6cceSSabrina Dubroca } 1947af7d6cceSSabrina Dubroca } 1948af7d6cceSSabrina Dubroca 1949af7d6cceSSabrina Dubroca void fib_sync_mtu(struct net_device *dev, u32 orig_mtu) 1950af7d6cceSSabrina Dubroca { 1951d07418afSEric Dumazet struct hlist_head *head = fib_info_devhash_bucket(dev); 1952af7d6cceSSabrina Dubroca struct fib_nh *nh; 1953af7d6cceSSabrina Dubroca 1954af7d6cceSSabrina Dubroca hlist_for_each_entry(nh, head, nh_hash) { 1955b75ed8b1SDavid Ahern if (nh->fib_nh_dev == dev) 195606c77c3eSDavid Ahern fib_nhc_update_mtu(&nh->nh_common, dev->mtu, orig_mtu); 1957af7d6cceSSabrina Dubroca } 1958af7d6cceSSabrina Dubroca } 1959af7d6cceSSabrina Dubroca 19604f823defSJulian Anastasov /* Event force Flags Description 19614f823defSJulian Anastasov * NETDEV_CHANGE 0 LINKDOWN Carrier OFF, not for scope host 19624f823defSJulian Anastasov * NETDEV_DOWN 0 LINKDOWN|DEAD Link down, not for scope host 19634f823defSJulian Anastasov * NETDEV_DOWN 1 LINKDOWN|DEAD Last address removed 19644f823defSJulian Anastasov * NETDEV_UNREGISTER 1 LINKDOWN|DEAD Device removed 19654c7e8084SDavid Ahern * 19664c7e8084SDavid Ahern * only used when fib_nh is built into fib_info 19674f823defSJulian Anastasov */ 19684f823defSJulian Anastasov int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force) 196985326fa5SDenis V. Lunev { 1970d07418afSEric Dumazet struct hlist_head *head = fib_info_devhash_bucket(dev); 19711da177e4SLinus Torvalds struct fib_info *prev_fi = NULL; 1972d07418afSEric Dumazet int scope = RT_SCOPE_NOWHERE; 19731da177e4SLinus Torvalds struct fib_nh *nh; 1974d07418afSEric Dumazet int ret = 0; 19751da177e4SLinus Torvalds 19764f823defSJulian Anastasov if (force) 197785326fa5SDenis V. Lunev scope = -1; 197885326fa5SDenis V. Lunev 1979b67bfe0dSSasha Levin hlist_for_each_entry(nh, head, nh_hash) { 19801da177e4SLinus Torvalds struct fib_info *fi = nh->nh_parent; 19811da177e4SLinus Torvalds int dead; 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds BUG_ON(!fi->fib_nhs); 1984b75ed8b1SDavid Ahern if (nh->fib_nh_dev != dev || fi == prev_fi) 19851da177e4SLinus Torvalds continue; 19861da177e4SLinus Torvalds prev_fi = fi; 19871da177e4SLinus Torvalds dead = 0; 19881da177e4SLinus Torvalds change_nexthops(fi) { 1989b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) 19901da177e4SLinus Torvalds dead++; 1991b75ed8b1SDavid Ahern else if (nexthop_nh->fib_nh_dev == dev && 1992b75ed8b1SDavid Ahern nexthop_nh->fib_nh_scope != scope) { 19938a3d0316SAndy Gospodarek switch (event) { 19948a3d0316SAndy Gospodarek case NETDEV_DOWN: 19958a3d0316SAndy Gospodarek case NETDEV_UNREGISTER: 1996b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags |= RTNH_F_DEAD; 1997a8eceea8SJoe Perches fallthrough; 19988a3d0316SAndy Gospodarek case NETDEV_CHANGE: 1999b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags |= RTNH_F_LINKDOWN; 20008a3d0316SAndy Gospodarek break; 20018a3d0316SAndy Gospodarek } 2002982acb97SIdo Schimmel call_fib_nh_notifiers(nexthop_nh, 2003982acb97SIdo Schimmel FIB_EVENT_NH_DEL); 20041da177e4SLinus Torvalds dead++; 20051da177e4SLinus Torvalds } 20061da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 20078a3d0316SAndy Gospodarek if (event == NETDEV_UNREGISTER && 2008b75ed8b1SDavid Ahern nexthop_nh->fib_nh_dev == dev) { 20091da177e4SLinus Torvalds dead = fi->fib_nhs; 20101da177e4SLinus Torvalds break; 20111da177e4SLinus Torvalds } 20121da177e4SLinus Torvalds #endif 20131da177e4SLinus Torvalds } endfor_nexthops(fi) 20141da177e4SLinus Torvalds if (dead == fi->fib_nhs) { 20158a3d0316SAndy Gospodarek switch (event) { 20168a3d0316SAndy Gospodarek case NETDEV_DOWN: 20178a3d0316SAndy Gospodarek case NETDEV_UNREGISTER: 20181da177e4SLinus Torvalds fi->fib_flags |= RTNH_F_DEAD; 2019a8eceea8SJoe Perches fallthrough; 20208a3d0316SAndy Gospodarek case NETDEV_CHANGE: 20218a3d0316SAndy Gospodarek fi->fib_flags |= RTNH_F_LINKDOWN; 20228a3d0316SAndy Gospodarek break; 20238a3d0316SAndy Gospodarek } 20241da177e4SLinus Torvalds ret++; 20251da177e4SLinus Torvalds } 20260e884c78SPeter Nørlund 20270e884c78SPeter Nørlund fib_rebalance(fi); 20281da177e4SLinus Torvalds } 20291da177e4SLinus Torvalds 20301da177e4SLinus Torvalds return ret; 20311da177e4SLinus Torvalds } 20321da177e4SLinus Torvalds 20330c838ff1SDavid S. Miller /* Must be invoked inside of an RCU protected region. */ 2034c7b371e3SDavid Ahern static void fib_select_default(const struct flowi4 *flp, struct fib_result *res) 20350c838ff1SDavid S. Miller { 20360c838ff1SDavid S. Miller struct fib_info *fi = NULL, *last_resort = NULL; 203756315f9eSAlexander Duyck struct hlist_head *fa_head = res->fa_head; 20380c838ff1SDavid S. Miller struct fib_table *tb = res->table; 203918a912e9SJulian Anastasov u8 slen = 32 - res->prefixlen; 20400c838ff1SDavid S. Miller int order = -1, last_idx = -1; 20412392debcSJulian Anastasov struct fib_alias *fa, *fa1 = NULL; 20422392debcSJulian Anastasov u32 last_prio = res->fi->fib_priority; 2043*32ccf110SGuillaume Nault dscp_t last_dscp = 0; 20440c838ff1SDavid S. Miller 204556315f9eSAlexander Duyck hlist_for_each_entry_rcu(fa, fa_head, fa_list) { 20460c838ff1SDavid S. Miller struct fib_info *next_fi = fa->fa_info; 20477c74b0beSDavid Ahern struct fib_nh_common *nhc; 20480c838ff1SDavid S. Miller 204918a912e9SJulian Anastasov if (fa->fa_slen != slen) 205018a912e9SJulian Anastasov continue; 2051*32ccf110SGuillaume Nault if (fa->fa_dscp && 2052*32ccf110SGuillaume Nault fa->fa_dscp != inet_dsfield_to_dscp(flp->flowi4_tos)) 20532392debcSJulian Anastasov continue; 205418a912e9SJulian Anastasov if (fa->tb_id != tb->tb_id) 205518a912e9SJulian Anastasov continue; 20562392debcSJulian Anastasov if (next_fi->fib_priority > last_prio && 2057*32ccf110SGuillaume Nault fa->fa_dscp == last_dscp) { 2058*32ccf110SGuillaume Nault if (last_dscp) 20592392debcSJulian Anastasov continue; 20602392debcSJulian Anastasov break; 20612392debcSJulian Anastasov } 20622392debcSJulian Anastasov if (next_fi->fib_flags & RTNH_F_DEAD) 20632392debcSJulian Anastasov continue; 2064*32ccf110SGuillaume Nault last_dscp = fa->fa_dscp; 20652392debcSJulian Anastasov last_prio = next_fi->fib_priority; 20662392debcSJulian Anastasov 206737e826c5SDavid S. Miller if (next_fi->fib_scope != res->scope || 20680c838ff1SDavid S. Miller fa->fa_type != RTN_UNICAST) 20690c838ff1SDavid S. Miller continue; 20705481d73fSDavid Ahern 20717c74b0beSDavid Ahern nhc = fib_info_nhc(next_fi, 0); 20727c74b0beSDavid Ahern if (!nhc->nhc_gw_family || nhc->nhc_scope != RT_SCOPE_LINK) 20730c838ff1SDavid S. Miller continue; 20740c838ff1SDavid S. Miller 20750c838ff1SDavid S. Miller fib_alias_accessed(fa); 20760c838ff1SDavid S. Miller 207751456b29SIan Morris if (!fi) { 20780c838ff1SDavid S. Miller if (next_fi != res->fi) 20790c838ff1SDavid S. Miller break; 20802392debcSJulian Anastasov fa1 = fa; 20810c838ff1SDavid S. Miller } else if (!fib_detect_death(fi, order, &last_resort, 20822392debcSJulian Anastasov &last_idx, fa1->fa_default)) { 20830c838ff1SDavid S. Miller fib_result_assign(res, fi); 20842392debcSJulian Anastasov fa1->fa_default = order; 20850c838ff1SDavid S. Miller goto out; 20860c838ff1SDavid S. Miller } 20870c838ff1SDavid S. Miller fi = next_fi; 20880c838ff1SDavid S. Miller order++; 20890c838ff1SDavid S. Miller } 20900c838ff1SDavid S. Miller 209151456b29SIan Morris if (order <= 0 || !fi) { 20922392debcSJulian Anastasov if (fa1) 20932392debcSJulian Anastasov fa1->fa_default = -1; 20940c838ff1SDavid S. Miller goto out; 20950c838ff1SDavid S. Miller } 20960c838ff1SDavid S. Miller 20970c838ff1SDavid S. Miller if (!fib_detect_death(fi, order, &last_resort, &last_idx, 20982392debcSJulian Anastasov fa1->fa_default)) { 20990c838ff1SDavid S. Miller fib_result_assign(res, fi); 21002392debcSJulian Anastasov fa1->fa_default = order; 21010c838ff1SDavid S. Miller goto out; 21020c838ff1SDavid S. Miller } 21030c838ff1SDavid S. Miller 21040c838ff1SDavid S. Miller if (last_idx >= 0) 21050c838ff1SDavid S. Miller fib_result_assign(res, last_resort); 21062392debcSJulian Anastasov fa1->fa_default = last_idx; 21070c838ff1SDavid S. Miller out: 210831d40937SEric Dumazet return; 21090c838ff1SDavid S. Miller } 21100c838ff1SDavid S. Miller 21111da177e4SLinus Torvalds /* 21126a31d2a9SEric Dumazet * Dead device goes up. We wake up dead nexthops. 21136a31d2a9SEric Dumazet * It takes sense only on multipath routes. 21144c7e8084SDavid Ahern * 21154c7e8084SDavid Ahern * only used when fib_nh is built into fib_info 21161da177e4SLinus Torvalds */ 2117ecc5663cSDavid Ahern int fib_sync_up(struct net_device *dev, unsigned char nh_flags) 21181da177e4SLinus Torvalds { 21191da177e4SLinus Torvalds struct fib_info *prev_fi; 21201da177e4SLinus Torvalds struct hlist_head *head; 21211da177e4SLinus Torvalds struct fib_nh *nh; 21221da177e4SLinus Torvalds int ret; 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds if (!(dev->flags & IFF_UP)) 21251da177e4SLinus Torvalds return 0; 21261da177e4SLinus Torvalds 2127c9b3292eSJulian Anastasov if (nh_flags & RTNH_F_DEAD) { 2128c9b3292eSJulian Anastasov unsigned int flags = dev_get_flags(dev); 2129c9b3292eSJulian Anastasov 2130c9b3292eSJulian Anastasov if (flags & (IFF_RUNNING | IFF_LOWER_UP)) 2131c9b3292eSJulian Anastasov nh_flags |= RTNH_F_LINKDOWN; 2132c9b3292eSJulian Anastasov } 2133c9b3292eSJulian Anastasov 21341da177e4SLinus Torvalds prev_fi = NULL; 2135d07418afSEric Dumazet head = fib_info_devhash_bucket(dev); 21361da177e4SLinus Torvalds ret = 0; 21371da177e4SLinus Torvalds 2138b67bfe0dSSasha Levin hlist_for_each_entry(nh, head, nh_hash) { 21391da177e4SLinus Torvalds struct fib_info *fi = nh->nh_parent; 21401da177e4SLinus Torvalds int alive; 21411da177e4SLinus Torvalds 21421da177e4SLinus Torvalds BUG_ON(!fi->fib_nhs); 2143b75ed8b1SDavid Ahern if (nh->fib_nh_dev != dev || fi == prev_fi) 21441da177e4SLinus Torvalds continue; 21451da177e4SLinus Torvalds 21461da177e4SLinus Torvalds prev_fi = fi; 21471da177e4SLinus Torvalds alive = 0; 21481da177e4SLinus Torvalds change_nexthops(fi) { 2149b75ed8b1SDavid Ahern if (!(nexthop_nh->fib_nh_flags & nh_flags)) { 21501da177e4SLinus Torvalds alive++; 21511da177e4SLinus Torvalds continue; 21521da177e4SLinus Torvalds } 2153b75ed8b1SDavid Ahern if (!nexthop_nh->fib_nh_dev || 2154b75ed8b1SDavid Ahern !(nexthop_nh->fib_nh_dev->flags & IFF_UP)) 21551da177e4SLinus Torvalds continue; 2156b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_dev != dev || 215771fceff0SDavid S. Miller !__in_dev_get_rtnl(dev)) 21581da177e4SLinus Torvalds continue; 21591da177e4SLinus Torvalds alive++; 2160b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags &= ~nh_flags; 2161982acb97SIdo Schimmel call_fib_nh_notifiers(nexthop_nh, FIB_EVENT_NH_ADD); 21621da177e4SLinus Torvalds } endfor_nexthops(fi) 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds if (alive > 0) { 21658a3d0316SAndy Gospodarek fi->fib_flags &= ~nh_flags; 21661da177e4SLinus Torvalds ret++; 21671da177e4SLinus Torvalds } 21680e884c78SPeter Nørlund 21690e884c78SPeter Nørlund fib_rebalance(fi); 21701da177e4SLinus Torvalds } 21711da177e4SLinus Torvalds 21721da177e4SLinus Torvalds return ret; 21731da177e4SLinus Torvalds } 21741da177e4SLinus Torvalds 21758a3d0316SAndy Gospodarek #ifdef CONFIG_IP_ROUTE_MULTIPATH 2176a6db4494SDavid Ahern static bool fib_good_nh(const struct fib_nh *nh) 2177a6db4494SDavid Ahern { 2178a6db4494SDavid Ahern int state = NUD_REACHABLE; 2179a6db4494SDavid Ahern 2180b75ed8b1SDavid Ahern if (nh->fib_nh_scope == RT_SCOPE_LINK) { 2181a6db4494SDavid Ahern struct neighbour *n; 2182a6db4494SDavid Ahern 2183a6db4494SDavid Ahern rcu_read_lock_bh(); 2184a6db4494SDavid Ahern 21851a38c43dSDavid Ahern if (likely(nh->fib_nh_gw_family == AF_INET)) 2186b75ed8b1SDavid Ahern n = __ipv4_neigh_lookup_noref(nh->fib_nh_dev, 2187b75ed8b1SDavid Ahern (__force u32)nh->fib_nh_gw4); 21881a38c43dSDavid Ahern else if (nh->fib_nh_gw_family == AF_INET6) 21891a38c43dSDavid Ahern n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev, 21901a38c43dSDavid Ahern &nh->fib_nh_gw6); 21911a38c43dSDavid Ahern else 21921a38c43dSDavid Ahern n = NULL; 2193a6db4494SDavid Ahern if (n) 2194a6db4494SDavid Ahern state = n->nud_state; 2195a6db4494SDavid Ahern 2196a6db4494SDavid Ahern rcu_read_unlock_bh(); 2197a6db4494SDavid Ahern } 2198a6db4494SDavid Ahern 2199a6db4494SDavid Ahern return !!(state & NUD_VALID); 2200a6db4494SDavid Ahern } 22018a3d0316SAndy Gospodarek 22020e884c78SPeter Nørlund void fib_select_multipath(struct fib_result *res, int hash) 22031da177e4SLinus Torvalds { 22041da177e4SLinus Torvalds struct fib_info *fi = res->fi; 2205a6db4494SDavid Ahern struct net *net = fi->fib_net; 2206a6db4494SDavid Ahern bool first = false; 22071da177e4SLinus Torvalds 22084c7e8084SDavid Ahern if (unlikely(res->fi->nh)) { 22094c7e8084SDavid Ahern nexthop_path_fib_result(res, hash); 22104c7e8084SDavid Ahern return; 22114c7e8084SDavid Ahern } 22124c7e8084SDavid Ahern 2213eba618abSDavid Ahern change_nexthops(fi) { 22146174a30dSXin Long if (net->ipv4.sysctl_fib_multipath_use_neigh) { 2215eba618abSDavid Ahern if (!fib_good_nh(nexthop_nh)) 22160eeb075fSAndy Gospodarek continue; 2217a6db4494SDavid Ahern if (!first) { 2218a6db4494SDavid Ahern res->nh_sel = nhsel; 2219eba618abSDavid Ahern res->nhc = &nexthop_nh->nh_common; 2220a6db4494SDavid Ahern first = true; 2221a6db4494SDavid Ahern } 22226174a30dSXin Long } 22236174a30dSXin Long 2224eba618abSDavid Ahern if (hash > atomic_read(&nexthop_nh->fib_nh_upper_bound)) 22256174a30dSXin Long continue; 22266174a30dSXin Long 22276174a30dSXin Long res->nh_sel = nhsel; 2228eba618abSDavid Ahern res->nhc = &nexthop_nh->nh_common; 22296174a30dSXin Long return; 22301da177e4SLinus Torvalds } endfor_nexthops(fi); 22311da177e4SLinus Torvalds } 22321da177e4SLinus Torvalds #endif 22333ce58d84SDavid Ahern 22343ce58d84SDavid Ahern void fib_select_path(struct net *net, struct fib_result *res, 2235bf4e0a3dSNikolay Aleksandrov struct flowi4 *fl4, const struct sk_buff *skb) 22363ce58d84SDavid Ahern { 22370d876f2cSDavid Ahern if (fl4->flowi4_oif && !(fl4->flowi4_flags & FLOWI_FLAG_SKIP_NH_OIF)) 22380d876f2cSDavid Ahern goto check_saddr; 22397a18c5b9SDavid Ahern 22403ce58d84SDavid Ahern #ifdef CONFIG_IP_ROUTE_MULTIPATH 22415481d73fSDavid Ahern if (fib_info_num_path(res->fi) > 1) { 22427efc0b6bSDavid Ahern int h = fib_multipath_hash(net, fl4, skb, NULL); 22439920e48bSPaolo Abeni 2244bf4e0a3dSNikolay Aleksandrov fib_select_multipath(res, h); 22453ce58d84SDavid Ahern } 22463ce58d84SDavid Ahern else 22473ce58d84SDavid Ahern #endif 22483ce58d84SDavid Ahern if (!res->prefixlen && 22493ce58d84SDavid Ahern res->table->tb_num_default > 1 && 22500d876f2cSDavid Ahern res->type == RTN_UNICAST) 22513ce58d84SDavid Ahern fib_select_default(fl4, res); 22523ce58d84SDavid Ahern 22530d876f2cSDavid Ahern check_saddr: 22543ce58d84SDavid Ahern if (!fl4->saddr) 2255eba618abSDavid Ahern fl4->saddr = fib_result_prefsrc(net, res); 22563ce58d84SDavid Ahern } 2257