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> 321da177e4SLinus Torvalds 3314c85021SArnaldo Carvalho de Melo #include <net/arp.h> 341da177e4SLinus Torvalds #include <net/ip.h> 351da177e4SLinus Torvalds #include <net/protocol.h> 361da177e4SLinus Torvalds #include <net/route.h> 371da177e4SLinus Torvalds #include <net/tcp.h> 381da177e4SLinus Torvalds #include <net/sock.h> 391da177e4SLinus Torvalds #include <net/ip_fib.h> 40717a8f5bSDavid Ahern #include <net/ip6_fib.h> 415481d73fSDavid Ahern #include <net/nexthop.h> 42f21c7bc5SThomas Graf #include <net/netlink.h> 433c618c1dSDavid Ahern #include <net/rtnh.h> 44571e7226SRoopa Prabhu #include <net/lwtunnel.h> 4504b1d4e5SIdo Schimmel #include <net/fib_notifier.h> 46c0a72077SDavid Ahern #include <net/addrconf.h> 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds #include "fib_lookup.h" 491da177e4SLinus Torvalds 50832b4c5eSStephen Hemminger static DEFINE_SPINLOCK(fib_info_lock); 511da177e4SLinus Torvalds static struct hlist_head *fib_info_hash; 521da177e4SLinus Torvalds static struct hlist_head *fib_info_laddrhash; 53123b9731SDavid S. Miller static unsigned int fib_info_hash_size; 541da177e4SLinus Torvalds static unsigned int fib_info_cnt; 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds #define DEVINDEX_HASHBITS 8 571da177e4SLinus Torvalds #define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS) 581da177e4SLinus Torvalds static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE]; 591da177e4SLinus Torvalds 60dcb1ecb5SDavid Ahern /* for_nexthops and change_nexthops only used when nexthop object 61dcb1ecb5SDavid Ahern * is not set in a fib_info. The logic within can reference fib_nh. 62dcb1ecb5SDavid Ahern */ 631da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 641da177e4SLinus Torvalds 656a31d2a9SEric Dumazet #define for_nexthops(fi) { \ 666a31d2a9SEric Dumazet int nhsel; const struct fib_nh *nh; \ 676a31d2a9SEric Dumazet for (nhsel = 0, nh = (fi)->fib_nh; \ 685481d73fSDavid Ahern nhsel < fib_info_num_path((fi)); \ 696a31d2a9SEric Dumazet nh++, nhsel++) 701da177e4SLinus Torvalds 716a31d2a9SEric Dumazet #define change_nexthops(fi) { \ 726a31d2a9SEric Dumazet int nhsel; struct fib_nh *nexthop_nh; \ 736a31d2a9SEric Dumazet for (nhsel = 0, nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \ 745481d73fSDavid Ahern nhsel < fib_info_num_path((fi)); \ 756a31d2a9SEric Dumazet nexthop_nh++, nhsel++) 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds #else /* CONFIG_IP_ROUTE_MULTIPATH */ 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds /* Hope, that gcc will optimize it to get rid of dummy loop */ 801da177e4SLinus Torvalds 816a31d2a9SEric Dumazet #define for_nexthops(fi) { \ 826a31d2a9SEric Dumazet int nhsel; const struct fib_nh *nh = (fi)->fib_nh; \ 831da177e4SLinus Torvalds for (nhsel = 0; nhsel < 1; nhsel++) 841da177e4SLinus Torvalds 856a31d2a9SEric Dumazet #define change_nexthops(fi) { \ 866a31d2a9SEric Dumazet int nhsel; \ 876a31d2a9SEric Dumazet struct fib_nh *nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \ 881da177e4SLinus Torvalds for (nhsel = 0; nhsel < 1; nhsel++) 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds #endif /* CONFIG_IP_ROUTE_MULTIPATH */ 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds #define endfor_nexthops(fi) } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds 953be0686bSDavid S. Miller const struct fib_prop fib_props[RTN_MAX + 1] = { 966a31d2a9SEric Dumazet [RTN_UNSPEC] = { 971da177e4SLinus Torvalds .error = 0, 981da177e4SLinus Torvalds .scope = RT_SCOPE_NOWHERE, 996a31d2a9SEric Dumazet }, 1006a31d2a9SEric Dumazet [RTN_UNICAST] = { 1011da177e4SLinus Torvalds .error = 0, 1021da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1036a31d2a9SEric Dumazet }, 1046a31d2a9SEric Dumazet [RTN_LOCAL] = { 1051da177e4SLinus Torvalds .error = 0, 1061da177e4SLinus Torvalds .scope = RT_SCOPE_HOST, 1076a31d2a9SEric Dumazet }, 1086a31d2a9SEric Dumazet [RTN_BROADCAST] = { 1091da177e4SLinus Torvalds .error = 0, 1101da177e4SLinus Torvalds .scope = RT_SCOPE_LINK, 1116a31d2a9SEric Dumazet }, 1126a31d2a9SEric Dumazet [RTN_ANYCAST] = { 1131da177e4SLinus Torvalds .error = 0, 1141da177e4SLinus Torvalds .scope = RT_SCOPE_LINK, 1156a31d2a9SEric Dumazet }, 1166a31d2a9SEric Dumazet [RTN_MULTICAST] = { 1171da177e4SLinus Torvalds .error = 0, 1181da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1196a31d2a9SEric Dumazet }, 1206a31d2a9SEric Dumazet [RTN_BLACKHOLE] = { 1211da177e4SLinus Torvalds .error = -EINVAL, 1221da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1236a31d2a9SEric Dumazet }, 1246a31d2a9SEric Dumazet [RTN_UNREACHABLE] = { 1251da177e4SLinus Torvalds .error = -EHOSTUNREACH, 1261da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1276a31d2a9SEric Dumazet }, 1286a31d2a9SEric Dumazet [RTN_PROHIBIT] = { 1291da177e4SLinus Torvalds .error = -EACCES, 1301da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1316a31d2a9SEric Dumazet }, 1326a31d2a9SEric Dumazet [RTN_THROW] = { 1331da177e4SLinus Torvalds .error = -EAGAIN, 1341da177e4SLinus Torvalds .scope = RT_SCOPE_UNIVERSE, 1356a31d2a9SEric Dumazet }, 1366a31d2a9SEric Dumazet [RTN_NAT] = { 1371da177e4SLinus Torvalds .error = -EINVAL, 1381da177e4SLinus Torvalds .scope = RT_SCOPE_NOWHERE, 1396a31d2a9SEric Dumazet }, 1406a31d2a9SEric Dumazet [RTN_XRESOLVE] = { 1411da177e4SLinus Torvalds .error = -EINVAL, 1421da177e4SLinus Torvalds .scope = RT_SCOPE_NOWHERE, 1436a31d2a9SEric Dumazet }, 1441da177e4SLinus Torvalds }; 1451da177e4SLinus Torvalds 146c5038a83SDavid S. Miller static void rt_fibinfo_free(struct rtable __rcu **rtp) 14754764bb6SEric Dumazet { 14854764bb6SEric Dumazet struct rtable *rt = rcu_dereference_protected(*rtp, 1); 14954764bb6SEric Dumazet 15054764bb6SEric Dumazet if (!rt) 15154764bb6SEric Dumazet return; 15254764bb6SEric Dumazet 15354764bb6SEric Dumazet /* Not even needed : RCU_INIT_POINTER(*rtp, NULL); 15454764bb6SEric Dumazet * because we waited an RCU grace period before calling 15554764bb6SEric Dumazet * free_fib_info_rcu() 15654764bb6SEric Dumazet */ 15754764bb6SEric Dumazet 15895c47f9cSWei Wang dst_dev_put(&rt->dst); 159b838d5e1SWei Wang dst_release_immediate(&rt->dst); 16054764bb6SEric Dumazet } 16154764bb6SEric Dumazet 162a5995e71SDavid Ahern static void free_nh_exceptions(struct fib_nh_common *nhc) 163c5038a83SDavid S. Miller { 164caa41527SEric Dumazet struct fnhe_hash_bucket *hash; 165c5038a83SDavid S. Miller int i; 166c5038a83SDavid S. Miller 167a5995e71SDavid Ahern hash = rcu_dereference_protected(nhc->nhc_exceptions, 1); 168caa41527SEric Dumazet if (!hash) 169caa41527SEric Dumazet return; 170c5038a83SDavid S. Miller for (i = 0; i < FNHE_HASH_SIZE; i++) { 171c5038a83SDavid S. Miller struct fib_nh_exception *fnhe; 172c5038a83SDavid S. Miller 173c5038a83SDavid S. Miller fnhe = rcu_dereference_protected(hash[i].chain, 1); 174c5038a83SDavid S. Miller while (fnhe) { 175c5038a83SDavid S. Miller struct fib_nh_exception *next; 176c5038a83SDavid S. Miller 177c5038a83SDavid S. Miller next = rcu_dereference_protected(fnhe->fnhe_next, 1); 178c5038a83SDavid S. Miller 1792ffae99dSTimo Teräs rt_fibinfo_free(&fnhe->fnhe_rth_input); 1802ffae99dSTimo Teräs rt_fibinfo_free(&fnhe->fnhe_rth_output); 181c5038a83SDavid S. Miller 182c5038a83SDavid S. Miller kfree(fnhe); 183c5038a83SDavid S. Miller 184c5038a83SDavid S. Miller fnhe = next; 185c5038a83SDavid S. Miller } 186c5038a83SDavid S. Miller } 187c5038a83SDavid S. Miller kfree(hash); 188c5038a83SDavid S. Miller } 189c5038a83SDavid S. Miller 190c5038a83SDavid S. Miller static void rt_fibinfo_free_cpus(struct rtable __rcu * __percpu *rtp) 191d26b3a7cSEric Dumazet { 192d26b3a7cSEric Dumazet int cpu; 193d26b3a7cSEric Dumazet 194d26b3a7cSEric Dumazet if (!rtp) 195d26b3a7cSEric Dumazet return; 196d26b3a7cSEric Dumazet 197d26b3a7cSEric Dumazet for_each_possible_cpu(cpu) { 198d26b3a7cSEric Dumazet struct rtable *rt; 199d26b3a7cSEric Dumazet 200d26b3a7cSEric Dumazet rt = rcu_dereference_protected(*per_cpu_ptr(rtp, cpu), 1); 2010830106cSWei Wang if (rt) { 20295c47f9cSWei Wang dst_dev_put(&rt->dst); 203b838d5e1SWei Wang dst_release_immediate(&rt->dst); 204d26b3a7cSEric Dumazet } 2050830106cSWei Wang } 206d26b3a7cSEric Dumazet free_percpu(rtp); 207d26b3a7cSEric Dumazet } 208d26b3a7cSEric Dumazet 209979e276eSDavid Ahern void fib_nh_common_release(struct fib_nh_common *nhc) 210979e276eSDavid Ahern { 211979e276eSDavid Ahern dev_put(nhc->nhc_dev); 212979e276eSDavid Ahern lwtstate_put(nhc->nhc_lwtstate); 2130f457a36SDavid Ahern rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output); 2140f457a36SDavid Ahern rt_fibinfo_free(&nhc->nhc_rth_input); 215a5995e71SDavid Ahern free_nh_exceptions(nhc); 216979e276eSDavid Ahern } 217979e276eSDavid Ahern EXPORT_SYMBOL_GPL(fib_nh_common_release); 218979e276eSDavid Ahern 219faa041a4SDavid Ahern void fib_nh_release(struct net *net, struct fib_nh *fib_nh) 220faa041a4SDavid Ahern { 221faa041a4SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 222faa041a4SDavid Ahern if (fib_nh->nh_tclassid) 223213f5f8fSEric Dumazet atomic_dec(&net->ipv4.fib_num_tclassid_users); 224faa041a4SDavid Ahern #endif 225979e276eSDavid Ahern fib_nh_common_release(&fib_nh->nh_common); 226faa041a4SDavid Ahern } 227faa041a4SDavid Ahern 2281da177e4SLinus Torvalds /* Release a nexthop info record */ 22919c1ea14SYan, Zheng static void free_fib_info_rcu(struct rcu_head *head) 23019c1ea14SYan, Zheng { 23119c1ea14SYan, Zheng struct fib_info *fi = container_of(head, struct fib_info, rcu); 23219c1ea14SYan, Zheng 2334c7e8084SDavid Ahern if (fi->nh) { 2344c7e8084SDavid Ahern nexthop_put(fi->nh); 2354c7e8084SDavid Ahern } else { 236e49cc0daSYanmin Zhang change_nexthops(fi) { 237faa041a4SDavid Ahern fib_nh_release(fi->fib_net, nexthop_nh); 238e49cc0daSYanmin Zhang } endfor_nexthops(fi); 2394c7e8084SDavid Ahern } 240e49cc0daSYanmin Zhang 241cc5f0eb2SDavid Ahern ip_fib_metrics_put(fi->fib_metrics); 242cc5f0eb2SDavid Ahern 24319c1ea14SYan, Zheng kfree(fi); 24419c1ea14SYan, Zheng } 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds void free_fib_info(struct fib_info *fi) 2471da177e4SLinus Torvalds { 2481da177e4SLinus Torvalds if (fi->fib_dead == 0) { 249058bd4d2SJoe Perches pr_warn("Freeing alive fib_info %p\n", fi); 2501da177e4SLinus Torvalds return; 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds fib_info_cnt--; 253faa041a4SDavid Ahern 25419c1ea14SYan, Zheng call_rcu(&fi->rcu, free_fib_info_rcu); 2551da177e4SLinus Torvalds } 256b423cb10SIdo Schimmel EXPORT_SYMBOL_GPL(free_fib_info); 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds void fib_release_info(struct fib_info *fi) 2591da177e4SLinus Torvalds { 260832b4c5eSStephen Hemminger spin_lock_bh(&fib_info_lock); 26179976892SYajun Deng if (fi && refcount_dec_and_test(&fi->fib_treeref)) { 2621da177e4SLinus Torvalds hlist_del(&fi->fib_hash); 2631da177e4SLinus Torvalds if (fi->fib_prefsrc) 2641da177e4SLinus Torvalds hlist_del(&fi->fib_lhash); 2654c7e8084SDavid Ahern if (fi->nh) { 2664c7e8084SDavid Ahern list_del(&fi->nh_list); 2674c7e8084SDavid Ahern } else { 2681da177e4SLinus Torvalds change_nexthops(fi) { 269b75ed8b1SDavid Ahern if (!nexthop_nh->fib_nh_dev) 2701da177e4SLinus Torvalds continue; 27171fceff0SDavid S. Miller hlist_del(&nexthop_nh->nh_hash); 2721da177e4SLinus Torvalds } endfor_nexthops(fi) 2734c7e8084SDavid Ahern } 2741da177e4SLinus Torvalds fi->fib_dead = 1; 2751da177e4SLinus Torvalds fib_info_put(fi); 2761da177e4SLinus Torvalds } 277832b4c5eSStephen Hemminger spin_unlock_bh(&fib_info_lock); 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 2805481d73fSDavid Ahern static inline int nh_comp(struct fib_info *fi, struct fib_info *ofi) 2811da177e4SLinus Torvalds { 2825481d73fSDavid Ahern const struct fib_nh *onh; 2831da177e4SLinus Torvalds 2844c7e8084SDavid Ahern if (fi->nh || ofi->nh) 2854c7e8084SDavid Ahern return nexthop_cmp(fi->nh, ofi->nh) ? 0 : -1; 2864c7e8084SDavid Ahern 2874c7e8084SDavid Ahern if (ofi->fib_nhs == 0) 2884c7e8084SDavid Ahern return 0; 2894c7e8084SDavid Ahern 2901da177e4SLinus Torvalds for_nexthops(fi) { 2915481d73fSDavid Ahern onh = fib_info_nh(ofi, nhsel); 2925481d73fSDavid Ahern 293b75ed8b1SDavid Ahern if (nh->fib_nh_oif != onh->fib_nh_oif || 294a4ea5d43SDavid Ahern nh->fib_nh_gw_family != onh->fib_nh_gw_family || 295b75ed8b1SDavid Ahern nh->fib_nh_scope != onh->fib_nh_scope || 2961da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 297b75ed8b1SDavid Ahern nh->fib_nh_weight != onh->fib_nh_weight || 2981da177e4SLinus Torvalds #endif 299c7066f70SPatrick McHardy #ifdef CONFIG_IP_ROUTE_CLASSID 3001da177e4SLinus Torvalds nh->nh_tclassid != onh->nh_tclassid || 3011da177e4SLinus Torvalds #endif 302b75ed8b1SDavid Ahern lwtunnel_cmp_encap(nh->fib_nh_lws, onh->fib_nh_lws) || 303b75ed8b1SDavid Ahern ((nh->fib_nh_flags ^ onh->fib_nh_flags) & ~RTNH_COMPARE_MASK)) 3041da177e4SLinus Torvalds return -1; 305a4ea5d43SDavid Ahern 306a4ea5d43SDavid Ahern if (nh->fib_nh_gw_family == AF_INET && 307a4ea5d43SDavid Ahern nh->fib_nh_gw4 != onh->fib_nh_gw4) 308a4ea5d43SDavid Ahern return -1; 309a4ea5d43SDavid Ahern 310a4ea5d43SDavid Ahern if (nh->fib_nh_gw_family == AF_INET6 && 311a4ea5d43SDavid Ahern ipv6_addr_cmp(&nh->fib_nh_gw6, &onh->fib_nh_gw6)) 312a4ea5d43SDavid Ahern return -1; 3131da177e4SLinus Torvalds } endfor_nexthops(fi); 3141da177e4SLinus Torvalds return 0; 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds 31788ebc72fSDavid S. Miller static inline unsigned int fib_devindex_hashfn(unsigned int val) 31888ebc72fSDavid S. Miller { 31988ebc72fSDavid S. Miller unsigned int mask = DEVINDEX_HASHSIZE - 1; 32088ebc72fSDavid S. Miller 32188ebc72fSDavid S. Miller return (val ^ 32288ebc72fSDavid S. Miller (val >> DEVINDEX_HASHBITS) ^ 32388ebc72fSDavid S. Miller (val >> (DEVINDEX_HASHBITS * 2))) & mask; 32488ebc72fSDavid S. Miller } 32588ebc72fSDavid S. Miller 3266c48ea5fSDavid Ahern static unsigned int fib_info_hashfn_1(int init_val, u8 protocol, u8 scope, 3276c48ea5fSDavid Ahern u32 prefsrc, u32 priority) 3286c48ea5fSDavid Ahern { 3296c48ea5fSDavid Ahern unsigned int val = init_val; 3306c48ea5fSDavid Ahern 3316c48ea5fSDavid Ahern val ^= (protocol << 8) | scope; 3326c48ea5fSDavid Ahern val ^= prefsrc; 3336c48ea5fSDavid Ahern val ^= priority; 3346c48ea5fSDavid Ahern 3356c48ea5fSDavid Ahern return val; 3366c48ea5fSDavid Ahern } 3376c48ea5fSDavid Ahern 3386c48ea5fSDavid Ahern static unsigned int fib_info_hashfn_result(unsigned int val) 3391da177e4SLinus Torvalds { 340123b9731SDavid S. Miller unsigned int mask = (fib_info_hash_size - 1); 3411da177e4SLinus Torvalds 3426c48ea5fSDavid Ahern return (val ^ (val >> 7) ^ (val >> 12)) & mask; 3436c48ea5fSDavid Ahern } 3446c48ea5fSDavid Ahern 3456c48ea5fSDavid Ahern static inline unsigned int fib_info_hashfn(struct fib_info *fi) 3466c48ea5fSDavid Ahern { 3476c48ea5fSDavid Ahern unsigned int val; 3486c48ea5fSDavid Ahern 3496c48ea5fSDavid Ahern val = fib_info_hashfn_1(fi->fib_nhs, fi->fib_protocol, 3506c48ea5fSDavid Ahern fi->fib_scope, (__force u32)fi->fib_prefsrc, 3516c48ea5fSDavid Ahern fi->fib_priority); 3524c7e8084SDavid Ahern 3534c7e8084SDavid Ahern if (fi->nh) { 3544c7e8084SDavid Ahern val ^= fib_devindex_hashfn(fi->nh->id); 3554c7e8084SDavid Ahern } else { 35688ebc72fSDavid S. Miller for_nexthops(fi) { 357b75ed8b1SDavid Ahern val ^= fib_devindex_hashfn(nh->fib_nh_oif); 35888ebc72fSDavid S. Miller } endfor_nexthops(fi) 3594c7e8084SDavid Ahern } 3601da177e4SLinus Torvalds 3616c48ea5fSDavid Ahern return fib_info_hashfn_result(val); 3626c48ea5fSDavid Ahern } 3636c48ea5fSDavid Ahern 3646c48ea5fSDavid Ahern /* no metrics, only nexthop id */ 3656c48ea5fSDavid Ahern static struct fib_info *fib_find_info_nh(struct net *net, 3666c48ea5fSDavid Ahern const struct fib_config *cfg) 3676c48ea5fSDavid Ahern { 3686c48ea5fSDavid Ahern struct hlist_head *head; 3696c48ea5fSDavid Ahern struct fib_info *fi; 3706c48ea5fSDavid Ahern unsigned int hash; 3716c48ea5fSDavid Ahern 3726c48ea5fSDavid Ahern hash = fib_info_hashfn_1(fib_devindex_hashfn(cfg->fc_nh_id), 3736c48ea5fSDavid Ahern cfg->fc_protocol, cfg->fc_scope, 3746c48ea5fSDavid Ahern (__force u32)cfg->fc_prefsrc, 3756c48ea5fSDavid Ahern cfg->fc_priority); 3766c48ea5fSDavid Ahern hash = fib_info_hashfn_result(hash); 3776c48ea5fSDavid Ahern head = &fib_info_hash[hash]; 3786c48ea5fSDavid Ahern 3796c48ea5fSDavid Ahern hlist_for_each_entry(fi, head, fib_hash) { 3806c48ea5fSDavid Ahern if (!net_eq(fi->fib_net, net)) 3816c48ea5fSDavid Ahern continue; 3826c48ea5fSDavid Ahern if (!fi->nh || fi->nh->id != cfg->fc_nh_id) 3836c48ea5fSDavid Ahern continue; 3846c48ea5fSDavid Ahern if (cfg->fc_protocol == fi->fib_protocol && 3856c48ea5fSDavid Ahern cfg->fc_scope == fi->fib_scope && 3866c48ea5fSDavid Ahern cfg->fc_prefsrc == fi->fib_prefsrc && 3876c48ea5fSDavid Ahern cfg->fc_priority == fi->fib_priority && 3886c48ea5fSDavid Ahern cfg->fc_type == fi->fib_type && 3896c48ea5fSDavid Ahern cfg->fc_table == fi->fib_tb_id && 3906c48ea5fSDavid Ahern !((cfg->fc_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK)) 3916c48ea5fSDavid Ahern return fi; 3926c48ea5fSDavid Ahern } 3936c48ea5fSDavid Ahern 3946c48ea5fSDavid Ahern return NULL; 3951da177e4SLinus Torvalds } 3961da177e4SLinus Torvalds 3975481d73fSDavid Ahern static struct fib_info *fib_find_info(struct fib_info *nfi) 3981da177e4SLinus Torvalds { 3991da177e4SLinus Torvalds struct hlist_head *head; 4001da177e4SLinus Torvalds struct fib_info *fi; 4011da177e4SLinus Torvalds unsigned int hash; 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds hash = fib_info_hashfn(nfi); 4041da177e4SLinus Torvalds head = &fib_info_hash[hash]; 4051da177e4SLinus Torvalds 406b67bfe0dSSasha Levin hlist_for_each_entry(fi, head, fib_hash) { 40709ad9bc7SOctavian Purdila if (!net_eq(fi->fib_net, nfi->fib_net)) 4084814bdbdSDenis V. Lunev continue; 4091da177e4SLinus Torvalds if (fi->fib_nhs != nfi->fib_nhs) 4101da177e4SLinus Torvalds continue; 4111da177e4SLinus Torvalds if (nfi->fib_protocol == fi->fib_protocol && 41237e826c5SDavid S. Miller nfi->fib_scope == fi->fib_scope && 4131da177e4SLinus Torvalds nfi->fib_prefsrc == fi->fib_prefsrc && 4141da177e4SLinus Torvalds nfi->fib_priority == fi->fib_priority && 415f4ef85bbSEric Dumazet nfi->fib_type == fi->fib_type && 4161da177e4SLinus Torvalds memcmp(nfi->fib_metrics, fi->fib_metrics, 417fcd13f42SEric Dumazet sizeof(u32) * RTAX_MAX) == 0 && 4188a3d0316SAndy Gospodarek !((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) && 4194c7e8084SDavid Ahern nh_comp(fi, nfi) == 0) 4201da177e4SLinus Torvalds return fi; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds return NULL; 4241da177e4SLinus Torvalds } 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds /* Check, that the gateway is already configured. 4276a31d2a9SEric Dumazet * Used only by redirect accept routine. 4281da177e4SLinus Torvalds */ 429d878e72eSAl Viro int ip_fib_check_default(__be32 gw, struct net_device *dev) 4301da177e4SLinus Torvalds { 4311da177e4SLinus Torvalds struct hlist_head *head; 4321da177e4SLinus Torvalds struct fib_nh *nh; 4331da177e4SLinus Torvalds unsigned int hash; 4341da177e4SLinus Torvalds 435832b4c5eSStephen Hemminger spin_lock(&fib_info_lock); 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds hash = fib_devindex_hashfn(dev->ifindex); 4381da177e4SLinus Torvalds head = &fib_info_devhash[hash]; 439b67bfe0dSSasha Levin hlist_for_each_entry(nh, head, nh_hash) { 440b75ed8b1SDavid Ahern if (nh->fib_nh_dev == dev && 441b75ed8b1SDavid Ahern nh->fib_nh_gw4 == gw && 442b75ed8b1SDavid Ahern !(nh->fib_nh_flags & RTNH_F_DEAD)) { 443832b4c5eSStephen Hemminger spin_unlock(&fib_info_lock); 4441da177e4SLinus Torvalds return 0; 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds } 4471da177e4SLinus Torvalds 448832b4c5eSStephen Hemminger spin_unlock(&fib_info_lock); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds return -1; 4511da177e4SLinus Torvalds } 4521da177e4SLinus Torvalds 4531e7bdec6SAmit Cohen size_t fib_nlmsg_size(struct fib_info *fi) 454339bf98fSThomas Graf { 455339bf98fSThomas Graf size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg)) 456339bf98fSThomas Graf + nla_total_size(4) /* RTA_TABLE */ 457339bf98fSThomas Graf + nla_total_size(4) /* RTA_DST */ 458339bf98fSThomas Graf + nla_total_size(4) /* RTA_PRIORITY */ 459ea697639SDaniel Borkmann + nla_total_size(4) /* RTA_PREFSRC */ 460ea697639SDaniel Borkmann + nla_total_size(TCP_CA_NAME_MAX); /* RTAX_CC_ALGO */ 4615481d73fSDavid Ahern unsigned int nhs = fib_info_num_path(fi); 462339bf98fSThomas Graf 463339bf98fSThomas Graf /* space for nested metrics */ 464339bf98fSThomas Graf payload += nla_total_size((RTAX_MAX * nla_total_size(4))); 465339bf98fSThomas Graf 4664c7e8084SDavid Ahern if (fi->nh) 4674c7e8084SDavid Ahern payload += nla_total_size(4); /* RTA_NH_ID */ 4684c7e8084SDavid Ahern 4695481d73fSDavid Ahern if (nhs) { 470571e7226SRoopa Prabhu size_t nh_encapsize = 0; 4715481d73fSDavid Ahern /* Also handles the special case nhs == 1 */ 472339bf98fSThomas Graf 473339bf98fSThomas Graf /* each nexthop is packed in an attribute */ 474339bf98fSThomas Graf size_t nhsize = nla_total_size(sizeof(struct rtnexthop)); 475dcb1ecb5SDavid Ahern unsigned int i; 476339bf98fSThomas Graf 477339bf98fSThomas Graf /* may contain flow and gateway attribute */ 478339bf98fSThomas Graf nhsize += 2 * nla_total_size(4); 479339bf98fSThomas Graf 480571e7226SRoopa Prabhu /* grab encap info */ 481dcb1ecb5SDavid Ahern for (i = 0; i < fib_info_num_path(fi); i++) { 482dcb1ecb5SDavid Ahern struct fib_nh_common *nhc = fib_info_nhc(fi, i); 483dcb1ecb5SDavid Ahern 484dcb1ecb5SDavid Ahern if (nhc->nhc_lwtstate) { 485571e7226SRoopa Prabhu /* RTA_ENCAP_TYPE */ 486571e7226SRoopa Prabhu nh_encapsize += lwtunnel_get_encap_size( 487dcb1ecb5SDavid Ahern nhc->nhc_lwtstate); 488571e7226SRoopa Prabhu /* RTA_ENCAP */ 489571e7226SRoopa Prabhu nh_encapsize += nla_total_size(2); 490571e7226SRoopa Prabhu } 491dcb1ecb5SDavid Ahern } 492571e7226SRoopa Prabhu 493339bf98fSThomas Graf /* all nexthops are packed in a nested attribute */ 4945481d73fSDavid Ahern payload += nla_total_size((nhs * nhsize) + nh_encapsize); 495571e7226SRoopa Prabhu 496339bf98fSThomas Graf } 497339bf98fSThomas Graf 498339bf98fSThomas Graf return payload; 499339bf98fSThomas Graf } 500339bf98fSThomas Graf 50181f7bf6cSAl Viro void rtmsg_fib(int event, __be32 key, struct fib_alias *fa, 5029877b253SJoe Perches int dst_len, u32 tb_id, const struct nl_info *info, 503b8f55831SMilan Kocian unsigned int nlm_flags) 5041da177e4SLinus Torvalds { 5051e301fd0SIdo Schimmel struct fib_rt_info fri; 5061da177e4SLinus Torvalds struct sk_buff *skb; 5074e902c57SThomas Graf u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0; 508f21c7bc5SThomas Graf int err = -ENOBUFS; 5091da177e4SLinus Torvalds 510339bf98fSThomas Graf skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL); 51151456b29SIan Morris if (!skb) 512f21c7bc5SThomas Graf goto errout; 5131da177e4SLinus Torvalds 5141e301fd0SIdo Schimmel fri.fi = fa->fa_info; 5151e301fd0SIdo Schimmel fri.tb_id = tb_id; 5161e301fd0SIdo Schimmel fri.dst = key; 5171e301fd0SIdo Schimmel fri.dst_len = dst_len; 5181e301fd0SIdo Schimmel fri.tos = fa->fa_tos; 5191e301fd0SIdo Schimmel fri.type = fa->fa_type; 52090b93f1bSIdo Schimmel fri.offload = fa->offload; 52190b93f1bSIdo Schimmel fri.trap = fa->trap; 52236c5100eSAmit Cohen fri.offload_failed = fa->offload_failed; 5231e301fd0SIdo Schimmel err = fib_dump_info(skb, info->portid, seq, event, &fri, nlm_flags); 52426932566SPatrick McHardy if (err < 0) { 52526932566SPatrick McHardy /* -EMSGSIZE implies BUG in fib_nlmsg_size() */ 52626932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 52726932566SPatrick McHardy kfree_skb(skb); 52826932566SPatrick McHardy goto errout; 52926932566SPatrick McHardy } 53015e47304SEric W. Biederman rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV4_ROUTE, 5314e902c57SThomas Graf info->nlh, GFP_KERNEL); 5321ce85fe4SPablo Neira Ayuso return; 533f21c7bc5SThomas Graf errout: 534f21c7bc5SThomas Graf if (err < 0) 5354d1169c1SDenis V. Lunev rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err); 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds 538c9cb6b6eSStephen Hemminger static int fib_detect_death(struct fib_info *fi, int order, 539c9cb6b6eSStephen Hemminger struct fib_info **last_resort, int *last_idx, 540c9cb6b6eSStephen Hemminger int dflt) 5411da177e4SLinus Torvalds { 542619d1826SDavid Ahern const struct fib_nh_common *nhc = fib_info_nhc(fi, 0); 5431da177e4SLinus Torvalds struct neighbour *n; 5441da177e4SLinus Torvalds int state = NUD_NONE; 5451da177e4SLinus Torvalds 546619d1826SDavid Ahern if (likely(nhc->nhc_gw_family == AF_INET)) 547619d1826SDavid Ahern n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev); 548619d1826SDavid Ahern else if (nhc->nhc_gw_family == AF_INET6) 549619d1826SDavid Ahern n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6, 550619d1826SDavid Ahern nhc->nhc_dev); 551619d1826SDavid Ahern else 552619d1826SDavid Ahern n = NULL; 553619d1826SDavid Ahern 5541da177e4SLinus Torvalds if (n) { 5551da177e4SLinus Torvalds state = n->nud_state; 5561da177e4SLinus Torvalds neigh_release(n); 55788f64320SJulian Anastasov } else { 55888f64320SJulian Anastasov return 0; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds if (state == NUD_REACHABLE) 5611da177e4SLinus Torvalds return 0; 562c17860a0SDenis V. Lunev if ((state & NUD_VALID) && order != dflt) 5631da177e4SLinus Torvalds return 0; 5641da177e4SLinus Torvalds if ((state & NUD_VALID) || 56588f64320SJulian Anastasov (*last_idx < 0 && order > dflt && state != NUD_INCOMPLETE)) { 5661da177e4SLinus Torvalds *last_resort = fi; 5671da177e4SLinus Torvalds *last_idx = order; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds return 1; 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds 572faee6769SAlexander Aring int fib_nh_common_init(struct net *net, struct fib_nh_common *nhc, 573faee6769SAlexander Aring struct nlattr *encap, u16 encap_type, 574faee6769SAlexander Aring void *cfg, gfp_t gfp_flags, 575979e276eSDavid Ahern struct netlink_ext_ack *extack) 576979e276eSDavid Ahern { 5770f457a36SDavid Ahern int err; 5780f457a36SDavid Ahern 5790f457a36SDavid Ahern nhc->nhc_pcpu_rth_output = alloc_percpu_gfp(struct rtable __rcu *, 5800f457a36SDavid Ahern gfp_flags); 5810f457a36SDavid Ahern if (!nhc->nhc_pcpu_rth_output) 5820f457a36SDavid Ahern return -ENOMEM; 5830f457a36SDavid Ahern 584979e276eSDavid Ahern if (encap) { 585979e276eSDavid Ahern struct lwtunnel_state *lwtstate; 586979e276eSDavid Ahern 587979e276eSDavid Ahern if (encap_type == LWTUNNEL_ENCAP_NONE) { 588979e276eSDavid Ahern NL_SET_ERR_MSG(extack, "LWT encap type not specified"); 5890f457a36SDavid Ahern err = -EINVAL; 5900f457a36SDavid Ahern goto lwt_failure; 591979e276eSDavid Ahern } 592faee6769SAlexander Aring err = lwtunnel_build_state(net, encap_type, encap, 593faee6769SAlexander Aring nhc->nhc_family, cfg, &lwtstate, 594faee6769SAlexander Aring extack); 595979e276eSDavid Ahern if (err) 5960f457a36SDavid Ahern goto lwt_failure; 597979e276eSDavid Ahern 598979e276eSDavid Ahern nhc->nhc_lwtstate = lwtstate_get(lwtstate); 599979e276eSDavid Ahern } 600979e276eSDavid Ahern 601979e276eSDavid Ahern return 0; 6020f457a36SDavid Ahern 6030f457a36SDavid Ahern lwt_failure: 6040f457a36SDavid Ahern rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output); 6050f457a36SDavid Ahern nhc->nhc_pcpu_rth_output = NULL; 6060f457a36SDavid Ahern return err; 607979e276eSDavid Ahern } 608979e276eSDavid Ahern EXPORT_SYMBOL_GPL(fib_nh_common_init); 609979e276eSDavid Ahern 610e4516ef6SDavid Ahern int fib_nh_init(struct net *net, struct fib_nh *nh, 611e4516ef6SDavid Ahern struct fib_config *cfg, int nh_weight, 612e4516ef6SDavid Ahern struct netlink_ext_ack *extack) 613e4516ef6SDavid Ahern { 6140f457a36SDavid Ahern int err; 615e4516ef6SDavid Ahern 616f1741730SDavid Ahern nh->fib_nh_family = AF_INET; 617f1741730SDavid Ahern 618faee6769SAlexander Aring err = fib_nh_common_init(net, &nh->nh_common, cfg->fc_encap, 619979e276eSDavid Ahern cfg->fc_encap_type, cfg, GFP_KERNEL, extack); 620e4516ef6SDavid Ahern if (err) 6210f457a36SDavid Ahern return err; 622e4516ef6SDavid Ahern 623b75ed8b1SDavid Ahern nh->fib_nh_oif = cfg->fc_oif; 624a4ea5d43SDavid Ahern nh->fib_nh_gw_family = cfg->fc_gw_family; 625a4ea5d43SDavid Ahern if (cfg->fc_gw_family == AF_INET) 626f35b794bSDavid Ahern nh->fib_nh_gw4 = cfg->fc_gw4; 627a4ea5d43SDavid Ahern else if (cfg->fc_gw_family == AF_INET6) 628a4ea5d43SDavid Ahern nh->fib_nh_gw6 = cfg->fc_gw6; 629a4ea5d43SDavid Ahern 630b75ed8b1SDavid Ahern nh->fib_nh_flags = cfg->fc_flags; 631e4516ef6SDavid Ahern 632e4516ef6SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 633e4516ef6SDavid Ahern nh->nh_tclassid = cfg->fc_flow; 634e4516ef6SDavid Ahern if (nh->nh_tclassid) 635213f5f8fSEric Dumazet atomic_inc(&net->ipv4.fib_num_tclassid_users); 636e4516ef6SDavid Ahern #endif 637e4516ef6SDavid Ahern #ifdef CONFIG_IP_ROUTE_MULTIPATH 638b75ed8b1SDavid Ahern nh->fib_nh_weight = nh_weight; 639e4516ef6SDavid Ahern #endif 640e4516ef6SDavid Ahern return 0; 641e4516ef6SDavid Ahern } 642e4516ef6SDavid Ahern 6431da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 6441da177e4SLinus Torvalds 6456d8422a1SDavid Ahern static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining, 6466d8422a1SDavid Ahern struct netlink_ext_ack *extack) 6471da177e4SLinus Torvalds { 6481da177e4SLinus Torvalds int nhs = 0; 6491da177e4SLinus Torvalds 6504e902c57SThomas Graf while (rtnh_ok(rtnh, remaining)) { 6511da177e4SLinus Torvalds nhs++; 6524e902c57SThomas Graf rtnh = rtnh_next(rtnh, &remaining); 6531da177e4SLinus Torvalds } 6541da177e4SLinus Torvalds 6554e902c57SThomas Graf /* leftover implies invalid nexthop configuration, discard it */ 656c3ab2b4eSDavid Ahern if (remaining > 0) { 657c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 658c3ab2b4eSDavid Ahern "Invalid nexthop configuration - extra data after nexthops"); 659c3ab2b4eSDavid Ahern nhs = 0; 660c3ab2b4eSDavid Ahern } 661c3ab2b4eSDavid Ahern 662c3ab2b4eSDavid Ahern return nhs; 6634e902c57SThomas Graf } 6641da177e4SLinus Torvalds 665*7a3429baSDavid Ahern static int fib_gw_from_attr(__be32 *gw, struct nlattr *nla, 666*7a3429baSDavid Ahern struct netlink_ext_ack *extack) 667*7a3429baSDavid Ahern { 668*7a3429baSDavid Ahern if (nla_len(nla) < sizeof(*gw)) { 669*7a3429baSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid IPv4 address in RTA_GATEWAY"); 670*7a3429baSDavid Ahern return -EINVAL; 671*7a3429baSDavid Ahern } 672*7a3429baSDavid Ahern 673*7a3429baSDavid Ahern *gw = nla_get_in_addr(nla); 674*7a3429baSDavid Ahern 675*7a3429baSDavid Ahern return 0; 676*7a3429baSDavid Ahern } 677*7a3429baSDavid Ahern 6784c7e8084SDavid Ahern /* only called when fib_nh is integrated into fib_info */ 6794e902c57SThomas Graf static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh, 6806d8422a1SDavid Ahern int remaining, struct fib_config *cfg, 6816d8422a1SDavid Ahern struct netlink_ext_ack *extack) 6824e902c57SThomas Graf { 683e4516ef6SDavid Ahern struct net *net = fi->fib_net; 684e4516ef6SDavid Ahern struct fib_config fib_cfg; 6855481d73fSDavid Ahern struct fib_nh *nh; 686571e7226SRoopa Prabhu int ret; 687571e7226SRoopa Prabhu 6881da177e4SLinus Torvalds change_nexthops(fi) { 6894e902c57SThomas Graf int attrlen; 6904e902c57SThomas Graf 691e4516ef6SDavid Ahern memset(&fib_cfg, 0, sizeof(fib_cfg)); 692e4516ef6SDavid Ahern 693c3ab2b4eSDavid Ahern if (!rtnh_ok(rtnh, remaining)) { 694c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 695c3ab2b4eSDavid Ahern "Invalid nexthop configuration - extra data after nexthop"); 6961da177e4SLinus Torvalds return -EINVAL; 697c3ab2b4eSDavid Ahern } 6984e902c57SThomas Graf 699c3ab2b4eSDavid Ahern if (rtnh->rtnh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) { 700c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 701c3ab2b4eSDavid Ahern "Invalid flags for nexthop - can not contain DEAD or LINKDOWN"); 70280610229SJulian Anastasov return -EINVAL; 703c3ab2b4eSDavid Ahern } 70480610229SJulian Anastasov 705e4516ef6SDavid Ahern fib_cfg.fc_flags = (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags; 706e4516ef6SDavid Ahern fib_cfg.fc_oif = rtnh->rtnh_ifindex; 7074e902c57SThomas Graf 7084e902c57SThomas Graf attrlen = rtnh_attrlen(rtnh); 7094e902c57SThomas Graf if (attrlen > 0) { 710d1566268SDavid Ahern struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh); 7114e902c57SThomas Graf 7124e902c57SThomas Graf nla = nla_find(attrs, attrlen, RTA_GATEWAY); 713d1566268SDavid Ahern nlav = nla_find(attrs, attrlen, RTA_VIA); 714d1566268SDavid Ahern if (nla && nlav) { 715d1566268SDavid Ahern NL_SET_ERR_MSG(extack, 716d1566268SDavid Ahern "Nexthop configuration can not contain both GATEWAY and VIA"); 717d1566268SDavid Ahern return -EINVAL; 718d1566268SDavid Ahern } 719f35b794bSDavid Ahern if (nla) { 720*7a3429baSDavid Ahern ret = fib_gw_from_attr(&fib_cfg.fc_gw4, nla, 721*7a3429baSDavid Ahern extack); 722*7a3429baSDavid Ahern if (ret) 723*7a3429baSDavid Ahern goto errout; 724*7a3429baSDavid Ahern 725d73f80f9SDavid Ahern if (fib_cfg.fc_gw4) 726d73f80f9SDavid Ahern fib_cfg.fc_gw_family = AF_INET; 727d1566268SDavid Ahern } else if (nlav) { 728d1566268SDavid Ahern ret = fib_gw_from_via(&fib_cfg, nlav, extack); 729d1566268SDavid Ahern if (ret) 730d1566268SDavid Ahern goto errout; 731f35b794bSDavid Ahern } 732571e7226SRoopa Prabhu 733e4516ef6SDavid Ahern nla = nla_find(attrs, attrlen, RTA_FLOW); 734e4516ef6SDavid Ahern if (nla) 735e4516ef6SDavid Ahern fib_cfg.fc_flow = nla_get_u32(nla); 736e4516ef6SDavid Ahern 737e4516ef6SDavid Ahern fib_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP); 738e4516ef6SDavid Ahern nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE); 739e4516ef6SDavid Ahern if (nla) 740e4516ef6SDavid Ahern fib_cfg.fc_encap_type = nla_get_u16(nla); 741c3ab2b4eSDavid Ahern } 74230357d7dSDavid Ahern 743e4516ef6SDavid Ahern ret = fib_nh_init(net, nexthop_nh, &fib_cfg, 744e4516ef6SDavid Ahern rtnh->rtnh_hops + 1, extack); 745571e7226SRoopa Prabhu if (ret) 746571e7226SRoopa Prabhu goto errout; 7474e902c57SThomas Graf 7484e902c57SThomas Graf rtnh = rtnh_next(rtnh, &remaining); 7491da177e4SLinus Torvalds } endfor_nexthops(fi); 7504e902c57SThomas Graf 751571e7226SRoopa Prabhu ret = -EINVAL; 7525481d73fSDavid Ahern nh = fib_info_nh(fi, 0); 7535481d73fSDavid Ahern if (cfg->fc_oif && nh->fib_nh_oif != cfg->fc_oif) { 754e4516ef6SDavid Ahern NL_SET_ERR_MSG(extack, 755e4516ef6SDavid Ahern "Nexthop device index does not match RTA_OIF"); 756e4516ef6SDavid Ahern goto errout; 757e4516ef6SDavid Ahern } 758f35b794bSDavid Ahern if (cfg->fc_gw_family) { 7595481d73fSDavid Ahern if (cfg->fc_gw_family != nh->fib_nh_gw_family || 760f35b794bSDavid Ahern (cfg->fc_gw_family == AF_INET && 7615481d73fSDavid Ahern nh->fib_nh_gw4 != cfg->fc_gw4) || 762a4ea5d43SDavid Ahern (cfg->fc_gw_family == AF_INET6 && 7635481d73fSDavid Ahern ipv6_addr_cmp(&nh->fib_nh_gw6, &cfg->fc_gw6))) { 764e4516ef6SDavid Ahern NL_SET_ERR_MSG(extack, 765a4ea5d43SDavid Ahern "Nexthop gateway does not match RTA_GATEWAY or RTA_VIA"); 766e4516ef6SDavid Ahern goto errout; 767e4516ef6SDavid Ahern } 768f35b794bSDavid Ahern } 769e4516ef6SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 7705481d73fSDavid Ahern if (cfg->fc_flow && nh->nh_tclassid != cfg->fc_flow) { 771e4516ef6SDavid Ahern NL_SET_ERR_MSG(extack, 772e4516ef6SDavid Ahern "Nexthop class id does not match RTA_FLOW"); 773e4516ef6SDavid Ahern goto errout; 774e4516ef6SDavid Ahern } 775e4516ef6SDavid Ahern #endif 776e4516ef6SDavid Ahern ret = 0; 777571e7226SRoopa Prabhu errout: 778571e7226SRoopa Prabhu return ret; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds 7814c7e8084SDavid Ahern /* only called when fib_nh is integrated into fib_info */ 7820e884c78SPeter Nørlund static void fib_rebalance(struct fib_info *fi) 7830e884c78SPeter Nørlund { 7840e884c78SPeter Nørlund int total; 7850e884c78SPeter Nørlund int w; 7860e884c78SPeter Nørlund 7875481d73fSDavid Ahern if (fib_info_num_path(fi) < 2) 7880e884c78SPeter Nørlund return; 7890e884c78SPeter Nørlund 7900e884c78SPeter Nørlund total = 0; 7910e884c78SPeter Nørlund for_nexthops(fi) { 792b75ed8b1SDavid Ahern if (nh->fib_nh_flags & RTNH_F_DEAD) 7930e884c78SPeter Nørlund continue; 7940e884c78SPeter Nørlund 795b75ed8b1SDavid Ahern if (ip_ignore_linkdown(nh->fib_nh_dev) && 796b75ed8b1SDavid Ahern nh->fib_nh_flags & RTNH_F_LINKDOWN) 7970e884c78SPeter Nørlund continue; 7980e884c78SPeter Nørlund 799b75ed8b1SDavid Ahern total += nh->fib_nh_weight; 8000e884c78SPeter Nørlund } endfor_nexthops(fi); 8010e884c78SPeter Nørlund 8020e884c78SPeter Nørlund w = 0; 8030e884c78SPeter Nørlund change_nexthops(fi) { 8040e884c78SPeter Nørlund int upper_bound; 8050e884c78SPeter Nørlund 806b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) { 8070e884c78SPeter Nørlund upper_bound = -1; 808b75ed8b1SDavid Ahern } else if (ip_ignore_linkdown(nexthop_nh->fib_nh_dev) && 809b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) { 8100e884c78SPeter Nørlund upper_bound = -1; 8110e884c78SPeter Nørlund } else { 812b75ed8b1SDavid Ahern w += nexthop_nh->fib_nh_weight; 8130a837fe4SPeter Nørlund upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31, 8140e884c78SPeter Nørlund total) - 1; 8150e884c78SPeter Nørlund } 8160e884c78SPeter Nørlund 817b75ed8b1SDavid Ahern atomic_set(&nexthop_nh->fib_nh_upper_bound, upper_bound); 8180e884c78SPeter Nørlund } endfor_nexthops(fi); 8190e884c78SPeter Nørlund } 8200e884c78SPeter Nørlund #else /* CONFIG_IP_ROUTE_MULTIPATH */ 8210e884c78SPeter Nørlund 8228373c6c8SDavid Ahern static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh, 8238373c6c8SDavid Ahern int remaining, struct fib_config *cfg, 8248373c6c8SDavid Ahern struct netlink_ext_ack *extack) 8258373c6c8SDavid Ahern { 8268373c6c8SDavid Ahern NL_SET_ERR_MSG(extack, "Multipath support not enabled in kernel"); 8278373c6c8SDavid Ahern 8288373c6c8SDavid Ahern return -EINVAL; 8298373c6c8SDavid Ahern } 8308373c6c8SDavid Ahern 8310e884c78SPeter Nørlund #define fib_rebalance(fi) do { } while (0) 8320e884c78SPeter Nørlund 8330e884c78SPeter Nørlund #endif /* CONFIG_IP_ROUTE_MULTIPATH */ 8341da177e4SLinus Torvalds 835faee6769SAlexander Aring static int fib_encap_match(struct net *net, u16 encap_type, 836571e7226SRoopa Prabhu struct nlattr *encap, 83730357d7dSDavid Ahern const struct fib_nh *nh, 8389ae28727SDavid Ahern const struct fib_config *cfg, 8399ae28727SDavid Ahern struct netlink_ext_ack *extack) 840571e7226SRoopa Prabhu { 841571e7226SRoopa Prabhu struct lwtunnel_state *lwtstate; 842df383e62SJiri Benc int ret, result = 0; 843571e7226SRoopa Prabhu 844571e7226SRoopa Prabhu if (encap_type == LWTUNNEL_ENCAP_NONE) 845571e7226SRoopa Prabhu return 0; 846571e7226SRoopa Prabhu 847faee6769SAlexander Aring ret = lwtunnel_build_state(net, encap_type, encap, AF_INET, 8489ae28727SDavid Ahern cfg, &lwtstate, extack); 849df383e62SJiri Benc if (!ret) { 850b75ed8b1SDavid Ahern result = lwtunnel_cmp_encap(lwtstate, nh->fib_nh_lws); 851df383e62SJiri Benc lwtstate_free(lwtstate); 852df383e62SJiri Benc } 853571e7226SRoopa Prabhu 854df383e62SJiri Benc return result; 855571e7226SRoopa Prabhu } 856571e7226SRoopa Prabhu 857faee6769SAlexander Aring int fib_nh_match(struct net *net, struct fib_config *cfg, struct fib_info *fi, 8589ae28727SDavid Ahern struct netlink_ext_ack *extack) 8591da177e4SLinus Torvalds { 8601da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 8614e902c57SThomas Graf struct rtnexthop *rtnh; 8624e902c57SThomas Graf int remaining; 8631da177e4SLinus Torvalds #endif 8641da177e4SLinus Torvalds 8654e902c57SThomas Graf if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority) 8661da177e4SLinus Torvalds return 1; 8671da177e4SLinus Torvalds 868493ced1aSDavid Ahern if (cfg->fc_nh_id) { 869493ced1aSDavid Ahern if (fi->nh && cfg->fc_nh_id == fi->nh->id) 870493ced1aSDavid Ahern return 0; 871493ced1aSDavid Ahern return 1; 872493ced1aSDavid Ahern } 873493ced1aSDavid Ahern 874f35b794bSDavid Ahern if (cfg->fc_oif || cfg->fc_gw_family) { 8755481d73fSDavid Ahern struct fib_nh *nh = fib_info_nh(fi, 0); 8765481d73fSDavid Ahern 877571e7226SRoopa Prabhu if (cfg->fc_encap) { 878faee6769SAlexander Aring if (fib_encap_match(net, cfg->fc_encap_type, 879faee6769SAlexander Aring cfg->fc_encap, nh, cfg, extack)) 880571e7226SRoopa Prabhu return 1; 881571e7226SRoopa Prabhu } 882a8c6db1dSStefano Brivio #ifdef CONFIG_IP_ROUTE_CLASSID 883a8c6db1dSStefano Brivio if (cfg->fc_flow && 8845481d73fSDavid Ahern cfg->fc_flow != nh->nh_tclassid) 885a8c6db1dSStefano Brivio return 1; 886a8c6db1dSStefano Brivio #endif 8875481d73fSDavid Ahern if ((cfg->fc_oif && cfg->fc_oif != nh->fib_nh_oif) || 888f35b794bSDavid Ahern (cfg->fc_gw_family && 8895481d73fSDavid Ahern cfg->fc_gw_family != nh->fib_nh_gw_family)) 8901da177e4SLinus Torvalds return 1; 891f35b794bSDavid Ahern 892f35b794bSDavid Ahern if (cfg->fc_gw_family == AF_INET && 8935481d73fSDavid Ahern cfg->fc_gw4 != nh->fib_nh_gw4) 894f35b794bSDavid Ahern return 1; 895f35b794bSDavid Ahern 896a4ea5d43SDavid Ahern if (cfg->fc_gw_family == AF_INET6 && 8975481d73fSDavid Ahern ipv6_addr_cmp(&cfg->fc_gw6, &nh->fib_nh_gw6)) 898a4ea5d43SDavid Ahern return 1; 899a4ea5d43SDavid Ahern 900f35b794bSDavid Ahern return 0; 9011da177e4SLinus Torvalds } 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 90451456b29SIan Morris if (!cfg->fc_mp) 9051da177e4SLinus Torvalds return 0; 9064e902c57SThomas Graf 9074e902c57SThomas Graf rtnh = cfg->fc_mp; 9084e902c57SThomas Graf remaining = cfg->fc_mp_len; 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds for_nexthops(fi) { 9114e902c57SThomas Graf int attrlen; 9121da177e4SLinus Torvalds 9134e902c57SThomas Graf if (!rtnh_ok(rtnh, remaining)) 9141da177e4SLinus Torvalds return -EINVAL; 9154e902c57SThomas Graf 916b75ed8b1SDavid Ahern if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->fib_nh_oif) 9171da177e4SLinus Torvalds return 1; 9184e902c57SThomas Graf 9194e902c57SThomas Graf attrlen = rtnh_attrlen(rtnh); 920f76936d0SJiri Pirko if (attrlen > 0) { 921d1566268SDavid Ahern struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh); 922*7a3429baSDavid Ahern int err; 9234e902c57SThomas Graf 9244e902c57SThomas Graf nla = nla_find(attrs, attrlen, RTA_GATEWAY); 925d1566268SDavid Ahern nlav = nla_find(attrs, attrlen, RTA_VIA); 926d1566268SDavid Ahern if (nla && nlav) { 927d1566268SDavid Ahern NL_SET_ERR_MSG(extack, 928d1566268SDavid Ahern "Nexthop configuration can not contain both GATEWAY and VIA"); 929d1566268SDavid Ahern return -EINVAL; 930d1566268SDavid Ahern } 931d1566268SDavid Ahern 932d1566268SDavid Ahern if (nla) { 933*7a3429baSDavid Ahern __be32 gw; 934*7a3429baSDavid Ahern 935*7a3429baSDavid Ahern err = fib_gw_from_attr(&gw, nla, extack); 936*7a3429baSDavid Ahern if (err) 937*7a3429baSDavid Ahern return err; 938*7a3429baSDavid Ahern 939d1566268SDavid Ahern if (nh->fib_nh_gw_family != AF_INET || 940*7a3429baSDavid Ahern gw != nh->fib_nh_gw4) 9411da177e4SLinus Torvalds return 1; 942d1566268SDavid Ahern } else if (nlav) { 943d1566268SDavid Ahern struct fib_config cfg2; 944d1566268SDavid Ahern 945d1566268SDavid Ahern err = fib_gw_from_via(&cfg2, nlav, extack); 946d1566268SDavid Ahern if (err) 947d1566268SDavid Ahern return err; 948d1566268SDavid Ahern 949d1566268SDavid Ahern switch (nh->fib_nh_gw_family) { 950d1566268SDavid Ahern case AF_INET: 951d1566268SDavid Ahern if (cfg2.fc_gw_family != AF_INET || 952d1566268SDavid Ahern cfg2.fc_gw4 != nh->fib_nh_gw4) 953d1566268SDavid Ahern return 1; 954d1566268SDavid Ahern break; 955d1566268SDavid Ahern case AF_INET6: 956d1566268SDavid Ahern if (cfg2.fc_gw_family != AF_INET6 || 957d1566268SDavid Ahern ipv6_addr_cmp(&cfg2.fc_gw6, 958d1566268SDavid Ahern &nh->fib_nh_gw6)) 959d1566268SDavid Ahern return 1; 960d1566268SDavid Ahern break; 961d1566268SDavid Ahern } 962d1566268SDavid Ahern } 963d1566268SDavid Ahern 964c7066f70SPatrick McHardy #ifdef CONFIG_IP_ROUTE_CLASSID 9654e902c57SThomas Graf nla = nla_find(attrs, attrlen, RTA_FLOW); 9664e902c57SThomas Graf if (nla && nla_get_u32(nla) != nh->nh_tclassid) 9671da177e4SLinus Torvalds return 1; 9681da177e4SLinus Torvalds #endif 9691da177e4SLinus Torvalds } 9704e902c57SThomas Graf 9714e902c57SThomas Graf rtnh = rtnh_next(rtnh, &remaining); 9721da177e4SLinus Torvalds } endfor_nexthops(fi); 9731da177e4SLinus Torvalds #endif 9741da177e4SLinus Torvalds return 0; 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds 9775f9ae3d9SXin Long bool fib_metrics_match(struct fib_config *cfg, struct fib_info *fi) 9785f9ae3d9SXin Long { 9795f9ae3d9SXin Long struct nlattr *nla; 9805f9ae3d9SXin Long int remaining; 9815f9ae3d9SXin Long 9825f9ae3d9SXin Long if (!cfg->fc_mx) 9835f9ae3d9SXin Long return true; 9845f9ae3d9SXin Long 9855f9ae3d9SXin Long nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) { 9865f9ae3d9SXin Long int type = nla_type(nla); 987d03a4557SPhil Sutter u32 fi_val, val; 9885f9ae3d9SXin Long 9895f9ae3d9SXin Long if (!type) 9905f9ae3d9SXin Long continue; 9915f9ae3d9SXin Long if (type > RTAX_MAX) 9925f9ae3d9SXin Long return false; 9935f9ae3d9SXin Long 9945f9ae3d9SXin Long if (type == RTAX_CC_ALGO) { 9955f9ae3d9SXin Long char tmp[TCP_CA_NAME_MAX]; 9965f9ae3d9SXin Long bool ecn_ca = false; 9975f9ae3d9SXin Long 998872f6903SFrancis Laniel nla_strscpy(tmp, nla, sizeof(tmp)); 9996670e152SStephen Hemminger val = tcp_ca_get_key_by_name(fi->fib_net, tmp, &ecn_ca); 10005f9ae3d9SXin Long } else { 10015b5e7a0dSEric Dumazet if (nla_len(nla) != sizeof(u32)) 10025b5e7a0dSEric Dumazet return false; 10035f9ae3d9SXin Long val = nla_get_u32(nla); 10045f9ae3d9SXin Long } 10055f9ae3d9SXin Long 1006d03a4557SPhil Sutter fi_val = fi->fib_metrics->metrics[type - 1]; 1007d03a4557SPhil Sutter if (type == RTAX_FEATURES) 1008d03a4557SPhil Sutter fi_val &= ~DST_FEATURE_ECN_CA; 1009d03a4557SPhil Sutter 1010d03a4557SPhil Sutter if (fi_val != val) 10115f9ae3d9SXin Long return false; 10125f9ae3d9SXin Long } 10135f9ae3d9SXin Long 10145f9ae3d9SXin Long return true; 10155f9ae3d9SXin Long } 10165f9ae3d9SXin Long 1017717a8f5bSDavid Ahern static int fib_check_nh_v6_gw(struct net *net, struct fib_nh *nh, 1018717a8f5bSDavid Ahern u32 table, struct netlink_ext_ack *extack) 1019717a8f5bSDavid Ahern { 1020717a8f5bSDavid Ahern struct fib6_config cfg = { 1021717a8f5bSDavid Ahern .fc_table = table, 1022717a8f5bSDavid Ahern .fc_flags = nh->fib_nh_flags | RTF_GATEWAY, 1023717a8f5bSDavid Ahern .fc_ifindex = nh->fib_nh_oif, 1024717a8f5bSDavid Ahern .fc_gateway = nh->fib_nh_gw6, 1025717a8f5bSDavid Ahern }; 1026717a8f5bSDavid Ahern struct fib6_nh fib6_nh = {}; 1027717a8f5bSDavid Ahern int err; 1028717a8f5bSDavid Ahern 1029717a8f5bSDavid Ahern err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack); 1030717a8f5bSDavid Ahern if (!err) { 1031717a8f5bSDavid Ahern nh->fib_nh_dev = fib6_nh.fib_nh_dev; 1032717a8f5bSDavid Ahern dev_hold(nh->fib_nh_dev); 1033717a8f5bSDavid Ahern nh->fib_nh_oif = nh->fib_nh_dev->ifindex; 1034717a8f5bSDavid Ahern nh->fib_nh_scope = RT_SCOPE_LINK; 1035717a8f5bSDavid Ahern 1036717a8f5bSDavid Ahern ipv6_stub->fib6_nh_release(&fib6_nh); 1037717a8f5bSDavid Ahern } 1038717a8f5bSDavid Ahern 1039717a8f5bSDavid Ahern return err; 1040717a8f5bSDavid Ahern } 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds /* 10436a31d2a9SEric Dumazet * Picture 10446a31d2a9SEric Dumazet * ------- 10456a31d2a9SEric Dumazet * 10466a31d2a9SEric Dumazet * Semantics of nexthop is very messy by historical reasons. 10476a31d2a9SEric Dumazet * We have to take into account, that: 10486a31d2a9SEric Dumazet * a) gateway can be actually local interface address, 10496a31d2a9SEric Dumazet * so that gatewayed route is direct. 10506a31d2a9SEric Dumazet * b) gateway must be on-link address, possibly 10516a31d2a9SEric Dumazet * described not by an ifaddr, but also by a direct route. 10526a31d2a9SEric Dumazet * c) If both gateway and interface are specified, they should not 10536a31d2a9SEric Dumazet * contradict. 10546a31d2a9SEric Dumazet * d) If we use tunnel routes, gateway could be not on-link. 10556a31d2a9SEric Dumazet * 10566a31d2a9SEric Dumazet * Attempt to reconcile all of these (alas, self-contradictory) conditions 10576a31d2a9SEric Dumazet * results in pretty ugly and hairy code with obscure logic. 10586a31d2a9SEric Dumazet * 10596a31d2a9SEric Dumazet * I chose to generalized it instead, so that the size 10606a31d2a9SEric Dumazet * of code does not increase practically, but it becomes 10616a31d2a9SEric Dumazet * much more general. 10626a31d2a9SEric Dumazet * Every prefix is assigned a "scope" value: "host" is local address, 10636a31d2a9SEric Dumazet * "link" is direct route, 10646a31d2a9SEric Dumazet * [ ... "site" ... "interior" ... ] 10656a31d2a9SEric Dumazet * and "universe" is true gateway route with global meaning. 10666a31d2a9SEric Dumazet * 10676a31d2a9SEric Dumazet * Every prefix refers to a set of "nexthop"s (gw, oif), 10686a31d2a9SEric Dumazet * where gw must have narrower scope. This recursion stops 10696a31d2a9SEric Dumazet * when gw has LOCAL scope or if "nexthop" is declared ONLINK, 10706a31d2a9SEric Dumazet * which means that gw is forced to be on link. 10716a31d2a9SEric Dumazet * 10726a31d2a9SEric Dumazet * Code is still hairy, but now it is apparently logically 10736a31d2a9SEric Dumazet * consistent and very flexible. F.e. as by-product it allows 10746a31d2a9SEric Dumazet * to co-exists in peace independent exterior and interior 10756a31d2a9SEric Dumazet * routing processes. 10766a31d2a9SEric Dumazet * 10776a31d2a9SEric Dumazet * Normally it looks as following. 10786a31d2a9SEric Dumazet * 10796a31d2a9SEric Dumazet * {universe prefix} -> (gw, oif) [scope link] 10806a31d2a9SEric Dumazet * | 10816a31d2a9SEric Dumazet * |-> {link prefix} -> (gw, oif) [scope local] 10826a31d2a9SEric Dumazet * | 10836a31d2a9SEric Dumazet * |-> {local prefix} (terminal node) 10841da177e4SLinus Torvalds */ 1085448d7248SDavid Ahern static int fib_check_nh_v4_gw(struct net *net, struct fib_nh *nh, u32 table, 1086448d7248SDavid Ahern u8 scope, struct netlink_ext_ack *extack) 10871da177e4SLinus Torvalds { 10886a31d2a9SEric Dumazet struct net_device *dev; 10891da177e4SLinus Torvalds struct fib_result res; 1090c3fee640SEnrico Weigelt int err = 0; 10911da177e4SLinus Torvalds 1092b75ed8b1SDavid Ahern if (nh->fib_nh_flags & RTNH_F_ONLINK) { 109330bbaa19SDavid Ahern unsigned int addr_type; 10941da177e4SLinus Torvalds 1095448d7248SDavid Ahern if (scope >= RT_SCOPE_LINK) { 1096448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid scope"); 10971da177e4SLinus Torvalds return -EINVAL; 1098c3ab2b4eSDavid Ahern } 1099b75ed8b1SDavid Ahern dev = __dev_get_by_index(net, nh->fib_nh_oif); 1100066b1030SDavid Ahern if (!dev) { 1101066b1030SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop device required for onlink"); 11021da177e4SLinus Torvalds return -ENODEV; 1103066b1030SDavid Ahern } 1104c3ab2b4eSDavid Ahern if (!(dev->flags & IFF_UP)) { 1105448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop device is not up"); 11061da177e4SLinus Torvalds return -ENETDOWN; 1107c3ab2b4eSDavid Ahern } 1108448d7248SDavid Ahern addr_type = inet_addr_type_dev_table(net, dev, nh->fib_nh_gw4); 1109c3ab2b4eSDavid Ahern if (addr_type != RTN_UNICAST) { 1110448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway"); 111130bbaa19SDavid Ahern return -EINVAL; 1112c3ab2b4eSDavid Ahern } 11138a3d0316SAndy Gospodarek if (!netif_carrier_ok(dev)) 1114b75ed8b1SDavid Ahern nh->fib_nh_flags |= RTNH_F_LINKDOWN; 1115b75ed8b1SDavid Ahern nh->fib_nh_dev = dev; 11161da177e4SLinus Torvalds dev_hold(dev); 1117b75ed8b1SDavid Ahern nh->fib_nh_scope = RT_SCOPE_LINK; 11181da177e4SLinus Torvalds return 0; 11191da177e4SLinus Torvalds } 1120ebc0ffaeSEric Dumazet rcu_read_lock(); 11211da177e4SLinus Torvalds { 11223bfd8472SDavid Ahern struct fib_table *tbl = NULL; 11239ade2286SDavid S. Miller struct flowi4 fl4 = { 1124b75ed8b1SDavid Ahern .daddr = nh->fib_nh_gw4, 1125448d7248SDavid Ahern .flowi4_scope = scope + 1, 1126b75ed8b1SDavid Ahern .flowi4_oif = nh->fib_nh_oif, 11276a662719SCong Wang .flowi4_iif = LOOPBACK_IFINDEX, 11284e902c57SThomas Graf }; 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds /* It is not necessary, but requires a bit of thinking */ 11319ade2286SDavid S. Miller if (fl4.flowi4_scope < RT_SCOPE_LINK) 11329ade2286SDavid S. Miller fl4.flowi4_scope = RT_SCOPE_LINK; 11333bfd8472SDavid Ahern 11345eea3a63Sguodeqing if (table && table != RT_TABLE_MAIN) 1135448d7248SDavid Ahern tbl = fib_get_table(net, table); 11363bfd8472SDavid Ahern 11373bfd8472SDavid Ahern if (tbl) 11383bfd8472SDavid Ahern err = fib_table_lookup(tbl, &fl4, &res, 11391e313678SEric Dumazet FIB_LOOKUP_IGNORE_LINKSTATE | 11401e313678SEric Dumazet FIB_LOOKUP_NOREF); 11414c9bcd11SDavid Ahern 11424c9bcd11SDavid Ahern /* on error or if no table given do full lookup. This 11434c9bcd11SDavid Ahern * is needed for example when nexthops are in the local 11444c9bcd11SDavid Ahern * table rather than the given table 11454c9bcd11SDavid Ahern */ 11464c9bcd11SDavid Ahern if (!tbl || err) { 11470eeb075fSAndy Gospodarek err = fib_lookup(net, &fl4, &res, 11480eeb075fSAndy Gospodarek FIB_LOOKUP_IGNORE_LINKSTATE); 11494c9bcd11SDavid Ahern } 11504c9bcd11SDavid Ahern 1151ebc0ffaeSEric Dumazet if (err) { 1152448d7248SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway"); 1153448d7248SDavid Ahern goto out; 11541da177e4SLinus Torvalds } 1155ebc0ffaeSEric Dumazet } 1156448d7248SDavid Ahern 11571da177e4SLinus Torvalds err = -EINVAL; 1158c3ab2b4eSDavid Ahern if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) { 1159c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway"); 11601da177e4SLinus Torvalds goto out; 1161c3ab2b4eSDavid Ahern } 1162b75ed8b1SDavid Ahern nh->fib_nh_scope = res.scope; 1163b75ed8b1SDavid Ahern nh->fib_nh_oif = FIB_RES_OIF(res); 1164b75ed8b1SDavid Ahern nh->fib_nh_dev = dev = FIB_RES_DEV(res); 1165c3ab2b4eSDavid Ahern if (!dev) { 1166c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1167c3ab2b4eSDavid Ahern "No egress device for nexthop gateway"); 11681da177e4SLinus Torvalds goto out; 1169c3ab2b4eSDavid Ahern } 11706a31d2a9SEric Dumazet dev_hold(dev); 11718a3d0316SAndy Gospodarek if (!netif_carrier_ok(dev)) 1172b75ed8b1SDavid Ahern nh->fib_nh_flags |= RTNH_F_LINKDOWN; 11738723e1b4SEric Dumazet err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN; 1174448d7248SDavid Ahern out: 1175448d7248SDavid Ahern rcu_read_unlock(); 1176448d7248SDavid Ahern return err; 1177448d7248SDavid Ahern } 1178448d7248SDavid Ahern 1179448d7248SDavid Ahern static int fib_check_nh_nongw(struct net *net, struct fib_nh *nh, 1180448d7248SDavid Ahern struct netlink_ext_ack *extack) 1181448d7248SDavid Ahern { 11821da177e4SLinus Torvalds struct in_device *in_dev; 1183448d7248SDavid Ahern int err; 11841da177e4SLinus Torvalds 1185b75ed8b1SDavid Ahern if (nh->fib_nh_flags & (RTNH_F_PERVASIVE | RTNH_F_ONLINK)) { 1186c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1187c3ab2b4eSDavid Ahern "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set"); 11881da177e4SLinus Torvalds return -EINVAL; 1189c3ab2b4eSDavid Ahern } 1190448d7248SDavid Ahern 11918723e1b4SEric Dumazet rcu_read_lock(); 1192448d7248SDavid Ahern 11938723e1b4SEric Dumazet err = -ENODEV; 1194b75ed8b1SDavid Ahern in_dev = inetdev_by_index(net, nh->fib_nh_oif); 119551456b29SIan Morris if (!in_dev) 11968723e1b4SEric Dumazet goto out; 11978723e1b4SEric Dumazet err = -ENETDOWN; 1198c3ab2b4eSDavid Ahern if (!(in_dev->dev->flags & IFF_UP)) { 1199c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Device for nexthop is not up"); 12008723e1b4SEric Dumazet goto out; 1201c3ab2b4eSDavid Ahern } 1202448d7248SDavid Ahern 1203b75ed8b1SDavid Ahern nh->fib_nh_dev = in_dev->dev; 1204b75ed8b1SDavid Ahern dev_hold(nh->fib_nh_dev); 1205b75ed8b1SDavid Ahern nh->fib_nh_scope = RT_SCOPE_HOST; 1206b75ed8b1SDavid Ahern if (!netif_carrier_ok(nh->fib_nh_dev)) 1207b75ed8b1SDavid Ahern nh->fib_nh_flags |= RTNH_F_LINKDOWN; 12088723e1b4SEric Dumazet err = 0; 12098723e1b4SEric Dumazet out: 12108723e1b4SEric Dumazet rcu_read_unlock(); 12118723e1b4SEric Dumazet return err; 12121da177e4SLinus Torvalds } 12131da177e4SLinus Torvalds 1214ac1fab2dSDavid Ahern int fib_check_nh(struct net *net, struct fib_nh *nh, u32 table, u8 scope, 1215448d7248SDavid Ahern struct netlink_ext_ack *extack) 1216448d7248SDavid Ahern { 1217448d7248SDavid Ahern int err; 1218448d7248SDavid Ahern 1219448d7248SDavid Ahern if (nh->fib_nh_gw_family == AF_INET) 1220ac1fab2dSDavid Ahern err = fib_check_nh_v4_gw(net, nh, table, scope, extack); 1221717a8f5bSDavid Ahern else if (nh->fib_nh_gw_family == AF_INET6) 1222717a8f5bSDavid Ahern err = fib_check_nh_v6_gw(net, nh, table, extack); 1223448d7248SDavid Ahern else 1224448d7248SDavid Ahern err = fib_check_nh_nongw(net, nh, extack); 1225448d7248SDavid Ahern 1226448d7248SDavid Ahern return err; 1227448d7248SDavid Ahern } 1228448d7248SDavid Ahern 122981f7bf6cSAl Viro static inline unsigned int fib_laddr_hashfn(__be32 val) 12301da177e4SLinus Torvalds { 1231123b9731SDavid S. Miller unsigned int mask = (fib_info_hash_size - 1); 12321da177e4SLinus Torvalds 12336a31d2a9SEric Dumazet return ((__force u32)val ^ 12346a31d2a9SEric Dumazet ((__force u32)val >> 7) ^ 12356a31d2a9SEric Dumazet ((__force u32)val >> 14)) & mask; 12361da177e4SLinus Torvalds } 12371da177e4SLinus Torvalds 1238123b9731SDavid S. Miller static struct hlist_head *fib_info_hash_alloc(int bytes) 12391da177e4SLinus Torvalds { 12401da177e4SLinus Torvalds if (bytes <= PAGE_SIZE) 124188f83491SJoonwoo Park return kzalloc(bytes, GFP_KERNEL); 12421da177e4SLinus Torvalds else 12431da177e4SLinus Torvalds return (struct hlist_head *) 12446a31d2a9SEric Dumazet __get_free_pages(GFP_KERNEL | __GFP_ZERO, 12456a31d2a9SEric Dumazet get_order(bytes)); 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds 1248123b9731SDavid S. Miller static void fib_info_hash_free(struct hlist_head *hash, int bytes) 12491da177e4SLinus Torvalds { 12501da177e4SLinus Torvalds if (!hash) 12511da177e4SLinus Torvalds return; 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds if (bytes <= PAGE_SIZE) 12541da177e4SLinus Torvalds kfree(hash); 12551da177e4SLinus Torvalds else 12561da177e4SLinus Torvalds free_pages((unsigned long) hash, get_order(bytes)); 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 1259123b9731SDavid S. Miller static void fib_info_hash_move(struct hlist_head *new_info_hash, 12601da177e4SLinus Torvalds struct hlist_head *new_laddrhash, 12611da177e4SLinus Torvalds unsigned int new_size) 12621da177e4SLinus Torvalds { 1263b7656e7fSDavid S. Miller struct hlist_head *old_info_hash, *old_laddrhash; 1264123b9731SDavid S. Miller unsigned int old_size = fib_info_hash_size; 1265b7656e7fSDavid S. Miller unsigned int i, bytes; 12661da177e4SLinus Torvalds 1267832b4c5eSStephen Hemminger spin_lock_bh(&fib_info_lock); 1268b7656e7fSDavid S. Miller old_info_hash = fib_info_hash; 1269b7656e7fSDavid S. Miller old_laddrhash = fib_info_laddrhash; 1270123b9731SDavid S. Miller fib_info_hash_size = new_size; 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds for (i = 0; i < old_size; i++) { 12731da177e4SLinus Torvalds struct hlist_head *head = &fib_info_hash[i]; 1274b67bfe0dSSasha Levin struct hlist_node *n; 12751da177e4SLinus Torvalds struct fib_info *fi; 12761da177e4SLinus Torvalds 1277b67bfe0dSSasha Levin hlist_for_each_entry_safe(fi, n, head, fib_hash) { 12781da177e4SLinus Torvalds struct hlist_head *dest; 12791da177e4SLinus Torvalds unsigned int new_hash; 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds new_hash = fib_info_hashfn(fi); 12821da177e4SLinus Torvalds dest = &new_info_hash[new_hash]; 12831da177e4SLinus Torvalds hlist_add_head(&fi->fib_hash, dest); 12841da177e4SLinus Torvalds } 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds fib_info_hash = new_info_hash; 12871da177e4SLinus Torvalds 12881da177e4SLinus Torvalds for (i = 0; i < old_size; i++) { 12891da177e4SLinus Torvalds struct hlist_head *lhead = &fib_info_laddrhash[i]; 1290b67bfe0dSSasha Levin struct hlist_node *n; 12911da177e4SLinus Torvalds struct fib_info *fi; 12921da177e4SLinus Torvalds 1293b67bfe0dSSasha Levin hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) { 12941da177e4SLinus Torvalds struct hlist_head *ldest; 12951da177e4SLinus Torvalds unsigned int new_hash; 12961da177e4SLinus Torvalds 12971da177e4SLinus Torvalds new_hash = fib_laddr_hashfn(fi->fib_prefsrc); 12981da177e4SLinus Torvalds ldest = &new_laddrhash[new_hash]; 12991da177e4SLinus Torvalds hlist_add_head(&fi->fib_lhash, ldest); 13001da177e4SLinus Torvalds } 13011da177e4SLinus Torvalds } 13021da177e4SLinus Torvalds fib_info_laddrhash = new_laddrhash; 13031da177e4SLinus Torvalds 1304832b4c5eSStephen Hemminger spin_unlock_bh(&fib_info_lock); 1305b7656e7fSDavid S. Miller 1306b7656e7fSDavid S. Miller bytes = old_size * sizeof(struct hlist_head *); 1307123b9731SDavid S. Miller fib_info_hash_free(old_info_hash, bytes); 1308123b9731SDavid S. Miller fib_info_hash_free(old_laddrhash, bytes); 13091da177e4SLinus Torvalds } 13101da177e4SLinus Torvalds 1311dcb1ecb5SDavid Ahern __be32 fib_info_update_nhc_saddr(struct net *net, struct fib_nh_common *nhc, 1312c3669486SDavid Ahern unsigned char scope) 1313436c3b66SDavid S. Miller { 1314dcb1ecb5SDavid Ahern struct fib_nh *nh; 1315dcb1ecb5SDavid Ahern 1316dcb1ecb5SDavid Ahern if (nhc->nhc_family != AF_INET) 1317dcb1ecb5SDavid Ahern return inet_select_addr(nhc->nhc_dev, 0, scope); 1318dcb1ecb5SDavid Ahern 1319dcb1ecb5SDavid Ahern nh = container_of(nhc, struct fib_nh, nh_common); 1320c3669486SDavid Ahern nh->nh_saddr = inet_select_addr(nh->fib_nh_dev, nh->fib_nh_gw4, scope); 1321436c3b66SDavid S. Miller nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid); 1322436c3b66SDavid S. Miller 1323436c3b66SDavid S. Miller return nh->nh_saddr; 1324436c3b66SDavid S. Miller } 1325436c3b66SDavid S. Miller 1326eba618abSDavid Ahern __be32 fib_result_prefsrc(struct net *net, struct fib_result *res) 1327eba618abSDavid Ahern { 1328eba618abSDavid Ahern struct fib_nh_common *nhc = res->nhc; 1329eba618abSDavid Ahern 1330eba618abSDavid Ahern if (res->fi->fib_prefsrc) 1331eba618abSDavid Ahern return res->fi->fib_prefsrc; 1332eba618abSDavid Ahern 1333dcb1ecb5SDavid Ahern if (nhc->nhc_family == AF_INET) { 1334dcb1ecb5SDavid Ahern struct fib_nh *nh; 1335dcb1ecb5SDavid Ahern 1336eba618abSDavid Ahern nh = container_of(nhc, struct fib_nh, nh_common); 1337eba618abSDavid Ahern if (nh->nh_saddr_genid == atomic_read(&net->ipv4.dev_addr_genid)) 1338eba618abSDavid Ahern return nh->nh_saddr; 1339dcb1ecb5SDavid Ahern } 1340eba618abSDavid Ahern 1341dcb1ecb5SDavid Ahern return fib_info_update_nhc_saddr(net, nhc, res->fi->fib_scope); 1342eba618abSDavid Ahern } 1343eba618abSDavid Ahern 1344021dd3b8SDavid Ahern static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc) 1345021dd3b8SDavid Ahern { 1346021dd3b8SDavid Ahern if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst || 1347021dd3b8SDavid Ahern fib_prefsrc != cfg->fc_dst) { 13489b8ff518SDavid Ahern u32 tb_id = cfg->fc_table; 1349e1b8d903SDavid Ahern int rc; 1350021dd3b8SDavid Ahern 1351021dd3b8SDavid Ahern if (tb_id == RT_TABLE_MAIN) 1352021dd3b8SDavid Ahern tb_id = RT_TABLE_LOCAL; 1353021dd3b8SDavid Ahern 1354e1b8d903SDavid Ahern rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net, 1355e1b8d903SDavid Ahern fib_prefsrc, tb_id); 1356e1b8d903SDavid Ahern 1357e1b8d903SDavid Ahern if (rc != RTN_LOCAL && tb_id != RT_TABLE_LOCAL) { 1358e1b8d903SDavid Ahern rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net, 1359e1b8d903SDavid Ahern fib_prefsrc, RT_TABLE_LOCAL); 1360021dd3b8SDavid Ahern } 1361e1b8d903SDavid Ahern 1362e1b8d903SDavid Ahern if (rc != RTN_LOCAL) 1363e1b8d903SDavid Ahern return false; 1364021dd3b8SDavid Ahern } 1365021dd3b8SDavid Ahern return true; 1366021dd3b8SDavid Ahern } 1367021dd3b8SDavid Ahern 13686d8422a1SDavid Ahern struct fib_info *fib_create_info(struct fib_config *cfg, 13696d8422a1SDavid Ahern struct netlink_ext_ack *extack) 13701da177e4SLinus Torvalds { 13711da177e4SLinus Torvalds int err; 13721da177e4SLinus Torvalds struct fib_info *fi = NULL; 13734c7e8084SDavid Ahern struct nexthop *nh = NULL; 13741da177e4SLinus Torvalds struct fib_info *ofi; 13751da177e4SLinus Torvalds int nhs = 1; 13767462bd74SDenis V. Lunev struct net *net = cfg->fc_nlinfo.nl_net; 13771da177e4SLinus Torvalds 13784c8237cdSDavid S. Miller if (cfg->fc_type > RTN_MAX) 13794c8237cdSDavid S. Miller goto err_inval; 13804c8237cdSDavid S. Miller 13811da177e4SLinus Torvalds /* Fast check to catch the most weird cases */ 1382c3ab2b4eSDavid Ahern if (fib_props[cfg->fc_type].scope > cfg->fc_scope) { 1383c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid scope"); 13841da177e4SLinus Torvalds goto err_inval; 1385c3ab2b4eSDavid Ahern } 13861da177e4SLinus Torvalds 1387c3ab2b4eSDavid Ahern if (cfg->fc_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) { 1388c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1389c3ab2b4eSDavid Ahern "Invalid rtm_flags - can not contain DEAD or LINKDOWN"); 139080610229SJulian Anastasov goto err_inval; 1391c3ab2b4eSDavid Ahern } 139280610229SJulian Anastasov 1393493ced1aSDavid Ahern if (cfg->fc_nh_id) { 13946c48ea5fSDavid Ahern if (!cfg->fc_mx) { 13956c48ea5fSDavid Ahern fi = fib_find_info_nh(net, cfg); 13966c48ea5fSDavid Ahern if (fi) { 139779976892SYajun Deng refcount_inc(&fi->fib_treeref); 13986c48ea5fSDavid Ahern return fi; 13996c48ea5fSDavid Ahern } 14006c48ea5fSDavid Ahern } 14016c48ea5fSDavid Ahern 1402493ced1aSDavid Ahern nh = nexthop_find_by_id(net, cfg->fc_nh_id); 1403493ced1aSDavid Ahern if (!nh) { 1404493ced1aSDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop id does not exist"); 1405493ced1aSDavid Ahern goto err_inval; 1406493ced1aSDavid Ahern } 1407493ced1aSDavid Ahern nhs = 0; 1408493ced1aSDavid Ahern } 1409493ced1aSDavid Ahern 14101da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 14114e902c57SThomas Graf if (cfg->fc_mp) { 14126d8422a1SDavid Ahern nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack); 14131da177e4SLinus Torvalds if (nhs == 0) 14141da177e4SLinus Torvalds goto err_inval; 14151da177e4SLinus Torvalds } 14161da177e4SLinus Torvalds #endif 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds err = -ENOBUFS; 1419123b9731SDavid S. Miller if (fib_info_cnt >= fib_info_hash_size) { 1420123b9731SDavid S. Miller unsigned int new_size = fib_info_hash_size << 1; 14211da177e4SLinus Torvalds struct hlist_head *new_info_hash; 14221da177e4SLinus Torvalds struct hlist_head *new_laddrhash; 14231da177e4SLinus Torvalds unsigned int bytes; 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds if (!new_size) 1426d94ce9b2SEric Dumazet new_size = 16; 14271da177e4SLinus Torvalds bytes = new_size * sizeof(struct hlist_head *); 1428123b9731SDavid S. Miller new_info_hash = fib_info_hash_alloc(bytes); 1429123b9731SDavid S. Miller new_laddrhash = fib_info_hash_alloc(bytes); 14301da177e4SLinus Torvalds if (!new_info_hash || !new_laddrhash) { 1431123b9731SDavid S. Miller fib_info_hash_free(new_info_hash, bytes); 1432123b9731SDavid S. Miller fib_info_hash_free(new_laddrhash, bytes); 143388f83491SJoonwoo Park } else 1434123b9731SDavid S. Miller fib_info_hash_move(new_info_hash, new_laddrhash, new_size); 14351da177e4SLinus Torvalds 1436123b9731SDavid S. Miller if (!fib_info_hash_size) 14371da177e4SLinus Torvalds goto failure; 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds 14401f533ba6SGustavo A. R. Silva fi = kzalloc(struct_size(fi, fib_nh, nhs), GFP_KERNEL); 144151456b29SIan Morris if (!fi) 14421da177e4SLinus Torvalds goto failure; 1443767a2217SDavid Ahern fi->fib_metrics = ip_fib_metrics_init(fi->fib_net, cfg->fc_mx, 1444d7e774f3SDavid Ahern cfg->fc_mx_len, extack); 144588e235b8SEnrico Weigelt if (IS_ERR(fi->fib_metrics)) { 1446767a2217SDavid Ahern err = PTR_ERR(fi->fib_metrics); 1447187e5b3aSEric Dumazet kfree(fi); 1448187e5b3aSEric Dumazet return ERR_PTR(err); 1449187e5b3aSEric Dumazet } 1450767a2217SDavid Ahern 1451187e5b3aSEric Dumazet fib_info_cnt++; 1452efd7ef1cSEric W. Biederman fi->fib_net = net; 14534e902c57SThomas Graf fi->fib_protocol = cfg->fc_protocol; 145437e826c5SDavid S. Miller fi->fib_scope = cfg->fc_scope; 14554e902c57SThomas Graf fi->fib_flags = cfg->fc_flags; 14564e902c57SThomas Graf fi->fib_priority = cfg->fc_priority; 14574e902c57SThomas Graf fi->fib_prefsrc = cfg->fc_prefsrc; 1458f4ef85bbSEric Dumazet fi->fib_type = cfg->fc_type; 14595a56a0b3SMark Tomlinson fi->fib_tb_id = cfg->fc_table; 14601da177e4SLinus Torvalds 14611da177e4SLinus Torvalds fi->fib_nhs = nhs; 14624c7e8084SDavid Ahern if (nh) { 14634c7e8084SDavid Ahern if (!nexthop_get(nh)) { 14644c7e8084SDavid Ahern NL_SET_ERR_MSG(extack, "Nexthop has been deleted"); 14654c7e8084SDavid Ahern err = -EINVAL; 14664c7e8084SDavid Ahern } else { 14674c7e8084SDavid Ahern err = 0; 14684c7e8084SDavid Ahern fi->nh = nh; 14694c7e8084SDavid Ahern } 14704c7e8084SDavid Ahern } else { 14711da177e4SLinus Torvalds change_nexthops(fi) { 147271fceff0SDavid S. Miller nexthop_nh->nh_parent = fi; 14731da177e4SLinus Torvalds } endfor_nexthops(fi) 14741da177e4SLinus Torvalds 1475e4516ef6SDavid Ahern if (cfg->fc_mp) 14764c7e8084SDavid Ahern err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg, 14774c7e8084SDavid Ahern extack); 1478e4516ef6SDavid Ahern else 1479e4516ef6SDavid Ahern err = fib_nh_init(net, fi->fib_nh, cfg, 1, extack); 14804c7e8084SDavid Ahern } 1481e4516ef6SDavid Ahern 14824e902c57SThomas Graf if (err != 0) 14831da177e4SLinus Torvalds goto failure; 14841da177e4SLinus Torvalds 14854e902c57SThomas Graf if (fib_props[cfg->fc_type].error) { 1486f35b794bSDavid Ahern if (cfg->fc_gw_family || cfg->fc_oif || cfg->fc_mp) { 1487c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1488c3ab2b4eSDavid Ahern "Gateway, device and multipath can not be specified for this route type"); 14891da177e4SLinus Torvalds goto err_inval; 1490c3ab2b4eSDavid Ahern } 14911da177e4SLinus Torvalds goto link_it; 14924c8237cdSDavid S. Miller } else { 14934c8237cdSDavid S. Miller switch (cfg->fc_type) { 14944c8237cdSDavid S. Miller case RTN_UNICAST: 14954c8237cdSDavid S. Miller case RTN_LOCAL: 14964c8237cdSDavid S. Miller case RTN_BROADCAST: 14974c8237cdSDavid S. Miller case RTN_ANYCAST: 14984c8237cdSDavid S. Miller case RTN_MULTICAST: 14994c8237cdSDavid S. Miller break; 15004c8237cdSDavid S. Miller default: 1501c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid route type"); 15024c8237cdSDavid S. Miller goto err_inval; 15034c8237cdSDavid S. Miller } 15041da177e4SLinus Torvalds } 15051da177e4SLinus Torvalds 1506c3ab2b4eSDavid Ahern if (cfg->fc_scope > RT_SCOPE_HOST) { 1507c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid scope"); 15081da177e4SLinus Torvalds goto err_inval; 1509c3ab2b4eSDavid Ahern } 15101da177e4SLinus Torvalds 15114c7e8084SDavid Ahern if (fi->nh) { 15124c7e8084SDavid Ahern err = fib_check_nexthop(fi->nh, cfg->fc_scope, extack); 15134c7e8084SDavid Ahern if (err) 15144c7e8084SDavid Ahern goto failure; 15154c7e8084SDavid Ahern } else if (cfg->fc_scope == RT_SCOPE_HOST) { 15161da177e4SLinus Torvalds struct fib_nh *nh = fi->fib_nh; 15171da177e4SLinus Torvalds 15181da177e4SLinus Torvalds /* Local address is added. */ 1519c3ab2b4eSDavid Ahern if (nhs != 1) { 1520c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1521c3ab2b4eSDavid Ahern "Route with host scope can not have multiple nexthops"); 15226d8422a1SDavid Ahern goto err_inval; 1523c3ab2b4eSDavid Ahern } 1524bdf00467SDavid Ahern if (nh->fib_nh_gw_family) { 1525c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, 1526c3ab2b4eSDavid Ahern "Route with host scope can not have a gateway"); 15271da177e4SLinus Torvalds goto err_inval; 1528c3ab2b4eSDavid Ahern } 1529b75ed8b1SDavid Ahern nh->fib_nh_scope = RT_SCOPE_NOWHERE; 15305481d73fSDavid Ahern nh->fib_nh_dev = dev_get_by_index(net, nh->fib_nh_oif); 15311da177e4SLinus Torvalds err = -ENODEV; 1532b75ed8b1SDavid Ahern if (!nh->fib_nh_dev) 15331da177e4SLinus Torvalds goto failure; 15341da177e4SLinus Torvalds } else { 15358a3d0316SAndy Gospodarek int linkdown = 0; 15368a3d0316SAndy Gospodarek 15371da177e4SLinus Torvalds change_nexthops(fi) { 1538ac1fab2dSDavid Ahern err = fib_check_nh(cfg->fc_nlinfo.nl_net, nexthop_nh, 1539ac1fab2dSDavid Ahern cfg->fc_table, cfg->fc_scope, 1540ac1fab2dSDavid Ahern extack); 15416a31d2a9SEric Dumazet if (err != 0) 15421da177e4SLinus Torvalds goto failure; 1543b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) 15448a3d0316SAndy Gospodarek linkdown++; 15451da177e4SLinus Torvalds } endfor_nexthops(fi) 15468a3d0316SAndy Gospodarek if (linkdown == fi->fib_nhs) 15478a3d0316SAndy Gospodarek fi->fib_flags |= RTNH_F_LINKDOWN; 15481da177e4SLinus Torvalds } 15491da177e4SLinus Torvalds 1550c3ab2b4eSDavid Ahern if (fi->fib_prefsrc && !fib_valid_prefsrc(cfg, fi->fib_prefsrc)) { 1551c3ab2b4eSDavid Ahern NL_SET_ERR_MSG(extack, "Invalid prefsrc address"); 15521da177e4SLinus Torvalds goto err_inval; 1553c3ab2b4eSDavid Ahern } 15541da177e4SLinus Torvalds 15554c7e8084SDavid Ahern if (!fi->nh) { 15561fc050a1SDavid S. Miller change_nexthops(fi) { 1557dcb1ecb5SDavid Ahern fib_info_update_nhc_saddr(net, &nexthop_nh->nh_common, 1558dcb1ecb5SDavid Ahern fi->fib_scope); 155919a9d136SDavid Ahern if (nexthop_nh->fib_nh_gw_family == AF_INET6) 156019a9d136SDavid Ahern fi->fib_nh_is_v6 = true; 15611fc050a1SDavid S. Miller } endfor_nexthops(fi) 15621fc050a1SDavid S. Miller 15630e884c78SPeter Nørlund fib_rebalance(fi); 15644c7e8084SDavid Ahern } 15650e884c78SPeter Nørlund 15661da177e4SLinus Torvalds link_it: 15676a31d2a9SEric Dumazet ofi = fib_find_info(fi); 15686a31d2a9SEric Dumazet if (ofi) { 15691da177e4SLinus Torvalds fi->fib_dead = 1; 15701da177e4SLinus Torvalds free_fib_info(fi); 157179976892SYajun Deng refcount_inc(&ofi->fib_treeref); 15721da177e4SLinus Torvalds return ofi; 15731da177e4SLinus Torvalds } 15741da177e4SLinus Torvalds 157528814cd1SDavid Ahern refcount_set(&fi->fib_treeref, 1); 15760029c0deSReshetova, Elena refcount_set(&fi->fib_clntref, 1); 1577832b4c5eSStephen Hemminger spin_lock_bh(&fib_info_lock); 15781da177e4SLinus Torvalds hlist_add_head(&fi->fib_hash, 15791da177e4SLinus Torvalds &fib_info_hash[fib_info_hashfn(fi)]); 15801da177e4SLinus Torvalds if (fi->fib_prefsrc) { 15811da177e4SLinus Torvalds struct hlist_head *head; 15821da177e4SLinus Torvalds 15831da177e4SLinus Torvalds head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)]; 15841da177e4SLinus Torvalds hlist_add_head(&fi->fib_lhash, head); 15851da177e4SLinus Torvalds } 15864c7e8084SDavid Ahern if (fi->nh) { 15874c7e8084SDavid Ahern list_add(&fi->nh_list, &nh->fi_list); 15884c7e8084SDavid Ahern } else { 15891da177e4SLinus Torvalds change_nexthops(fi) { 15901da177e4SLinus Torvalds struct hlist_head *head; 15911da177e4SLinus Torvalds unsigned int hash; 15921da177e4SLinus Torvalds 1593b75ed8b1SDavid Ahern if (!nexthop_nh->fib_nh_dev) 15941da177e4SLinus Torvalds continue; 1595b75ed8b1SDavid Ahern hash = fib_devindex_hashfn(nexthop_nh->fib_nh_dev->ifindex); 15961da177e4SLinus Torvalds head = &fib_info_devhash[hash]; 159771fceff0SDavid S. Miller hlist_add_head(&nexthop_nh->nh_hash, head); 15981da177e4SLinus Torvalds } endfor_nexthops(fi) 15994c7e8084SDavid Ahern } 1600832b4c5eSStephen Hemminger spin_unlock_bh(&fib_info_lock); 16011da177e4SLinus Torvalds return fi; 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds err_inval: 16041da177e4SLinus Torvalds err = -EINVAL; 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds failure: 16071da177e4SLinus Torvalds if (fi) { 16081da177e4SLinus Torvalds fi->fib_dead = 1; 16091da177e4SLinus Torvalds free_fib_info(fi); 16101da177e4SLinus Torvalds } 16114e902c57SThomas Graf 16124e902c57SThomas Graf return ERR_PTR(err); 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 1615c0a72077SDavid Ahern int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nhc, 16167bdf4de1SDonald Sharp u8 rt_family, unsigned char *flags, bool skip_oif) 1617b0f60193SDavid Ahern { 1618c2364199SDavid Ahern if (nhc->nhc_flags & RTNH_F_DEAD) 1619b0f60193SDavid Ahern *flags |= RTNH_F_DEAD; 1620b0f60193SDavid Ahern 1621c2364199SDavid Ahern if (nhc->nhc_flags & RTNH_F_LINKDOWN) { 1622b0f60193SDavid Ahern *flags |= RTNH_F_LINKDOWN; 1623b0f60193SDavid Ahern 1624b0f60193SDavid Ahern rcu_read_lock(); 1625c2364199SDavid Ahern switch (nhc->nhc_family) { 1626c2364199SDavid Ahern case AF_INET: 1627c2364199SDavid Ahern if (ip_ignore_linkdown(nhc->nhc_dev)) 1628b0f60193SDavid Ahern *flags |= RTNH_F_DEAD; 1629c2364199SDavid Ahern break; 1630c0a72077SDavid Ahern case AF_INET6: 1631c0a72077SDavid Ahern if (ip6_ignore_linkdown(nhc->nhc_dev)) 1632c0a72077SDavid Ahern *flags |= RTNH_F_DEAD; 1633c0a72077SDavid Ahern break; 1634c2364199SDavid Ahern } 1635b0f60193SDavid Ahern rcu_read_unlock(); 1636b0f60193SDavid Ahern } 1637b0f60193SDavid Ahern 1638bdf00467SDavid Ahern switch (nhc->nhc_gw_family) { 1639c2364199SDavid Ahern case AF_INET: 1640c2364199SDavid Ahern if (nla_put_in_addr(skb, RTA_GATEWAY, nhc->nhc_gw.ipv4)) 1641b0f60193SDavid Ahern goto nla_put_failure; 1642c2364199SDavid Ahern break; 1643c0a72077SDavid Ahern case AF_INET6: 1644d1566268SDavid Ahern /* if gateway family does not match nexthop family 1645d1566268SDavid Ahern * gateway is encoded as RTA_VIA 1646d1566268SDavid Ahern */ 16477bdf4de1SDonald Sharp if (rt_family != nhc->nhc_gw_family) { 1648d1566268SDavid Ahern int alen = sizeof(struct in6_addr); 1649d1566268SDavid Ahern struct nlattr *nla; 1650d1566268SDavid Ahern struct rtvia *via; 1651d1566268SDavid Ahern 1652d1566268SDavid Ahern nla = nla_reserve(skb, RTA_VIA, alen + 2); 1653d1566268SDavid Ahern if (!nla) 1654c0a72077SDavid Ahern goto nla_put_failure; 1655d1566268SDavid Ahern 1656d1566268SDavid Ahern via = nla_data(nla); 1657d1566268SDavid Ahern via->rtvia_family = AF_INET6; 1658d1566268SDavid Ahern memcpy(via->rtvia_addr, &nhc->nhc_gw.ipv6, alen); 1659d1566268SDavid Ahern } else if (nla_put_in6_addr(skb, RTA_GATEWAY, 1660d1566268SDavid Ahern &nhc->nhc_gw.ipv6) < 0) { 1661d1566268SDavid Ahern goto nla_put_failure; 1662d1566268SDavid Ahern } 1663c0a72077SDavid Ahern break; 1664c2364199SDavid Ahern } 1665b0f60193SDavid Ahern 1666ca787e0bSIdo Schimmel *flags |= (nhc->nhc_flags & 1667ca787e0bSIdo Schimmel (RTNH_F_ONLINK | RTNH_F_OFFLOAD | RTNH_F_TRAP)); 1668b0f60193SDavid Ahern 1669c2364199SDavid Ahern if (!skip_oif && nhc->nhc_dev && 1670c2364199SDavid Ahern nla_put_u32(skb, RTA_OIF, nhc->nhc_dev->ifindex)) 1671b0f60193SDavid Ahern goto nla_put_failure; 1672b0f60193SDavid Ahern 1673c2364199SDavid Ahern if (nhc->nhc_lwtstate && 1674ffa8ce54SDavid Ahern lwtunnel_fill_encap(skb, nhc->nhc_lwtstate, 1675ffa8ce54SDavid Ahern RTA_ENCAP, RTA_ENCAP_TYPE) < 0) 1676b0f60193SDavid Ahern goto nla_put_failure; 1677b0f60193SDavid Ahern 1678b0f60193SDavid Ahern return 0; 1679b0f60193SDavid Ahern 1680b0f60193SDavid Ahern nla_put_failure: 1681b0f60193SDavid Ahern return -EMSGSIZE; 1682b0f60193SDavid Ahern } 1683c0a72077SDavid Ahern EXPORT_SYMBOL_GPL(fib_nexthop_info); 1684b0f60193SDavid Ahern 1685c0a72077SDavid Ahern #if IS_ENABLED(CONFIG_IP_ROUTE_MULTIPATH) || IS_ENABLED(CONFIG_IPV6) 1686c0a72077SDavid Ahern int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nhc, 1687597aa16cSXiao Liang int nh_weight, u8 rt_family, u32 nh_tclassid) 1688b0f60193SDavid Ahern { 1689c2364199SDavid Ahern const struct net_device *dev = nhc->nhc_dev; 1690b0f60193SDavid Ahern struct rtnexthop *rtnh; 1691ecc5663cSDavid Ahern unsigned char flags = 0; 1692b0f60193SDavid Ahern 1693b0f60193SDavid Ahern rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh)); 1694b0f60193SDavid Ahern if (!rtnh) 1695b0f60193SDavid Ahern goto nla_put_failure; 1696b0f60193SDavid Ahern 1697c2364199SDavid Ahern rtnh->rtnh_hops = nh_weight - 1; 1698b0f60193SDavid Ahern rtnh->rtnh_ifindex = dev ? dev->ifindex : 0; 1699b0f60193SDavid Ahern 17007bdf4de1SDonald Sharp if (fib_nexthop_info(skb, nhc, rt_family, &flags, true) < 0) 1701b0f60193SDavid Ahern goto nla_put_failure; 1702b0f60193SDavid Ahern 1703b0f60193SDavid Ahern rtnh->rtnh_flags = flags; 1704b0f60193SDavid Ahern 1705597aa16cSXiao Liang if (nh_tclassid && nla_put_u32(skb, RTA_FLOW, nh_tclassid)) 1706597aa16cSXiao Liang goto nla_put_failure; 1707597aa16cSXiao Liang 1708b0f60193SDavid Ahern /* length of rtnetlink header + attributes */ 1709b0f60193SDavid Ahern rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh; 1710b0f60193SDavid Ahern 1711b0f60193SDavid Ahern return 0; 1712b0f60193SDavid Ahern 1713b0f60193SDavid Ahern nla_put_failure: 1714b0f60193SDavid Ahern return -EMSGSIZE; 1715b0f60193SDavid Ahern } 1716c0a72077SDavid Ahern EXPORT_SYMBOL_GPL(fib_add_nexthop); 1717c2364199SDavid Ahern #endif 1718b0f60193SDavid Ahern 1719c2364199SDavid Ahern #ifdef CONFIG_IP_ROUTE_MULTIPATH 1720b0f60193SDavid Ahern static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi) 1721b0f60193SDavid Ahern { 1722b0f60193SDavid Ahern struct nlattr *mp; 1723b0f60193SDavid Ahern 1724ae0be8deSMichal Kubecek mp = nla_nest_start_noflag(skb, RTA_MULTIPATH); 1725b0f60193SDavid Ahern if (!mp) 1726b0f60193SDavid Ahern goto nla_put_failure; 1727b0f60193SDavid Ahern 17284c7e8084SDavid Ahern if (unlikely(fi->nh)) { 17297bdf4de1SDonald Sharp if (nexthop_mpath_fill_node(skb, fi->nh, AF_INET) < 0) 17304c7e8084SDavid Ahern goto nla_put_failure; 17314c7e8084SDavid Ahern goto mp_end; 17324c7e8084SDavid Ahern } 17334c7e8084SDavid Ahern 1734b0f60193SDavid Ahern for_nexthops(fi) { 1735597aa16cSXiao Liang u32 nh_tclassid = 0; 1736b0f60193SDavid Ahern #ifdef CONFIG_IP_ROUTE_CLASSID 1737597aa16cSXiao Liang nh_tclassid = nh->nh_tclassid; 1738b0f60193SDavid Ahern #endif 1739597aa16cSXiao Liang if (fib_add_nexthop(skb, &nh->nh_common, nh->fib_nh_weight, 1740597aa16cSXiao Liang AF_INET, nh_tclassid) < 0) 1741597aa16cSXiao Liang goto nla_put_failure; 1742b0f60193SDavid Ahern } endfor_nexthops(fi); 1743b0f60193SDavid Ahern 17444c7e8084SDavid Ahern mp_end: 1745b0f60193SDavid Ahern nla_nest_end(skb, mp); 1746b0f60193SDavid Ahern 1747b0f60193SDavid Ahern return 0; 1748b0f60193SDavid Ahern 1749b0f60193SDavid Ahern nla_put_failure: 1750b0f60193SDavid Ahern return -EMSGSIZE; 1751b0f60193SDavid Ahern } 1752b0f60193SDavid Ahern #else 1753b0f60193SDavid Ahern static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi) 1754b0f60193SDavid Ahern { 1755b0f60193SDavid Ahern return 0; 1756b0f60193SDavid Ahern } 1757b0f60193SDavid Ahern #endif 1758b0f60193SDavid Ahern 175915e47304SEric W. Biederman int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event, 176008554789SAmit Cohen const struct fib_rt_info *fri, unsigned int flags) 17611da177e4SLinus Torvalds { 17621e301fd0SIdo Schimmel unsigned int nhs = fib_info_num_path(fri->fi); 17631e301fd0SIdo Schimmel struct fib_info *fi = fri->fi; 17641e301fd0SIdo Schimmel u32 tb_id = fri->tb_id; 17651da177e4SLinus Torvalds struct nlmsghdr *nlh; 1766be403ea1SThomas Graf struct rtmsg *rtm; 17671da177e4SLinus Torvalds 176815e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags); 176951456b29SIan Morris if (!nlh) 177026932566SPatrick McHardy return -EMSGSIZE; 1771be403ea1SThomas Graf 1772be403ea1SThomas Graf rtm = nlmsg_data(nlh); 17731da177e4SLinus Torvalds rtm->rtm_family = AF_INET; 17741e301fd0SIdo Schimmel rtm->rtm_dst_len = fri->dst_len; 17751da177e4SLinus Torvalds rtm->rtm_src_len = 0; 17761e301fd0SIdo Schimmel rtm->rtm_tos = fri->tos; 1777709772e6SKrzysztof Piotr Oledzki if (tb_id < 256) 17781da177e4SLinus Torvalds rtm->rtm_table = tb_id; 1779709772e6SKrzysztof Piotr Oledzki else 1780709772e6SKrzysztof Piotr Oledzki rtm->rtm_table = RT_TABLE_COMPAT; 1781f3756b79SDavid S. Miller if (nla_put_u32(skb, RTA_TABLE, tb_id)) 1782f3756b79SDavid S. Miller goto nla_put_failure; 17831e301fd0SIdo Schimmel rtm->rtm_type = fri->type; 17841da177e4SLinus Torvalds rtm->rtm_flags = fi->fib_flags; 178537e826c5SDavid S. Miller rtm->rtm_scope = fi->fib_scope; 17861da177e4SLinus Torvalds rtm->rtm_protocol = fi->fib_protocol; 1787be403ea1SThomas Graf 1788f3756b79SDavid S. Miller if (rtm->rtm_dst_len && 17891e301fd0SIdo Schimmel nla_put_in_addr(skb, RTA_DST, fri->dst)) 1790f3756b79SDavid S. Miller goto nla_put_failure; 1791f3756b79SDavid S. Miller if (fi->fib_priority && 1792f3756b79SDavid S. Miller nla_put_u32(skb, RTA_PRIORITY, fi->fib_priority)) 1793f3756b79SDavid S. Miller goto nla_put_failure; 17943fb07dafSEric Dumazet if (rtnetlink_put_metrics(skb, fi->fib_metrics->metrics) < 0) 1795be403ea1SThomas Graf goto nla_put_failure; 1796be403ea1SThomas Graf 1797f3756b79SDavid S. Miller if (fi->fib_prefsrc && 1798930345eaSJiri Benc nla_put_in_addr(skb, RTA_PREFSRC, fi->fib_prefsrc)) 1799f3756b79SDavid S. Miller goto nla_put_failure; 18004c7e8084SDavid Ahern 18014c7e8084SDavid Ahern if (fi->nh) { 18024c7e8084SDavid Ahern if (nla_put_u32(skb, RTA_NH_ID, fi->nh->id)) 18034c7e8084SDavid Ahern goto nla_put_failure; 18044c7e8084SDavid Ahern if (nexthop_is_blackhole(fi->nh)) 18054c7e8084SDavid Ahern rtm->rtm_type = RTN_BLACKHOLE; 18064f80116dSRoopa Prabhu if (!fi->fib_net->ipv4.sysctl_nexthop_compat_mode) 18074f80116dSRoopa Prabhu goto offload; 18084c7e8084SDavid Ahern } 18094c7e8084SDavid Ahern 18105481d73fSDavid Ahern if (nhs == 1) { 1811dcb1ecb5SDavid Ahern const struct fib_nh_common *nhc = fib_info_nhc(fi, 0); 1812ecc5663cSDavid Ahern unsigned char flags = 0; 1813be403ea1SThomas Graf 18147bdf4de1SDonald Sharp if (fib_nexthop_info(skb, nhc, AF_INET, &flags, false) < 0) 1815be403ea1SThomas Graf goto nla_put_failure; 18161da177e4SLinus Torvalds 1817b0f60193SDavid Ahern rtm->rtm_flags = flags; 1818c7066f70SPatrick McHardy #ifdef CONFIG_IP_ROUTE_CLASSID 1819dcb1ecb5SDavid Ahern if (nhc->nhc_family == AF_INET) { 1820dcb1ecb5SDavid Ahern struct fib_nh *nh; 1821dcb1ecb5SDavid Ahern 1822dcb1ecb5SDavid Ahern nh = container_of(nhc, struct fib_nh, nh_common); 1823f3756b79SDavid S. Miller if (nh->nh_tclassid && 1824f3756b79SDavid S. Miller nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid)) 1825f3756b79SDavid S. Miller goto nla_put_failure; 1826dcb1ecb5SDavid Ahern } 18278265abc0SPatrick McHardy #endif 1828b0f60193SDavid Ahern } else { 1829b0f60193SDavid Ahern if (fib_add_multipath(skb, fi) < 0) 1830ea7a8085SDavid Ahern goto nla_put_failure; 18311da177e4SLinus Torvalds } 1832b0f60193SDavid Ahern 18334f80116dSRoopa Prabhu offload: 183490b93f1bSIdo Schimmel if (fri->offload) 183590b93f1bSIdo Schimmel rtm->rtm_flags |= RTM_F_OFFLOAD; 183690b93f1bSIdo Schimmel if (fri->trap) 183790b93f1bSIdo Schimmel rtm->rtm_flags |= RTM_F_TRAP; 183836c5100eSAmit Cohen if (fri->offload_failed) 183936c5100eSAmit Cohen rtm->rtm_flags |= RTM_F_OFFLOAD_FAILED; 184090b93f1bSIdo Schimmel 1841053c095aSJohannes Berg nlmsg_end(skb, nlh); 1842053c095aSJohannes Berg return 0; 18431da177e4SLinus Torvalds 1844be403ea1SThomas Graf nla_put_failure: 184526932566SPatrick McHardy nlmsg_cancel(skb, nlh); 184626932566SPatrick McHardy return -EMSGSIZE; 18471da177e4SLinus Torvalds } 18481da177e4SLinus Torvalds 18491da177e4SLinus Torvalds /* 18506a31d2a9SEric Dumazet * Update FIB if: 18516a31d2a9SEric Dumazet * - local address disappeared -> we must delete all the entries 18526a31d2a9SEric Dumazet * referring to it. 18536a31d2a9SEric Dumazet * - device went down -> we must shutdown all nexthops going via it. 18541da177e4SLinus Torvalds */ 18555a56a0b3SMark Tomlinson int fib_sync_down_addr(struct net_device *dev, __be32 local) 18561da177e4SLinus Torvalds { 18571da177e4SLinus Torvalds int ret = 0; 18581da177e4SLinus Torvalds unsigned int hash = fib_laddr_hashfn(local); 18591da177e4SLinus Torvalds struct hlist_head *head = &fib_info_laddrhash[hash]; 1860e0a31262SDavid Ahern int tb_id = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN; 18615a56a0b3SMark Tomlinson struct net *net = dev_net(dev); 18621da177e4SLinus Torvalds struct fib_info *fi; 18631da177e4SLinus Torvalds 186451456b29SIan Morris if (!fib_info_laddrhash || local == 0) 186585326fa5SDenis V. Lunev return 0; 186685326fa5SDenis V. Lunev 1867b67bfe0dSSasha Levin hlist_for_each_entry(fi, head, fib_lhash) { 18685a56a0b3SMark Tomlinson if (!net_eq(fi->fib_net, net) || 18695a56a0b3SMark Tomlinson fi->fib_tb_id != tb_id) 18704814bdbdSDenis V. Lunev continue; 18711da177e4SLinus Torvalds if (fi->fib_prefsrc == local) { 18721da177e4SLinus Torvalds fi->fib_flags |= RTNH_F_DEAD; 18731da177e4SLinus Torvalds ret++; 18741da177e4SLinus Torvalds } 18751da177e4SLinus Torvalds } 187685326fa5SDenis V. Lunev return ret; 18771da177e4SLinus Torvalds } 18781da177e4SLinus Torvalds 1879b75ed8b1SDavid Ahern static int call_fib_nh_notifiers(struct fib_nh *nh, 1880982acb97SIdo Schimmel enum fib_event_type event_type) 1881982acb97SIdo Schimmel { 1882b75ed8b1SDavid Ahern bool ignore_link_down = ip_ignore_linkdown(nh->fib_nh_dev); 1883982acb97SIdo Schimmel struct fib_nh_notifier_info info = { 1884b75ed8b1SDavid Ahern .fib_nh = nh, 1885982acb97SIdo Schimmel }; 1886982acb97SIdo Schimmel 1887982acb97SIdo Schimmel switch (event_type) { 1888982acb97SIdo Schimmel case FIB_EVENT_NH_ADD: 1889b75ed8b1SDavid Ahern if (nh->fib_nh_flags & RTNH_F_DEAD) 1890982acb97SIdo Schimmel break; 1891b75ed8b1SDavid Ahern if (ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) 1892982acb97SIdo Schimmel break; 1893b75ed8b1SDavid Ahern return call_fib4_notifiers(dev_net(nh->fib_nh_dev), event_type, 1894982acb97SIdo Schimmel &info.info); 1895982acb97SIdo Schimmel case FIB_EVENT_NH_DEL: 1896b75ed8b1SDavid Ahern if ((ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) || 1897b75ed8b1SDavid Ahern (nh->fib_nh_flags & RTNH_F_DEAD)) 1898b75ed8b1SDavid Ahern return call_fib4_notifiers(dev_net(nh->fib_nh_dev), 1899982acb97SIdo Schimmel event_type, &info.info); 190079121184SGustavo A. R. Silva break; 1901982acb97SIdo Schimmel default: 1902982acb97SIdo Schimmel break; 1903982acb97SIdo Schimmel } 1904982acb97SIdo Schimmel 1905982acb97SIdo Schimmel return NOTIFY_DONE; 1906982acb97SIdo Schimmel } 1907982acb97SIdo Schimmel 1908af7d6cceSSabrina Dubroca /* Update the PMTU of exceptions when: 1909af7d6cceSSabrina Dubroca * - the new MTU of the first hop becomes smaller than the PMTU 1910af7d6cceSSabrina Dubroca * - the old MTU was the same as the PMTU, and it limited discovery of 1911af7d6cceSSabrina Dubroca * larger MTUs on the path. With that limit raised, we can now 1912af7d6cceSSabrina Dubroca * discover larger MTUs 1913af7d6cceSSabrina Dubroca * A special case is locked exceptions, for which the PMTU is smaller 1914af7d6cceSSabrina Dubroca * than the minimal accepted PMTU: 1915af7d6cceSSabrina Dubroca * - if the new MTU is greater than the PMTU, don't make any change 1916af7d6cceSSabrina Dubroca * - otherwise, unlock and set PMTU 1917af7d6cceSSabrina Dubroca */ 191806c77c3eSDavid Ahern void fib_nhc_update_mtu(struct fib_nh_common *nhc, u32 new, u32 orig) 1919af7d6cceSSabrina Dubroca { 1920af7d6cceSSabrina Dubroca struct fnhe_hash_bucket *bucket; 1921af7d6cceSSabrina Dubroca int i; 1922af7d6cceSSabrina Dubroca 1923a5995e71SDavid Ahern bucket = rcu_dereference_protected(nhc->nhc_exceptions, 1); 1924af7d6cceSSabrina Dubroca if (!bucket) 1925af7d6cceSSabrina Dubroca return; 1926af7d6cceSSabrina Dubroca 1927af7d6cceSSabrina Dubroca for (i = 0; i < FNHE_HASH_SIZE; i++) { 1928af7d6cceSSabrina Dubroca struct fib_nh_exception *fnhe; 1929af7d6cceSSabrina Dubroca 1930af7d6cceSSabrina Dubroca for (fnhe = rcu_dereference_protected(bucket[i].chain, 1); 1931af7d6cceSSabrina Dubroca fnhe; 1932af7d6cceSSabrina Dubroca fnhe = rcu_dereference_protected(fnhe->fnhe_next, 1)) { 1933af7d6cceSSabrina Dubroca if (fnhe->fnhe_mtu_locked) { 1934af7d6cceSSabrina Dubroca if (new <= fnhe->fnhe_pmtu) { 1935af7d6cceSSabrina Dubroca fnhe->fnhe_pmtu = new; 1936af7d6cceSSabrina Dubroca fnhe->fnhe_mtu_locked = false; 1937af7d6cceSSabrina Dubroca } 1938af7d6cceSSabrina Dubroca } else if (new < fnhe->fnhe_pmtu || 1939af7d6cceSSabrina Dubroca orig == fnhe->fnhe_pmtu) { 1940af7d6cceSSabrina Dubroca fnhe->fnhe_pmtu = new; 1941af7d6cceSSabrina Dubroca } 1942af7d6cceSSabrina Dubroca } 1943af7d6cceSSabrina Dubroca } 1944af7d6cceSSabrina Dubroca } 1945af7d6cceSSabrina Dubroca 1946af7d6cceSSabrina Dubroca void fib_sync_mtu(struct net_device *dev, u32 orig_mtu) 1947af7d6cceSSabrina Dubroca { 1948af7d6cceSSabrina Dubroca unsigned int hash = fib_devindex_hashfn(dev->ifindex); 1949af7d6cceSSabrina Dubroca struct hlist_head *head = &fib_info_devhash[hash]; 1950af7d6cceSSabrina Dubroca struct fib_nh *nh; 1951af7d6cceSSabrina Dubroca 1952af7d6cceSSabrina Dubroca hlist_for_each_entry(nh, head, nh_hash) { 1953b75ed8b1SDavid Ahern if (nh->fib_nh_dev == dev) 195406c77c3eSDavid Ahern fib_nhc_update_mtu(&nh->nh_common, dev->mtu, orig_mtu); 1955af7d6cceSSabrina Dubroca } 1956af7d6cceSSabrina Dubroca } 1957af7d6cceSSabrina Dubroca 19584f823defSJulian Anastasov /* Event force Flags Description 19594f823defSJulian Anastasov * NETDEV_CHANGE 0 LINKDOWN Carrier OFF, not for scope host 19604f823defSJulian Anastasov * NETDEV_DOWN 0 LINKDOWN|DEAD Link down, not for scope host 19614f823defSJulian Anastasov * NETDEV_DOWN 1 LINKDOWN|DEAD Last address removed 19624f823defSJulian Anastasov * NETDEV_UNREGISTER 1 LINKDOWN|DEAD Device removed 19634c7e8084SDavid Ahern * 19644c7e8084SDavid Ahern * only used when fib_nh is built into fib_info 19654f823defSJulian Anastasov */ 19664f823defSJulian Anastasov int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force) 196785326fa5SDenis V. Lunev { 196885326fa5SDenis V. Lunev int ret = 0; 196985326fa5SDenis V. Lunev int scope = RT_SCOPE_NOWHERE; 19701da177e4SLinus Torvalds struct fib_info *prev_fi = NULL; 19711da177e4SLinus Torvalds unsigned int hash = fib_devindex_hashfn(dev->ifindex); 19721da177e4SLinus Torvalds struct hlist_head *head = &fib_info_devhash[hash]; 19731da177e4SLinus Torvalds struct fib_nh *nh; 19741da177e4SLinus Torvalds 19754f823defSJulian Anastasov if (force) 197685326fa5SDenis V. Lunev scope = -1; 197785326fa5SDenis V. Lunev 1978b67bfe0dSSasha Levin hlist_for_each_entry(nh, head, nh_hash) { 19791da177e4SLinus Torvalds struct fib_info *fi = nh->nh_parent; 19801da177e4SLinus Torvalds int dead; 19811da177e4SLinus Torvalds 19821da177e4SLinus Torvalds BUG_ON(!fi->fib_nhs); 1983b75ed8b1SDavid Ahern if (nh->fib_nh_dev != dev || fi == prev_fi) 19841da177e4SLinus Torvalds continue; 19851da177e4SLinus Torvalds prev_fi = fi; 19861da177e4SLinus Torvalds dead = 0; 19871da177e4SLinus Torvalds change_nexthops(fi) { 1988b75ed8b1SDavid Ahern if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) 19891da177e4SLinus Torvalds dead++; 1990b75ed8b1SDavid Ahern else if (nexthop_nh->fib_nh_dev == dev && 1991b75ed8b1SDavid Ahern nexthop_nh->fib_nh_scope != scope) { 19928a3d0316SAndy Gospodarek switch (event) { 19938a3d0316SAndy Gospodarek case NETDEV_DOWN: 19948a3d0316SAndy Gospodarek case NETDEV_UNREGISTER: 1995b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags |= RTNH_F_DEAD; 1996a8eceea8SJoe Perches fallthrough; 19978a3d0316SAndy Gospodarek case NETDEV_CHANGE: 1998b75ed8b1SDavid Ahern nexthop_nh->fib_nh_flags |= RTNH_F_LINKDOWN; 19998a3d0316SAndy Gospodarek break; 20008a3d0316SAndy Gospodarek } 2001982acb97SIdo Schimmel call_fib_nh_notifiers(nexthop_nh, 2002982acb97SIdo Schimmel FIB_EVENT_NH_DEL); 20031da177e4SLinus Torvalds dead++; 20041da177e4SLinus Torvalds } 20051da177e4SLinus Torvalds #ifdef CONFIG_IP_ROUTE_MULTIPATH 20068a3d0316SAndy Gospodarek if (event == NETDEV_UNREGISTER && 2007b75ed8b1SDavid Ahern nexthop_nh->fib_nh_dev == dev) { 20081da177e4SLinus Torvalds dead = fi->fib_nhs; 20091da177e4SLinus Torvalds break; 20101da177e4SLinus Torvalds } 20111da177e4SLinus Torvalds #endif 20121da177e4SLinus Torvalds } endfor_nexthops(fi) 20131da177e4SLinus Torvalds if (dead == fi->fib_nhs) { 20148a3d0316SAndy Gospodarek switch (event) { 20158a3d0316SAndy Gospodarek case NETDEV_DOWN: 20168a3d0316SAndy Gospodarek case NETDEV_UNREGISTER: 20171da177e4SLinus Torvalds fi->fib_flags |= RTNH_F_DEAD; 2018a8eceea8SJoe Perches fallthrough; 20198a3d0316SAndy Gospodarek case NETDEV_CHANGE: 20208a3d0316SAndy Gospodarek fi->fib_flags |= RTNH_F_LINKDOWN; 20218a3d0316SAndy Gospodarek break; 20228a3d0316SAndy Gospodarek } 20231da177e4SLinus Torvalds ret++; 20241da177e4SLinus Torvalds } 20250e884c78SPeter Nørlund 20260e884c78SPeter Nørlund fib_rebalance(fi); 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds 20291da177e4SLinus Torvalds return ret; 20301da177e4SLinus Torvalds } 20311da177e4SLinus Torvalds 20320c838ff1SDavid S. Miller /* Must be invoked inside of an RCU protected region. */ 2033c7b371e3SDavid Ahern static void fib_select_default(const struct flowi4 *flp, struct fib_result *res) 20340c838ff1SDavid S. Miller { 20350c838ff1SDavid S. Miller struct fib_info *fi = NULL, *last_resort = NULL; 203656315f9eSAlexander Duyck struct hlist_head *fa_head = res->fa_head; 20370c838ff1SDavid S. Miller struct fib_table *tb = res->table; 203818a912e9SJulian Anastasov u8 slen = 32 - res->prefixlen; 20390c838ff1SDavid S. Miller int order = -1, last_idx = -1; 20402392debcSJulian Anastasov struct fib_alias *fa, *fa1 = NULL; 20412392debcSJulian Anastasov u32 last_prio = res->fi->fib_priority; 20422392debcSJulian Anastasov u8 last_tos = 0; 20430c838ff1SDavid S. Miller 204456315f9eSAlexander Duyck hlist_for_each_entry_rcu(fa, fa_head, fa_list) { 20450c838ff1SDavid S. Miller struct fib_info *next_fi = fa->fa_info; 20467c74b0beSDavid Ahern struct fib_nh_common *nhc; 20470c838ff1SDavid S. Miller 204818a912e9SJulian Anastasov if (fa->fa_slen != slen) 204918a912e9SJulian Anastasov continue; 20502392debcSJulian Anastasov if (fa->fa_tos && fa->fa_tos != flp->flowi4_tos) 20512392debcSJulian Anastasov continue; 205218a912e9SJulian Anastasov if (fa->tb_id != tb->tb_id) 205318a912e9SJulian Anastasov continue; 20542392debcSJulian Anastasov if (next_fi->fib_priority > last_prio && 20552392debcSJulian Anastasov fa->fa_tos == last_tos) { 20562392debcSJulian Anastasov if (last_tos) 20572392debcSJulian Anastasov continue; 20582392debcSJulian Anastasov break; 20592392debcSJulian Anastasov } 20602392debcSJulian Anastasov if (next_fi->fib_flags & RTNH_F_DEAD) 20612392debcSJulian Anastasov continue; 20622392debcSJulian Anastasov last_tos = fa->fa_tos; 20632392debcSJulian Anastasov last_prio = next_fi->fib_priority; 20642392debcSJulian Anastasov 206537e826c5SDavid S. Miller if (next_fi->fib_scope != res->scope || 20660c838ff1SDavid S. Miller fa->fa_type != RTN_UNICAST) 20670c838ff1SDavid S. Miller continue; 20685481d73fSDavid Ahern 20697c74b0beSDavid Ahern nhc = fib_info_nhc(next_fi, 0); 20707c74b0beSDavid Ahern if (!nhc->nhc_gw_family || nhc->nhc_scope != RT_SCOPE_LINK) 20710c838ff1SDavid S. Miller continue; 20720c838ff1SDavid S. Miller 20730c838ff1SDavid S. Miller fib_alias_accessed(fa); 20740c838ff1SDavid S. Miller 207551456b29SIan Morris if (!fi) { 20760c838ff1SDavid S. Miller if (next_fi != res->fi) 20770c838ff1SDavid S. Miller break; 20782392debcSJulian Anastasov fa1 = fa; 20790c838ff1SDavid S. Miller } else if (!fib_detect_death(fi, order, &last_resort, 20802392debcSJulian Anastasov &last_idx, fa1->fa_default)) { 20810c838ff1SDavid S. Miller fib_result_assign(res, fi); 20822392debcSJulian Anastasov fa1->fa_default = order; 20830c838ff1SDavid S. Miller goto out; 20840c838ff1SDavid S. Miller } 20850c838ff1SDavid S. Miller fi = next_fi; 20860c838ff1SDavid S. Miller order++; 20870c838ff1SDavid S. Miller } 20880c838ff1SDavid S. Miller 208951456b29SIan Morris if (order <= 0 || !fi) { 20902392debcSJulian Anastasov if (fa1) 20912392debcSJulian Anastasov fa1->fa_default = -1; 20920c838ff1SDavid S. Miller goto out; 20930c838ff1SDavid S. Miller } 20940c838ff1SDavid S. Miller 20950c838ff1SDavid S. Miller if (!fib_detect_death(fi, order, &last_resort, &last_idx, 20962392debcSJulian Anastasov fa1->fa_default)) { 20970c838ff1SDavid S. Miller fib_result_assign(res, fi); 20982392debcSJulian Anastasov fa1->fa_default = order; 20990c838ff1SDavid S. Miller goto out; 21000c838ff1SDavid S. Miller } 21010c838ff1SDavid S. Miller 21020c838ff1SDavid S. Miller if (last_idx >= 0) 21030c838ff1SDavid S. Miller fib_result_assign(res, last_resort); 21042392debcSJulian Anastasov fa1->fa_default = last_idx; 21050c838ff1SDavid S. Miller out: 210631d40937SEric Dumazet return; 21070c838ff1SDavid S. Miller } 21080c838ff1SDavid S. Miller 21091da177e4SLinus Torvalds /* 21106a31d2a9SEric Dumazet * Dead device goes up. We wake up dead nexthops. 21116a31d2a9SEric Dumazet * It takes sense only on multipath routes. 21124c7e8084SDavid Ahern * 21134c7e8084SDavid Ahern * only used when fib_nh is built into fib_info 21141da177e4SLinus Torvalds */ 2115ecc5663cSDavid Ahern int fib_sync_up(struct net_device *dev, unsigned char nh_flags) 21161da177e4SLinus Torvalds { 21171da177e4SLinus Torvalds struct fib_info *prev_fi; 21181da177e4SLinus Torvalds unsigned int hash; 21191da177e4SLinus Torvalds struct hlist_head *head; 21201da177e4SLinus Torvalds struct fib_nh *nh; 21211da177e4SLinus Torvalds int ret; 21221da177e4SLinus Torvalds 21231da177e4SLinus Torvalds if (!(dev->flags & IFF_UP)) 21241da177e4SLinus Torvalds return 0; 21251da177e4SLinus Torvalds 2126c9b3292eSJulian Anastasov if (nh_flags & RTNH_F_DEAD) { 2127c9b3292eSJulian Anastasov unsigned int flags = dev_get_flags(dev); 2128c9b3292eSJulian Anastasov 2129c9b3292eSJulian Anastasov if (flags & (IFF_RUNNING | IFF_LOWER_UP)) 2130c9b3292eSJulian Anastasov nh_flags |= RTNH_F_LINKDOWN; 2131c9b3292eSJulian Anastasov } 2132c9b3292eSJulian Anastasov 21331da177e4SLinus Torvalds prev_fi = NULL; 21341da177e4SLinus Torvalds hash = fib_devindex_hashfn(dev->ifindex); 21351da177e4SLinus Torvalds head = &fib_info_devhash[hash]; 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