blob: 467b3c15395f14dffa749b2b8e9e13d064fc4066 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * IPv4 Forwarding Information Base: semantics.
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080016#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/bitops.h>
18#include <linux/types.h>
19#include <linux/kernel.h>
20#include <linux/jiffies.h>
21#include <linux/mm.h>
22#include <linux/string.h>
23#include <linux/socket.h>
24#include <linux/sockios.h>
25#include <linux/errno.h>
26#include <linux/in.h>
27#include <linux/inet.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020028#include <linux/inetdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/netdevice.h>
30#include <linux/if_arp.h>
31#include <linux/proc_fs.h>
32#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
David Ahernc3ab2b42017-05-21 10:12:03 -060035#include <linux/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020037#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <net/ip.h>
39#include <net/protocol.h>
40#include <net/route.h>
41#include <net/tcp.h>
42#include <net/sock.h>
43#include <net/ip_fib.h>
Thomas Graff21c7bc2006-08-15 00:34:17 -070044#include <net/netlink.h>
Thomas Graf4e902c52006-08-17 18:14:52 -070045#include <net/nexthop.h>
Roopa Prabhu571e7222015-07-21 10:43:47 +020046#include <net/lwtunnel.h>
Ido Schimmel04b1d4e2017-08-03 13:28:11 +020047#include <net/fib_notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49#include "fib_lookup.h"
50
Stephen Hemminger832b4c52006-08-29 16:48:09 -070051static DEFINE_SPINLOCK(fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052static struct hlist_head *fib_info_hash;
53static struct hlist_head *fib_info_laddrhash;
David S. Miller123b9732011-02-01 15:34:21 -080054static unsigned int fib_info_hash_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055static unsigned int fib_info_cnt;
56
57#define DEVINDEX_HASHBITS 8
58#define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS)
59static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE];
60
61#ifdef CONFIG_IP_ROUTE_MULTIPATH
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Eric Dumazet6a31d2a2010-10-04 20:00:18 +000063#define for_nexthops(fi) { \
64 int nhsel; const struct fib_nh *nh; \
65 for (nhsel = 0, nh = (fi)->fib_nh; \
66 nhsel < (fi)->fib_nhs; \
67 nh++, nhsel++)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Eric Dumazet6a31d2a2010-10-04 20:00:18 +000069#define change_nexthops(fi) { \
70 int nhsel; struct fib_nh *nexthop_nh; \
71 for (nhsel = 0, nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \
72 nhsel < (fi)->fib_nhs; \
73 nexthop_nh++, nhsel++)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75#else /* CONFIG_IP_ROUTE_MULTIPATH */
76
77/* Hope, that gcc will optimize it to get rid of dummy loop */
78
Eric Dumazet6a31d2a2010-10-04 20:00:18 +000079#define for_nexthops(fi) { \
80 int nhsel; const struct fib_nh *nh = (fi)->fib_nh; \
81 for (nhsel = 0; nhsel < 1; nhsel++)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Eric Dumazet6a31d2a2010-10-04 20:00:18 +000083#define change_nexthops(fi) { \
84 int nhsel; \
85 struct fib_nh *nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \
86 for (nhsel = 0; nhsel < 1; nhsel++)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88#endif /* CONFIG_IP_ROUTE_MULTIPATH */
89
90#define endfor_nexthops(fi) }
91
92
David S. Miller3be06862011-03-07 15:01:10 -080093const struct fib_prop fib_props[RTN_MAX + 1] = {
Eric Dumazet6a31d2a2010-10-04 20:00:18 +000094 [RTN_UNSPEC] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 .error = 0,
96 .scope = RT_SCOPE_NOWHERE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +000097 },
98 [RTN_UNICAST] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 .error = 0,
100 .scope = RT_SCOPE_UNIVERSE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000101 },
102 [RTN_LOCAL] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 .error = 0,
104 .scope = RT_SCOPE_HOST,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000105 },
106 [RTN_BROADCAST] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 .error = 0,
108 .scope = RT_SCOPE_LINK,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000109 },
110 [RTN_ANYCAST] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 .error = 0,
112 .scope = RT_SCOPE_LINK,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000113 },
114 [RTN_MULTICAST] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 .error = 0,
116 .scope = RT_SCOPE_UNIVERSE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000117 },
118 [RTN_BLACKHOLE] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 .error = -EINVAL,
120 .scope = RT_SCOPE_UNIVERSE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000121 },
122 [RTN_UNREACHABLE] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 .error = -EHOSTUNREACH,
124 .scope = RT_SCOPE_UNIVERSE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000125 },
126 [RTN_PROHIBIT] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 .error = -EACCES,
128 .scope = RT_SCOPE_UNIVERSE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000129 },
130 [RTN_THROW] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 .error = -EAGAIN,
132 .scope = RT_SCOPE_UNIVERSE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000133 },
134 [RTN_NAT] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 .error = -EINVAL,
136 .scope = RT_SCOPE_NOWHERE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000137 },
138 [RTN_XRESOLVE] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 .error = -EINVAL,
140 .scope = RT_SCOPE_NOWHERE,
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000141 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142};
143
David S. Millerc5038a82012-07-31 15:02:02 -0700144static void rt_fibinfo_free(struct rtable __rcu **rtp)
Eric Dumazet54764bb2012-07-31 01:08:23 +0000145{
146 struct rtable *rt = rcu_dereference_protected(*rtp, 1);
147
148 if (!rt)
149 return;
150
151 /* Not even needed : RCU_INIT_POINTER(*rtp, NULL);
152 * because we waited an RCU grace period before calling
153 * free_fib_info_rcu()
154 */
155
Wei Wang95c47f92017-06-17 10:42:30 -0700156 dst_dev_put(&rt->dst);
Wei Wangb838d5e2017-06-17 10:42:32 -0700157 dst_release_immediate(&rt->dst);
Eric Dumazet54764bb2012-07-31 01:08:23 +0000158}
159
David S. Millerc5038a82012-07-31 15:02:02 -0700160static void free_nh_exceptions(struct fib_nh *nh)
161{
Eric Dumazetcaa41522014-09-03 22:21:56 -0700162 struct fnhe_hash_bucket *hash;
David S. Millerc5038a82012-07-31 15:02:02 -0700163 int i;
164
Eric Dumazetcaa41522014-09-03 22:21:56 -0700165 hash = rcu_dereference_protected(nh->nh_exceptions, 1);
166 if (!hash)
167 return;
David S. Millerc5038a82012-07-31 15:02:02 -0700168 for (i = 0; i < FNHE_HASH_SIZE; i++) {
169 struct fib_nh_exception *fnhe;
170
171 fnhe = rcu_dereference_protected(hash[i].chain, 1);
172 while (fnhe) {
173 struct fib_nh_exception *next;
174
175 next = rcu_dereference_protected(fnhe->fnhe_next, 1);
176
Timo Teräs2ffae992013-06-27 10:27:05 +0300177 rt_fibinfo_free(&fnhe->fnhe_rth_input);
178 rt_fibinfo_free(&fnhe->fnhe_rth_output);
David S. Millerc5038a82012-07-31 15:02:02 -0700179
180 kfree(fnhe);
181
182 fnhe = next;
183 }
184 }
185 kfree(hash);
186}
187
188static void rt_fibinfo_free_cpus(struct rtable __rcu * __percpu *rtp)
Eric Dumazetd26b3a72012-07-31 05:45:30 +0000189{
190 int cpu;
191
192 if (!rtp)
193 return;
194
195 for_each_possible_cpu(cpu) {
196 struct rtable *rt;
197
198 rt = rcu_dereference_protected(*per_cpu_ptr(rtp, cpu), 1);
Wei Wang08301062017-06-17 10:42:29 -0700199 if (rt) {
Wei Wang95c47f92017-06-17 10:42:30 -0700200 dst_dev_put(&rt->dst);
Wei Wangb838d5e2017-06-17 10:42:32 -0700201 dst_release_immediate(&rt->dst);
Wei Wang08301062017-06-17 10:42:29 -0700202 }
Eric Dumazetd26b3a72012-07-31 05:45:30 +0000203 }
204 free_percpu(rtp);
205}
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207/* Release a nexthop info record */
Yan, Zheng19c1ea12011-09-04 20:24:20 +0000208static void free_fib_info_rcu(struct rcu_head *head)
209{
210 struct fib_info *fi = container_of(head, struct fib_info, rcu);
Eric Dumazet3fb07da2017-05-25 14:27:35 -0700211 struct dst_metrics *m;
Yan, Zheng19c1ea12011-09-04 20:24:20 +0000212
Yanmin Zhange49cc0d2012-05-23 15:39:45 +0000213 change_nexthops(fi) {
214 if (nexthop_nh->nh_dev)
215 dev_put(nexthop_nh->nh_dev);
Nicolas Dichtel5a6228a2015-07-24 12:28:36 +0200216 lwtstate_put(nexthop_nh->nh_lwtstate);
Eric Dumazetcaa41522014-09-03 22:21:56 -0700217 free_nh_exceptions(nexthop_nh);
David S. Millerc5038a82012-07-31 15:02:02 -0700218 rt_fibinfo_free_cpus(nexthop_nh->nh_pcpu_rth_output);
219 rt_fibinfo_free(&nexthop_nh->nh_rth_input);
Yanmin Zhange49cc0d2012-05-23 15:39:45 +0000220 } endfor_nexthops(fi);
221
Eric Dumazet3fb07da2017-05-25 14:27:35 -0700222 m = fi->fib_metrics;
Eric Dumazet9620fef2017-08-18 12:08:07 -0700223 if (m != &dst_default_metrics && refcount_dec_and_test(&m->refcnt))
Eric Dumazet3fb07da2017-05-25 14:27:35 -0700224 kfree(m);
Yan, Zheng19c1ea12011-09-04 20:24:20 +0000225 kfree(fi);
226}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228void free_fib_info(struct fib_info *fi)
229{
230 if (fi->fib_dead == 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +0000231 pr_warn("Freeing alive fib_info %p\n", fi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return;
233 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 fib_info_cnt--;
David S. Miller7a9bc9b2012-06-29 01:32:45 -0700235#ifdef CONFIG_IP_ROUTE_CLASSID
236 change_nexthops(fi) {
237 if (nexthop_nh->nh_tclassid)
David S. Millerf4530fa2012-07-05 22:13:13 -0700238 fi->fib_net->ipv4.fib_num_tclassid_users--;
David S. Miller7a9bc9b2012-06-29 01:32:45 -0700239 } endfor_nexthops(fi);
240#endif
Yan, Zheng19c1ea12011-09-04 20:24:20 +0000241 call_rcu(&fi->rcu, free_fib_info_rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242}
Ido Schimmelb423cb12016-12-03 16:44:58 +0100243EXPORT_SYMBOL_GPL(free_fib_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245void fib_release_info(struct fib_info *fi)
246{
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700247 spin_lock_bh(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 if (fi && --fi->fib_treeref == 0) {
249 hlist_del(&fi->fib_hash);
250 if (fi->fib_prefsrc)
251 hlist_del(&fi->fib_lhash);
252 change_nexthops(fi) {
David S. Miller71fceff2010-01-15 01:16:40 -0800253 if (!nexthop_nh->nh_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 continue;
David S. Miller71fceff2010-01-15 01:16:40 -0800255 hlist_del(&nexthop_nh->nh_hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 } endfor_nexthops(fi)
257 fi->fib_dead = 1;
258 fib_info_put(fi);
259 }
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700260 spin_unlock_bh(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261}
262
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000263static inline int nh_comp(const struct fib_info *fi, const struct fib_info *ofi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264{
265 const struct fib_nh *onh = ofi->fib_nh;
266
267 for_nexthops(fi) {
268 if (nh->nh_oif != onh->nh_oif ||
269 nh->nh_gw != onh->nh_gw ||
270 nh->nh_scope != onh->nh_scope ||
271#ifdef CONFIG_IP_ROUTE_MULTIPATH
272 nh->nh_weight != onh->nh_weight ||
273#endif
Patrick McHardyc7066f72011-01-14 13:36:42 +0100274#ifdef CONFIG_IP_ROUTE_CLASSID
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 nh->nh_tclassid != onh->nh_tclassid ||
276#endif
Roopa Prabhu571e7222015-07-21 10:43:47 +0200277 lwtunnel_cmp_encap(nh->nh_lwtstate, onh->nh_lwtstate) ||
Andy Gospodarek8a3d0312015-06-23 13:45:36 -0400278 ((nh->nh_flags ^ onh->nh_flags) & ~RTNH_COMPARE_MASK))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return -1;
280 onh++;
281 } endfor_nexthops(fi);
282 return 0;
283}
284
David S. Miller88ebc722008-01-12 21:49:01 -0800285static inline unsigned int fib_devindex_hashfn(unsigned int val)
286{
287 unsigned int mask = DEVINDEX_HASHSIZE - 1;
288
289 return (val ^
290 (val >> DEVINDEX_HASHBITS) ^
291 (val >> (DEVINDEX_HASHBITS * 2))) & mask;
292}
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294static inline unsigned int fib_info_hashfn(const struct fib_info *fi)
295{
David S. Miller123b9732011-02-01 15:34:21 -0800296 unsigned int mask = (fib_info_hash_size - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 unsigned int val = fi->fib_nhs;
298
David S. Miller37e826c2011-03-24 18:06:47 -0700299 val ^= (fi->fib_protocol << 8) | fi->fib_scope;
Al Viro81f7bf62006-09-27 18:40:00 -0700300 val ^= (__force u32)fi->fib_prefsrc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 val ^= fi->fib_priority;
David S. Miller88ebc722008-01-12 21:49:01 -0800302 for_nexthops(fi) {
303 val ^= fib_devindex_hashfn(nh->nh_oif);
304 } endfor_nexthops(fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 return (val ^ (val >> 7) ^ (val >> 12)) & mask;
307}
308
309static struct fib_info *fib_find_info(const struct fib_info *nfi)
310{
311 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 struct fib_info *fi;
313 unsigned int hash;
314
315 hash = fib_info_hashfn(nfi);
316 head = &fib_info_hash[hash];
317
Sasha Levinb67bfe02013-02-27 17:06:00 -0800318 hlist_for_each_entry(fi, head, fib_hash) {
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800319 if (!net_eq(fi->fib_net, nfi->fib_net))
Denis V. Lunev4814bdb2008-01-31 18:50:07 -0800320 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 if (fi->fib_nhs != nfi->fib_nhs)
322 continue;
323 if (nfi->fib_protocol == fi->fib_protocol &&
David S. Miller37e826c2011-03-24 18:06:47 -0700324 nfi->fib_scope == fi->fib_scope &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 nfi->fib_prefsrc == fi->fib_prefsrc &&
326 nfi->fib_priority == fi->fib_priority &&
Eric Dumazetf4ef85b2012-10-04 01:25:26 +0000327 nfi->fib_type == fi->fib_type &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 memcmp(nfi->fib_metrics, fi->fib_metrics,
Eric Dumazetfcd13f42011-03-24 07:01:24 +0000329 sizeof(u32) * RTAX_MAX) == 0 &&
Andy Gospodarek8a3d0312015-06-23 13:45:36 -0400330 !((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 (nfi->fib_nhs == 0 || nh_comp(fi, nfi) == 0))
332 return fi;
333 }
334
335 return NULL;
336}
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338/* Check, that the gateway is already configured.
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000339 * Used only by redirect accept routine.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 */
Al Virod878e72e2006-09-26 22:18:13 -0700341int ip_fib_check_default(__be32 gw, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 struct fib_nh *nh;
345 unsigned int hash;
346
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700347 spin_lock(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 hash = fib_devindex_hashfn(dev->ifindex);
350 head = &fib_info_devhash[hash];
Sasha Levinb67bfe02013-02-27 17:06:00 -0800351 hlist_for_each_entry(nh, head, nh_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (nh->nh_dev == dev &&
353 nh->nh_gw == gw &&
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000354 !(nh->nh_flags & RTNH_F_DEAD)) {
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700355 spin_unlock(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return 0;
357 }
358 }
359
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700360 spin_unlock(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 return -1;
363}
364
Thomas Graf339bf982006-11-10 14:10:15 -0800365static inline size_t fib_nlmsg_size(struct fib_info *fi)
366{
367 size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg))
368 + nla_total_size(4) /* RTA_TABLE */
369 + nla_total_size(4) /* RTA_DST */
370 + nla_total_size(4) /* RTA_PRIORITY */
Daniel Borkmannea697632015-01-05 23:57:47 +0100371 + nla_total_size(4) /* RTA_PREFSRC */
372 + nla_total_size(TCP_CA_NAME_MAX); /* RTAX_CC_ALGO */
Thomas Graf339bf982006-11-10 14:10:15 -0800373
374 /* space for nested metrics */
375 payload += nla_total_size((RTAX_MAX * nla_total_size(4)));
376
377 if (fi->fib_nhs) {
Roopa Prabhu571e7222015-07-21 10:43:47 +0200378 size_t nh_encapsize = 0;
Thomas Graf339bf982006-11-10 14:10:15 -0800379 /* Also handles the special case fib_nhs == 1 */
380
381 /* each nexthop is packed in an attribute */
382 size_t nhsize = nla_total_size(sizeof(struct rtnexthop));
383
384 /* may contain flow and gateway attribute */
385 nhsize += 2 * nla_total_size(4);
386
Roopa Prabhu571e7222015-07-21 10:43:47 +0200387 /* grab encap info */
388 for_nexthops(fi) {
389 if (nh->nh_lwtstate) {
390 /* RTA_ENCAP_TYPE */
391 nh_encapsize += lwtunnel_get_encap_size(
392 nh->nh_lwtstate);
393 /* RTA_ENCAP */
394 nh_encapsize += nla_total_size(2);
395 }
396 } endfor_nexthops(fi);
397
Thomas Graf339bf982006-11-10 14:10:15 -0800398 /* all nexthops are packed in a nested attribute */
Roopa Prabhu571e7222015-07-21 10:43:47 +0200399 payload += nla_total_size((fi->fib_nhs * nhsize) +
400 nh_encapsize);
401
Thomas Graf339bf982006-11-10 14:10:15 -0800402 }
403
404 return payload;
405}
406
Al Viro81f7bf62006-09-27 18:40:00 -0700407void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
Joe Perches9877b252013-10-17 13:34:11 -0700408 int dst_len, u32 tb_id, const struct nl_info *info,
Milan Kocianb8f55832007-05-23 14:55:06 -0700409 unsigned int nlm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
411 struct sk_buff *skb;
Thomas Graf4e902c52006-08-17 18:14:52 -0700412 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
Thomas Graff21c7bc2006-08-15 00:34:17 -0700413 int err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Thomas Graf339bf982006-11-10 14:10:15 -0800415 skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +0100416 if (!skb)
Thomas Graff21c7bc2006-08-15 00:34:17 -0700417 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Eric W. Biederman15e47302012-09-07 20:12:54 +0000419 err = fib_dump_info(skb, info->portid, seq, event, tb_id,
David S. Miller37e826c2011-03-24 18:06:47 -0700420 fa->fa_type, key, dst_len,
Milan Kocianb8f55832007-05-23 14:55:06 -0700421 fa->fa_tos, fa->fa_info, nlm_flags);
Patrick McHardy26932562007-01-31 23:16:40 -0800422 if (err < 0) {
423 /* -EMSGSIZE implies BUG in fib_nlmsg_size() */
424 WARN_ON(err == -EMSGSIZE);
425 kfree_skb(skb);
426 goto errout;
427 }
Eric W. Biederman15e47302012-09-07 20:12:54 +0000428 rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV4_ROUTE,
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -0800429 info->nlh, GFP_KERNEL);
430 return;
Thomas Graff21c7bc2006-08-15 00:34:17 -0700431errout:
432 if (err < 0)
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800433 rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434}
435
Stephen Hemmingerc9cb6b62013-12-28 11:05:36 -0800436static int fib_detect_death(struct fib_info *fi, int order,
437 struct fib_info **last_resort, int *last_idx,
438 int dflt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
440 struct neighbour *n;
441 int state = NUD_NONE;
442
443 n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
444 if (n) {
445 state = n->nud_state;
446 neigh_release(n);
Julian Anastasov88f64322015-07-23 10:39:35 +0300447 } else {
448 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
Jianjun Kongd93191002008-11-03 00:23:42 -0800450 if (state == NUD_REACHABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return 0;
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000452 if ((state & NUD_VALID) && order != dflt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return 0;
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000454 if ((state & NUD_VALID) ||
Julian Anastasov88f64322015-07-23 10:39:35 +0300455 (*last_idx < 0 && order > dflt && state != NUD_INCOMPLETE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 *last_resort = fi;
457 *last_idx = order;
458 }
459 return 1;
460}
461
462#ifdef CONFIG_IP_ROUTE_MULTIPATH
463
David Ahern6d8422a12017-05-21 10:12:02 -0600464static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining,
465 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 int nhs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Thomas Graf4e902c52006-08-17 18:14:52 -0700469 while (rtnh_ok(rtnh, remaining)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 nhs++;
Thomas Graf4e902c52006-08-17 18:14:52 -0700471 rtnh = rtnh_next(rtnh, &remaining);
472 }
473
474 /* leftover implies invalid nexthop configuration, discard it */
David Ahernc3ab2b42017-05-21 10:12:03 -0600475 if (remaining > 0) {
476 NL_SET_ERR_MSG(extack,
477 "Invalid nexthop configuration - extra data after nexthops");
478 nhs = 0;
479 }
480
481 return nhs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
483
Thomas Graf4e902c52006-08-17 18:14:52 -0700484static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
David Ahern6d8422a12017-05-21 10:12:02 -0600485 int remaining, struct fib_config *cfg,
486 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
Roopa Prabhu571e7222015-07-21 10:43:47 +0200488 int ret;
489
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 change_nexthops(fi) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700491 int attrlen;
492
David Ahernc3ab2b42017-05-21 10:12:03 -0600493 if (!rtnh_ok(rtnh, remaining)) {
494 NL_SET_ERR_MSG(extack,
495 "Invalid nexthop configuration - extra data after nexthop");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return -EINVAL;
David Ahernc3ab2b42017-05-21 10:12:03 -0600497 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700498
David Ahernc3ab2b42017-05-21 10:12:03 -0600499 if (rtnh->rtnh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
500 NL_SET_ERR_MSG(extack,
501 "Invalid flags for nexthop - can not contain DEAD or LINKDOWN");
Julian Anastasov80610222016-07-10 21:11:55 +0300502 return -EINVAL;
David Ahernc3ab2b42017-05-21 10:12:03 -0600503 }
Julian Anastasov80610222016-07-10 21:11:55 +0300504
David S. Miller71fceff2010-01-15 01:16:40 -0800505 nexthop_nh->nh_flags =
506 (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags;
507 nexthop_nh->nh_oif = rtnh->rtnh_ifindex;
508 nexthop_nh->nh_weight = rtnh->rtnh_hops + 1;
Thomas Graf4e902c52006-08-17 18:14:52 -0700509
510 attrlen = rtnh_attrlen(rtnh);
511 if (attrlen > 0) {
512 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
513
514 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
Jiri Benc67b61f62015-03-29 16:59:26 +0200515 nexthop_nh->nh_gw = nla ? nla_get_in_addr(nla) : 0;
Patrick McHardyc7066f72011-01-14 13:36:42 +0100516#ifdef CONFIG_IP_ROUTE_CLASSID
Thomas Graf4e902c52006-08-17 18:14:52 -0700517 nla = nla_find(attrs, attrlen, RTA_FLOW);
David S. Miller71fceff2010-01-15 01:16:40 -0800518 nexthop_nh->nh_tclassid = nla ? nla_get_u32(nla) : 0;
David S. Miller7a9bc9b2012-06-29 01:32:45 -0700519 if (nexthop_nh->nh_tclassid)
David S. Millerf4530fa2012-07-05 22:13:13 -0700520 fi->fib_net->ipv4.fib_num_tclassid_users++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521#endif
Roopa Prabhu571e7222015-07-21 10:43:47 +0200522 nla = nla_find(attrs, attrlen, RTA_ENCAP);
523 if (nla) {
524 struct lwtunnel_state *lwtstate;
Roopa Prabhu571e7222015-07-21 10:43:47 +0200525 struct nlattr *nla_entype;
526
527 nla_entype = nla_find(attrs, attrlen,
528 RTA_ENCAP_TYPE);
David Ahernc3ab2b42017-05-21 10:12:03 -0600529 if (!nla_entype) {
530 NL_SET_BAD_ATTR(extack, nla);
531 NL_SET_ERR_MSG(extack,
532 "Encap type is missing");
Roopa Prabhu571e7222015-07-21 10:43:47 +0200533 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -0600534 }
David Ahern30357d72017-01-30 12:07:37 -0800535
536 ret = lwtunnel_build_state(nla_get_u16(
Roopa Prabhu571e7222015-07-21 10:43:47 +0200537 nla_entype),
Tom Herbert127eb7c2015-08-24 09:45:41 -0700538 nla, AF_INET, cfg,
David Ahern9ae28722017-05-27 16:19:28 -0600539 &lwtstate, extack);
Roopa Prabhu571e7222015-07-21 10:43:47 +0200540 if (ret)
541 goto errout;
Nicolas Dichtel5a6228a2015-07-24 12:28:36 +0200542 nexthop_nh->nh_lwtstate =
543 lwtstate_get(lwtstate);
Roopa Prabhu571e7222015-07-21 10:43:47 +0200544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700546
547 rtnh = rtnh_next(rtnh, &remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 } endfor_nexthops(fi);
Thomas Graf4e902c52006-08-17 18:14:52 -0700549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 return 0;
Roopa Prabhu571e7222015-07-21 10:43:47 +0200551
552err_inval:
553 ret = -EINVAL;
554
555errout:
556 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
558
Peter Nørlund0e884c72015-09-30 10:12:21 +0200559static void fib_rebalance(struct fib_info *fi)
560{
561 int total;
562 int w;
563 struct in_device *in_dev;
564
565 if (fi->fib_nhs < 2)
566 return;
567
568 total = 0;
569 for_nexthops(fi) {
570 if (nh->nh_flags & RTNH_F_DEAD)
571 continue;
572
David Ahern51161aa2015-10-14 16:44:00 -0700573 in_dev = __in_dev_get_rtnl(nh->nh_dev);
Peter Nørlund0e884c72015-09-30 10:12:21 +0200574
575 if (in_dev &&
576 IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
577 nh->nh_flags & RTNH_F_LINKDOWN)
578 continue;
579
580 total += nh->nh_weight;
581 } endfor_nexthops(fi);
582
583 w = 0;
584 change_nexthops(fi) {
585 int upper_bound;
586
David Ahern51161aa2015-10-14 16:44:00 -0700587 in_dev = __in_dev_get_rtnl(nexthop_nh->nh_dev);
Peter Nørlund0e884c72015-09-30 10:12:21 +0200588
589 if (nexthop_nh->nh_flags & RTNH_F_DEAD) {
590 upper_bound = -1;
591 } else if (in_dev &&
592 IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
593 nexthop_nh->nh_flags & RTNH_F_LINKDOWN) {
594 upper_bound = -1;
595 } else {
596 w += nexthop_nh->nh_weight;
Peter Nørlund0a837fe2015-10-06 07:24:47 +0200597 upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31,
598 total) - 1;
Peter Nørlund0e884c72015-09-30 10:12:21 +0200599 }
600
601 atomic_set(&nexthop_nh->nh_upper_bound, upper_bound);
602 } endfor_nexthops(fi);
Peter Nørlund0e884c72015-09-30 10:12:21 +0200603}
Peter Nørlund0e884c72015-09-30 10:12:21 +0200604#else /* CONFIG_IP_ROUTE_MULTIPATH */
605
606#define fib_rebalance(fi) do { } while (0)
Peter Nørlund0e884c72015-09-30 10:12:21 +0200607
608#endif /* CONFIG_IP_ROUTE_MULTIPATH */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
David Ahern30357d72017-01-30 12:07:37 -0800610static int fib_encap_match(u16 encap_type,
Ying Xuee01286e2015-08-19 16:04:51 +0800611 struct nlattr *encap,
David Ahern30357d72017-01-30 12:07:37 -0800612 const struct fib_nh *nh,
David Ahern9ae28722017-05-27 16:19:28 -0600613 const struct fib_config *cfg,
614 struct netlink_ext_ack *extack)
Roopa Prabhu571e7222015-07-21 10:43:47 +0200615{
616 struct lwtunnel_state *lwtstate;
Jiri Bencdf383e62015-08-18 18:41:13 +0200617 int ret, result = 0;
Roopa Prabhu571e7222015-07-21 10:43:47 +0200618
619 if (encap_type == LWTUNNEL_ENCAP_NONE)
620 return 0;
621
David Ahern9ae28722017-05-27 16:19:28 -0600622 ret = lwtunnel_build_state(encap_type, encap, AF_INET,
623 cfg, &lwtstate, extack);
Jiri Bencdf383e62015-08-18 18:41:13 +0200624 if (!ret) {
625 result = lwtunnel_cmp_encap(lwtstate, nh->nh_lwtstate);
626 lwtstate_free(lwtstate);
627 }
Roopa Prabhu571e7222015-07-21 10:43:47 +0200628
Jiri Bencdf383e62015-08-18 18:41:13 +0200629 return result;
Roopa Prabhu571e7222015-07-21 10:43:47 +0200630}
631
David Ahern9ae28722017-05-27 16:19:28 -0600632int fib_nh_match(struct fib_config *cfg, struct fib_info *fi,
633 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
635#ifdef CONFIG_IP_ROUTE_MULTIPATH
Thomas Graf4e902c52006-08-17 18:14:52 -0700636 struct rtnexthop *rtnh;
637 int remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638#endif
639
Thomas Graf4e902c52006-08-17 18:14:52 -0700640 if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 return 1;
642
Thomas Graf4e902c52006-08-17 18:14:52 -0700643 if (cfg->fc_oif || cfg->fc_gw) {
Roopa Prabhu571e7222015-07-21 10:43:47 +0200644 if (cfg->fc_encap) {
David Ahern9ae28722017-05-27 16:19:28 -0600645 if (fib_encap_match(cfg->fc_encap_type, cfg->fc_encap,
646 fi->fib_nh, cfg, extack))
647 return 1;
Roopa Prabhu571e7222015-07-21 10:43:47 +0200648 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700649 if ((!cfg->fc_oif || cfg->fc_oif == fi->fib_nh->nh_oif) &&
650 (!cfg->fc_gw || cfg->fc_gw == fi->fib_nh->nh_gw))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 return 0;
652 return 1;
653 }
654
655#ifdef CONFIG_IP_ROUTE_MULTIPATH
Ian Morris51456b22015-04-03 09:17:26 +0100656 if (!cfg->fc_mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 return 0;
Thomas Graf4e902c52006-08-17 18:14:52 -0700658
659 rtnh = cfg->fc_mp;
660 remaining = cfg->fc_mp_len;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 for_nexthops(fi) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700663 int attrlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Thomas Graf4e902c52006-08-17 18:14:52 -0700665 if (!rtnh_ok(rtnh, remaining))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 return -EINVAL;
Thomas Graf4e902c52006-08-17 18:14:52 -0700667
668 if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->nh_oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return 1;
Thomas Graf4e902c52006-08-17 18:14:52 -0700670
671 attrlen = rtnh_attrlen(rtnh);
Jiri Pirkof76936d2014-10-13 16:34:10 +0200672 if (attrlen > 0) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700673 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
674
675 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
Jiri Benc67b61f62015-03-29 16:59:26 +0200676 if (nla && nla_get_in_addr(nla) != nh->nh_gw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 return 1;
Patrick McHardyc7066f72011-01-14 13:36:42 +0100678#ifdef CONFIG_IP_ROUTE_CLASSID
Thomas Graf4e902c52006-08-17 18:14:52 -0700679 nla = nla_find(attrs, attrlen, RTA_FLOW);
680 if (nla && nla_get_u32(nla) != nh->nh_tclassid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 return 1;
682#endif
683 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700684
685 rtnh = rtnh_next(rtnh, &remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 } endfor_nexthops(fi);
687#endif
688 return 0;
689}
690
Xin Long5f9ae3d2017-08-23 10:07:26 +0800691bool fib_metrics_match(struct fib_config *cfg, struct fib_info *fi)
692{
693 struct nlattr *nla;
694 int remaining;
695
696 if (!cfg->fc_mx)
697 return true;
698
699 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
700 int type = nla_type(nla);
701 u32 val;
702
703 if (!type)
704 continue;
705 if (type > RTAX_MAX)
706 return false;
707
708 if (type == RTAX_CC_ALGO) {
709 char tmp[TCP_CA_NAME_MAX];
710 bool ecn_ca = false;
711
712 nla_strlcpy(tmp, nla, sizeof(tmp));
713 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
714 } else {
715 val = nla_get_u32(nla);
716 }
717
718 if (fi->fib_metrics->metrics[type - 1] != val)
719 return false;
720 }
721
722 return true;
723}
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726/*
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000727 * Picture
728 * -------
729 *
730 * Semantics of nexthop is very messy by historical reasons.
731 * We have to take into account, that:
732 * a) gateway can be actually local interface address,
733 * so that gatewayed route is direct.
734 * b) gateway must be on-link address, possibly
735 * described not by an ifaddr, but also by a direct route.
736 * c) If both gateway and interface are specified, they should not
737 * contradict.
738 * d) If we use tunnel routes, gateway could be not on-link.
739 *
740 * Attempt to reconcile all of these (alas, self-contradictory) conditions
741 * results in pretty ugly and hairy code with obscure logic.
742 *
743 * I chose to generalized it instead, so that the size
744 * of code does not increase practically, but it becomes
745 * much more general.
746 * Every prefix is assigned a "scope" value: "host" is local address,
747 * "link" is direct route,
748 * [ ... "site" ... "interior" ... ]
749 * and "universe" is true gateway route with global meaning.
750 *
751 * Every prefix refers to a set of "nexthop"s (gw, oif),
752 * where gw must have narrower scope. This recursion stops
753 * when gw has LOCAL scope or if "nexthop" is declared ONLINK,
754 * which means that gw is forced to be on link.
755 *
756 * Code is still hairy, but now it is apparently logically
757 * consistent and very flexible. F.e. as by-product it allows
758 * to co-exists in peace independent exterior and interior
759 * routing processes.
760 *
761 * Normally it looks as following.
762 *
763 * {universe prefix} -> (gw, oif) [scope link]
764 * |
765 * |-> {link prefix} -> (gw, oif) [scope local]
766 * |
767 * |-> {local prefix} (terminal node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 */
David Ahernfa8fefa2017-09-27 20:41:59 -0700769static int fib_check_nh(struct fib_config *cfg, struct fib_nh *nh,
770 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771{
Tom Herbert127eb7c2015-08-24 09:45:41 -0700772 int err = 0;
Denis V. Lunev86167a32008-01-21 17:34:00 -0800773 struct net *net;
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000774 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Denis V. Lunev86167a32008-01-21 17:34:00 -0800776 net = cfg->fc_nlinfo.nl_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 if (nh->nh_gw) {
778 struct fib_result res;
779
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000780 if (nh->nh_flags & RTNH_F_ONLINK) {
David Ahern30bbaa12015-08-13 14:59:05 -0600781 unsigned int addr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
David Ahernc3ab2b42017-05-21 10:12:03 -0600783 if (cfg->fc_scope >= RT_SCOPE_LINK) {
784 NL_SET_ERR_MSG(extack,
785 "Nexthop has invalid scope");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 return -EINVAL;
David Ahernc3ab2b42017-05-21 10:12:03 -0600787 }
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000788 dev = __dev_get_by_index(net, nh->nh_oif);
789 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 return -ENODEV;
David Ahernc3ab2b42017-05-21 10:12:03 -0600791 if (!(dev->flags & IFF_UP)) {
792 NL_SET_ERR_MSG(extack,
793 "Nexthop device is not up");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 return -ENETDOWN;
David Ahernc3ab2b42017-05-21 10:12:03 -0600795 }
David Ahern30bbaa12015-08-13 14:59:05 -0600796 addr_type = inet_addr_type_dev_table(net, dev, nh->nh_gw);
David Ahernc3ab2b42017-05-21 10:12:03 -0600797 if (addr_type != RTN_UNICAST) {
798 NL_SET_ERR_MSG(extack,
799 "Nexthop has invalid gateway");
David Ahern30bbaa12015-08-13 14:59:05 -0600800 return -EINVAL;
David Ahernc3ab2b42017-05-21 10:12:03 -0600801 }
Andy Gospodarek8a3d0312015-06-23 13:45:36 -0400802 if (!netif_carrier_ok(dev))
803 nh->nh_flags |= RTNH_F_LINKDOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 nh->nh_dev = dev;
805 dev_hold(dev);
806 nh->nh_scope = RT_SCOPE_LINK;
807 return 0;
808 }
Eric Dumazetebc0ffa2010-10-05 10:41:36 +0000809 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 {
David Ahern3bfd8472015-08-13 14:59:07 -0600811 struct fib_table *tbl = NULL;
David S. Miller9ade2282011-03-12 02:02:42 -0500812 struct flowi4 fl4 = {
813 .daddr = nh->nh_gw,
814 .flowi4_scope = cfg->fc_scope + 1,
815 .flowi4_oif = nh->nh_oif,
Cong Wang6a662712014-04-15 16:25:34 -0700816 .flowi4_iif = LOOPBACK_IFINDEX,
Thomas Graf4e902c52006-08-17 18:14:52 -0700817 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
819 /* It is not necessary, but requires a bit of thinking */
David S. Miller9ade2282011-03-12 02:02:42 -0500820 if (fl4.flowi4_scope < RT_SCOPE_LINK)
821 fl4.flowi4_scope = RT_SCOPE_LINK;
David Ahern3bfd8472015-08-13 14:59:07 -0600822
823 if (cfg->fc_table)
824 tbl = fib_get_table(net, cfg->fc_table);
825
826 if (tbl)
827 err = fib_table_lookup(tbl, &fl4, &res,
Eric Dumazet1e313672015-08-15 10:54:07 -0700828 FIB_LOOKUP_IGNORE_LINKSTATE |
829 FIB_LOOKUP_NOREF);
David Ahern4c9bcd12015-08-19 11:40:31 -0700830
831 /* on error or if no table given do full lookup. This
832 * is needed for example when nexthops are in the local
833 * table rather than the given table
834 */
835 if (!tbl || err) {
David Ahern3bfd8472015-08-13 14:59:07 -0600836 err = fib_lookup(net, &fl4, &res,
837 FIB_LOOKUP_IGNORE_LINKSTATE);
David Ahern4c9bcd12015-08-19 11:40:31 -0700838 }
839
Eric Dumazetebc0ffa2010-10-05 10:41:36 +0000840 if (err) {
David Ahernc3ab2b42017-05-21 10:12:03 -0600841 NL_SET_ERR_MSG(extack,
842 "Nexthop has invalid gateway");
Eric Dumazetebc0ffa2010-10-05 10:41:36 +0000843 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 return err;
Eric Dumazetebc0ffa2010-10-05 10:41:36 +0000845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 }
847 err = -EINVAL;
David Ahernc3ab2b42017-05-21 10:12:03 -0600848 if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) {
849 NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 goto out;
David Ahernc3ab2b42017-05-21 10:12:03 -0600851 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 nh->nh_scope = res.scope;
853 nh->nh_oif = FIB_RES_OIF(res);
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000854 nh->nh_dev = dev = FIB_RES_DEV(res);
David Ahernc3ab2b42017-05-21 10:12:03 -0600855 if (!dev) {
856 NL_SET_ERR_MSG(extack,
857 "No egress device for nexthop gateway");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 goto out;
David Ahernc3ab2b42017-05-21 10:12:03 -0600859 }
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000860 dev_hold(dev);
Andy Gospodarek8a3d0312015-06-23 13:45:36 -0400861 if (!netif_carrier_ok(dev))
862 nh->nh_flags |= RTNH_F_LINKDOWN;
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000863 err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 } else {
865 struct in_device *in_dev;
866
David Ahernc3ab2b42017-05-21 10:12:03 -0600867 if (nh->nh_flags & (RTNH_F_PERVASIVE | RTNH_F_ONLINK)) {
868 NL_SET_ERR_MSG(extack,
869 "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return -EINVAL;
David Ahernc3ab2b42017-05-21 10:12:03 -0600871 }
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000872 rcu_read_lock();
873 err = -ENODEV;
Denis V. Lunev86167a32008-01-21 17:34:00 -0800874 in_dev = inetdev_by_index(net, nh->nh_oif);
Ian Morris51456b22015-04-03 09:17:26 +0100875 if (!in_dev)
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000876 goto out;
877 err = -ENETDOWN;
David Ahernc3ab2b42017-05-21 10:12:03 -0600878 if (!(in_dev->dev->flags & IFF_UP)) {
879 NL_SET_ERR_MSG(extack, "Device for nexthop is not up");
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000880 goto out;
David Ahernc3ab2b42017-05-21 10:12:03 -0600881 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 nh->nh_dev = in_dev->dev;
883 dev_hold(nh->nh_dev);
884 nh->nh_scope = RT_SCOPE_HOST;
Andy Gospodarek8a3d0312015-06-23 13:45:36 -0400885 if (!netif_carrier_ok(nh->nh_dev))
886 nh->nh_flags |= RTNH_F_LINKDOWN;
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000887 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 }
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000889out:
890 rcu_read_unlock();
891 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892}
893
Al Viro81f7bf62006-09-27 18:40:00 -0700894static inline unsigned int fib_laddr_hashfn(__be32 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895{
David S. Miller123b9732011-02-01 15:34:21 -0800896 unsigned int mask = (fib_info_hash_size - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000898 return ((__force u32)val ^
899 ((__force u32)val >> 7) ^
900 ((__force u32)val >> 14)) & mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901}
902
David S. Miller123b9732011-02-01 15:34:21 -0800903static struct hlist_head *fib_info_hash_alloc(int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904{
905 if (bytes <= PAGE_SIZE)
Joonwoo Park88f83492007-11-26 23:29:32 +0800906 return kzalloc(bytes, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 else
908 return (struct hlist_head *)
Eric Dumazet6a31d2a2010-10-04 20:00:18 +0000909 __get_free_pages(GFP_KERNEL | __GFP_ZERO,
910 get_order(bytes));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911}
912
David S. Miller123b9732011-02-01 15:34:21 -0800913static void fib_info_hash_free(struct hlist_head *hash, int bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
915 if (!hash)
916 return;
917
918 if (bytes <= PAGE_SIZE)
919 kfree(hash);
920 else
921 free_pages((unsigned long) hash, get_order(bytes));
922}
923
David S. Miller123b9732011-02-01 15:34:21 -0800924static void fib_info_hash_move(struct hlist_head *new_info_hash,
925 struct hlist_head *new_laddrhash,
926 unsigned int new_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
David S. Millerb7656e72005-08-05 04:12:48 -0700928 struct hlist_head *old_info_hash, *old_laddrhash;
David S. Miller123b9732011-02-01 15:34:21 -0800929 unsigned int old_size = fib_info_hash_size;
David S. Millerb7656e72005-08-05 04:12:48 -0700930 unsigned int i, bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700932 spin_lock_bh(&fib_info_lock);
David S. Millerb7656e72005-08-05 04:12:48 -0700933 old_info_hash = fib_info_hash;
934 old_laddrhash = fib_info_laddrhash;
David S. Miller123b9732011-02-01 15:34:21 -0800935 fib_info_hash_size = new_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 for (i = 0; i < old_size; i++) {
938 struct hlist_head *head = &fib_info_hash[i];
Sasha Levinb67bfe02013-02-27 17:06:00 -0800939 struct hlist_node *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 struct fib_info *fi;
941
Sasha Levinb67bfe02013-02-27 17:06:00 -0800942 hlist_for_each_entry_safe(fi, n, head, fib_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 struct hlist_head *dest;
944 unsigned int new_hash;
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 new_hash = fib_info_hashfn(fi);
947 dest = &new_info_hash[new_hash];
948 hlist_add_head(&fi->fib_hash, dest);
949 }
950 }
951 fib_info_hash = new_info_hash;
952
953 for (i = 0; i < old_size; i++) {
954 struct hlist_head *lhead = &fib_info_laddrhash[i];
Sasha Levinb67bfe02013-02-27 17:06:00 -0800955 struct hlist_node *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 struct fib_info *fi;
957
Sasha Levinb67bfe02013-02-27 17:06:00 -0800958 hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 struct hlist_head *ldest;
960 unsigned int new_hash;
961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 new_hash = fib_laddr_hashfn(fi->fib_prefsrc);
963 ldest = &new_laddrhash[new_hash];
964 hlist_add_head(&fi->fib_lhash, ldest);
965 }
966 }
967 fib_info_laddrhash = new_laddrhash;
968
Stephen Hemminger832b4c52006-08-29 16:48:09 -0700969 spin_unlock_bh(&fib_info_lock);
David S. Millerb7656e72005-08-05 04:12:48 -0700970
971 bytes = old_size * sizeof(struct hlist_head *);
David S. Miller123b9732011-02-01 15:34:21 -0800972 fib_info_hash_free(old_info_hash, bytes);
973 fib_info_hash_free(old_laddrhash, bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974}
975
David S. Miller436c3b62011-03-24 17:42:21 -0700976__be32 fib_info_update_nh_saddr(struct net *net, struct fib_nh *nh)
977{
978 nh->nh_saddr = inet_select_addr(nh->nh_dev,
979 nh->nh_gw,
David S. Miller37e826c2011-03-24 18:06:47 -0700980 nh->nh_parent->fib_scope);
David S. Miller436c3b62011-03-24 17:42:21 -0700981 nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid);
982
983 return nh->nh_saddr;
984}
985
David Ahern021dd3b2015-08-13 14:59:06 -0600986static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc)
987{
988 if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst ||
989 fib_prefsrc != cfg->fc_dst) {
David Ahern9b8ff512015-09-01 14:26:35 -0600990 u32 tb_id = cfg->fc_table;
David Aherne1b8d902015-11-03 15:59:28 -0800991 int rc;
David Ahern021dd3b2015-08-13 14:59:06 -0600992
993 if (tb_id == RT_TABLE_MAIN)
994 tb_id = RT_TABLE_LOCAL;
995
David Aherne1b8d902015-11-03 15:59:28 -0800996 rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
997 fib_prefsrc, tb_id);
998
999 if (rc != RTN_LOCAL && tb_id != RT_TABLE_LOCAL) {
1000 rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1001 fib_prefsrc, RT_TABLE_LOCAL);
David Ahern021dd3b2015-08-13 14:59:06 -06001002 }
David Aherne1b8d902015-11-03 15:59:28 -08001003
1004 if (rc != RTN_LOCAL)
1005 return false;
David Ahern021dd3b2015-08-13 14:59:06 -06001006 }
1007 return true;
1008}
1009
Florian Westphal6cf9dfd2015-08-31 15:58:44 +02001010static int
1011fib_convert_metrics(struct fib_info *fi, const struct fib_config *cfg)
1012{
Daniel Borkmannc3a8d942015-08-31 15:58:47 +02001013 bool ecn_ca = false;
Florian Westphal6cf9dfd2015-08-31 15:58:44 +02001014 struct nlattr *nla;
1015 int remaining;
1016
1017 if (!cfg->fc_mx)
1018 return 0;
1019
1020 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1021 int type = nla_type(nla);
1022 u32 val;
1023
1024 if (!type)
1025 continue;
1026 if (type > RTAX_MAX)
1027 return -EINVAL;
1028
1029 if (type == RTAX_CC_ALGO) {
1030 char tmp[TCP_CA_NAME_MAX];
1031
1032 nla_strlcpy(tmp, nla, sizeof(tmp));
Daniel Borkmannc3a8d942015-08-31 15:58:47 +02001033 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
Florian Westphal6cf9dfd2015-08-31 15:58:44 +02001034 if (val == TCP_CA_UNSPEC)
1035 return -EINVAL;
1036 } else {
1037 val = nla_get_u32(nla);
1038 }
1039 if (type == RTAX_ADVMSS && val > 65535 - 40)
1040 val = 65535 - 40;
1041 if (type == RTAX_MTU && val > 65535 - 15)
1042 val = 65535 - 15;
Paolo Abeni626abd52016-05-13 18:33:41 +02001043 if (type == RTAX_HOPLIMIT && val > 255)
1044 val = 255;
Daniel Borkmannb8d3e412015-08-31 15:58:46 +02001045 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1046 return -EINVAL;
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001047 fi->fib_metrics->metrics[type - 1] = val;
Florian Westphal6cf9dfd2015-08-31 15:58:44 +02001048 }
1049
Daniel Borkmannc3a8d942015-08-31 15:58:47 +02001050 if (ecn_ca)
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001051 fi->fib_metrics->metrics[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
Daniel Borkmannc3a8d942015-08-31 15:58:47 +02001052
Florian Westphal6cf9dfd2015-08-31 15:58:44 +02001053 return 0;
1054}
1055
David Ahern6d8422a12017-05-21 10:12:02 -06001056struct fib_info *fib_create_info(struct fib_config *cfg,
1057 struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
1059 int err;
1060 struct fib_info *fi = NULL;
1061 struct fib_info *ofi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 int nhs = 1;
Denis V. Lunev7462bd742008-01-31 18:49:32 -08001063 struct net *net = cfg->fc_nlinfo.nl_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
David S. Miller4c8237c2011-03-07 14:27:38 -08001065 if (cfg->fc_type > RTN_MAX)
1066 goto err_inval;
1067
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 /* Fast check to catch the most weird cases */
David Ahernc3ab2b42017-05-21 10:12:03 -06001069 if (fib_props[cfg->fc_type].scope > cfg->fc_scope) {
1070 NL_SET_ERR_MSG(extack, "Invalid scope");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001072 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
David Ahernc3ab2b42017-05-21 10:12:03 -06001074 if (cfg->fc_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
1075 NL_SET_ERR_MSG(extack,
1076 "Invalid rtm_flags - can not contain DEAD or LINKDOWN");
Julian Anastasov80610222016-07-10 21:11:55 +03001077 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001078 }
Julian Anastasov80610222016-07-10 21:11:55 +03001079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080#ifdef CONFIG_IP_ROUTE_MULTIPATH
Thomas Graf4e902c52006-08-17 18:14:52 -07001081 if (cfg->fc_mp) {
David Ahern6d8422a12017-05-21 10:12:02 -06001082 nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 if (nhs == 0)
1084 goto err_inval;
1085 }
1086#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
1088 err = -ENOBUFS;
David S. Miller123b9732011-02-01 15:34:21 -08001089 if (fib_info_cnt >= fib_info_hash_size) {
1090 unsigned int new_size = fib_info_hash_size << 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 struct hlist_head *new_info_hash;
1092 struct hlist_head *new_laddrhash;
1093 unsigned int bytes;
1094
1095 if (!new_size)
Eric Dumazetd94ce9b2012-10-21 20:12:09 +00001096 new_size = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 bytes = new_size * sizeof(struct hlist_head *);
David S. Miller123b9732011-02-01 15:34:21 -08001098 new_info_hash = fib_info_hash_alloc(bytes);
1099 new_laddrhash = fib_info_hash_alloc(bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 if (!new_info_hash || !new_laddrhash) {
David S. Miller123b9732011-02-01 15:34:21 -08001101 fib_info_hash_free(new_info_hash, bytes);
1102 fib_info_hash_free(new_laddrhash, bytes);
Joonwoo Park88f83492007-11-26 23:29:32 +08001103 } else
David S. Miller123b9732011-02-01 15:34:21 -08001104 fib_info_hash_move(new_info_hash, new_laddrhash, new_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
David S. Miller123b9732011-02-01 15:34:21 -08001106 if (!fib_info_hash_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 goto failure;
1108 }
1109
Panagiotis Issaris0da974f2006-07-21 14:51:30 -07001110 fi = kzalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +01001111 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 goto failure;
David S. Miller725d1e12011-01-28 14:05:05 -08001113 if (cfg->fc_mx) {
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001114 fi->fib_metrics = kzalloc(sizeof(*fi->fib_metrics), GFP_KERNEL);
Eric Dumazet187e5b32017-08-15 05:26:17 -07001115 if (unlikely(!fi->fib_metrics)) {
1116 kfree(fi);
1117 return ERR_PTR(err);
1118 }
Eric Dumazet9620fef2017-08-18 12:08:07 -07001119 refcount_set(&fi->fib_metrics->refcnt, 1);
Eric Dumazet187e5b32017-08-15 05:26:17 -07001120 } else {
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001121 fi->fib_metrics = (struct dst_metrics *)&dst_default_metrics;
Eric Dumazet187e5b32017-08-15 05:26:17 -07001122 }
1123 fib_info_cnt++;
Eric W. Biedermanefd7ef12015-03-11 23:04:08 -05001124 fi->fib_net = net;
Thomas Graf4e902c52006-08-17 18:14:52 -07001125 fi->fib_protocol = cfg->fc_protocol;
David S. Miller37e826c2011-03-24 18:06:47 -07001126 fi->fib_scope = cfg->fc_scope;
Thomas Graf4e902c52006-08-17 18:14:52 -07001127 fi->fib_flags = cfg->fc_flags;
1128 fi->fib_priority = cfg->fc_priority;
1129 fi->fib_prefsrc = cfg->fc_prefsrc;
Eric Dumazetf4ef85b2012-10-04 01:25:26 +00001130 fi->fib_type = cfg->fc_type;
Mark Tomlinson5a56a0b2016-09-05 10:20:20 +12001131 fi->fib_tb_id = cfg->fc_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
1133 fi->fib_nhs = nhs;
1134 change_nexthops(fi) {
David S. Miller71fceff2010-01-15 01:16:40 -08001135 nexthop_nh->nh_parent = fi;
Eric Dumazetd26b3a72012-07-31 05:45:30 +00001136 nexthop_nh->nh_pcpu_rth_output = alloc_percpu(struct rtable __rcu *);
Julian Anastasovf8a17172012-10-08 11:41:17 +00001137 if (!nexthop_nh->nh_pcpu_rth_output)
1138 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 } endfor_nexthops(fi)
1140
Florian Westphal6cf9dfd2015-08-31 15:58:44 +02001141 err = fib_convert_metrics(fi, cfg);
1142 if (err)
1143 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Thomas Graf4e902c52006-08-17 18:14:52 -07001145 if (cfg->fc_mp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146#ifdef CONFIG_IP_ROUTE_MULTIPATH
David Ahern6d8422a12017-05-21 10:12:02 -06001147 err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg, extack);
Thomas Graf4e902c52006-08-17 18:14:52 -07001148 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 goto failure;
David Ahernc3ab2b42017-05-21 10:12:03 -06001150 if (cfg->fc_oif && fi->fib_nh->nh_oif != cfg->fc_oif) {
1151 NL_SET_ERR_MSG(extack,
1152 "Nexthop device index does not match RTA_OIF");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001154 }
1155 if (cfg->fc_gw && fi->fib_nh->nh_gw != cfg->fc_gw) {
1156 NL_SET_ERR_MSG(extack,
1157 "Nexthop gateway does not match RTA_GATEWAY");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001159 }
Patrick McHardyc7066f72011-01-14 13:36:42 +01001160#ifdef CONFIG_IP_ROUTE_CLASSID
David Ahernc3ab2b42017-05-21 10:12:03 -06001161 if (cfg->fc_flow && fi->fib_nh->nh_tclassid != cfg->fc_flow) {
1162 NL_SET_ERR_MSG(extack,
1163 "Nexthop class id does not match RTA_FLOW");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001165 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166#endif
1167#else
David Ahernc3ab2b42017-05-21 10:12:03 -06001168 NL_SET_ERR_MSG(extack,
1169 "Multipath support not enabled in kernel");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 goto err_inval;
1171#endif
1172 } else {
1173 struct fib_nh *nh = fi->fib_nh;
Thomas Graf4e902c52006-08-17 18:14:52 -07001174
Roopa Prabhu571e7222015-07-21 10:43:47 +02001175 if (cfg->fc_encap) {
1176 struct lwtunnel_state *lwtstate;
Roopa Prabhu571e7222015-07-21 10:43:47 +02001177
David Ahernc3ab2b42017-05-21 10:12:03 -06001178 if (cfg->fc_encap_type == LWTUNNEL_ENCAP_NONE) {
1179 NL_SET_ERR_MSG(extack,
1180 "LWT encap type not specified");
Roopa Prabhu571e7222015-07-21 10:43:47 +02001181 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001182 }
David Ahern30357d72017-01-30 12:07:37 -08001183 err = lwtunnel_build_state(cfg->fc_encap_type,
Tom Herbert127eb7c2015-08-24 09:45:41 -07001184 cfg->fc_encap, AF_INET, cfg,
David Ahern9ae28722017-05-27 16:19:28 -06001185 &lwtstate, extack);
Roopa Prabhu571e7222015-07-21 10:43:47 +02001186 if (err)
1187 goto failure;
1188
Nicolas Dichtel5a6228a2015-07-24 12:28:36 +02001189 nh->nh_lwtstate = lwtstate_get(lwtstate);
Roopa Prabhu571e7222015-07-21 10:43:47 +02001190 }
Thomas Graf4e902c52006-08-17 18:14:52 -07001191 nh->nh_oif = cfg->fc_oif;
1192 nh->nh_gw = cfg->fc_gw;
1193 nh->nh_flags = cfg->fc_flags;
Patrick McHardyc7066f72011-01-14 13:36:42 +01001194#ifdef CONFIG_IP_ROUTE_CLASSID
Thomas Graf4e902c52006-08-17 18:14:52 -07001195 nh->nh_tclassid = cfg->fc_flow;
David S. Miller7a9bc9b2012-06-29 01:32:45 -07001196 if (nh->nh_tclassid)
David S. Millerf4530fa2012-07-05 22:13:13 -07001197 fi->fib_net->ipv4.fib_num_tclassid_users++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199#ifdef CONFIG_IP_ROUTE_MULTIPATH
1200 nh->nh_weight = 1;
1201#endif
1202 }
1203
Thomas Graf4e902c52006-08-17 18:14:52 -07001204 if (fib_props[cfg->fc_type].error) {
David Ahernc3ab2b42017-05-21 10:12:03 -06001205 if (cfg->fc_gw || cfg->fc_oif || cfg->fc_mp) {
1206 NL_SET_ERR_MSG(extack,
1207 "Gateway, device and multipath can not be specified for this route type");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 goto link_it;
David S. Miller4c8237c2011-03-07 14:27:38 -08001211 } else {
1212 switch (cfg->fc_type) {
1213 case RTN_UNICAST:
1214 case RTN_LOCAL:
1215 case RTN_BROADCAST:
1216 case RTN_ANYCAST:
1217 case RTN_MULTICAST:
1218 break;
1219 default:
David Ahernc3ab2b42017-05-21 10:12:03 -06001220 NL_SET_ERR_MSG(extack, "Invalid route type");
David S. Miller4c8237c2011-03-07 14:27:38 -08001221 goto err_inval;
1222 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 }
1224
David Ahernc3ab2b42017-05-21 10:12:03 -06001225 if (cfg->fc_scope > RT_SCOPE_HOST) {
1226 NL_SET_ERR_MSG(extack, "Invalid scope");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
Thomas Graf4e902c52006-08-17 18:14:52 -07001230 if (cfg->fc_scope == RT_SCOPE_HOST) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 struct fib_nh *nh = fi->fib_nh;
1232
1233 /* Local address is added. */
David Ahernc3ab2b42017-05-21 10:12:03 -06001234 if (nhs != 1) {
1235 NL_SET_ERR_MSG(extack,
1236 "Route with host scope can not have multiple nexthops");
David Ahern6d8422a12017-05-21 10:12:02 -06001237 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001238 }
1239 if (nh->nh_gw) {
1240 NL_SET_ERR_MSG(extack,
1241 "Route with host scope can not have a gateway");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001243 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 nh->nh_scope = RT_SCOPE_NOWHERE;
Denis V. Lunev7462bd742008-01-31 18:49:32 -08001245 nh->nh_dev = dev_get_by_index(net, fi->fib_nh->nh_oif);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 err = -ENODEV;
Ian Morris51456b22015-04-03 09:17:26 +01001247 if (!nh->nh_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 goto failure;
1249 } else {
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001250 int linkdown = 0;
1251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 change_nexthops(fi) {
David Ahernfa8fefa2017-09-27 20:41:59 -07001253 err = fib_check_nh(cfg, nexthop_nh, extack);
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001254 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 goto failure;
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001256 if (nexthop_nh->nh_flags & RTNH_F_LINKDOWN)
1257 linkdown++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 } endfor_nexthops(fi)
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001259 if (linkdown == fi->fib_nhs)
1260 fi->fib_flags |= RTNH_F_LINKDOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 }
1262
David Ahernc3ab2b42017-05-21 10:12:03 -06001263 if (fi->fib_prefsrc && !fib_valid_prefsrc(cfg, fi->fib_prefsrc)) {
1264 NL_SET_ERR_MSG(extack, "Invalid prefsrc address");
David Ahern021dd3b2015-08-13 14:59:06 -06001265 goto err_inval;
David Ahernc3ab2b42017-05-21 10:12:03 -06001266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
David S. Miller1fc050a2011-03-07 20:54:48 -08001268 change_nexthops(fi) {
David S. Miller436c3b62011-03-24 17:42:21 -07001269 fib_info_update_nh_saddr(net, nexthop_nh);
David S. Miller1fc050a2011-03-07 20:54:48 -08001270 } endfor_nexthops(fi)
1271
Peter Nørlund0e884c72015-09-30 10:12:21 +02001272 fib_rebalance(fi);
1273
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274link_it:
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001275 ofi = fib_find_info(fi);
1276 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 fi->fib_dead = 1;
1278 free_fib_info(fi);
1279 ofi->fib_treeref++;
1280 return ofi;
1281 }
1282
1283 fi->fib_treeref++;
Reshetova, Elena0029c0d2017-07-04 09:35:02 +03001284 refcount_set(&fi->fib_clntref, 1);
Stephen Hemminger832b4c52006-08-29 16:48:09 -07001285 spin_lock_bh(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 hlist_add_head(&fi->fib_hash,
1287 &fib_info_hash[fib_info_hashfn(fi)]);
1288 if (fi->fib_prefsrc) {
1289 struct hlist_head *head;
1290
1291 head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)];
1292 hlist_add_head(&fi->fib_lhash, head);
1293 }
1294 change_nexthops(fi) {
1295 struct hlist_head *head;
1296 unsigned int hash;
1297
David S. Miller71fceff2010-01-15 01:16:40 -08001298 if (!nexthop_nh->nh_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 continue;
David S. Miller71fceff2010-01-15 01:16:40 -08001300 hash = fib_devindex_hashfn(nexthop_nh->nh_dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 head = &fib_info_devhash[hash];
David S. Miller71fceff2010-01-15 01:16:40 -08001302 hlist_add_head(&nexthop_nh->nh_hash, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 } endfor_nexthops(fi)
Stephen Hemminger832b4c52006-08-29 16:48:09 -07001304 spin_unlock_bh(&fib_info_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 return fi;
1306
1307err_inval:
1308 err = -EINVAL;
1309
1310failure:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001311 if (fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 fi->fib_dead = 1;
1313 free_fib_info(fi);
1314 }
Thomas Graf4e902c52006-08-17 18:14:52 -07001315
1316 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317}
1318
Eric W. Biederman15e47302012-09-07 20:12:54 +00001319int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
David S. Miller37e826c2011-03-24 18:06:47 -07001320 u32 tb_id, u8 type, __be32 dst, int dst_len, u8 tos,
Thomas Grafbe403ea2006-08-17 18:15:17 -07001321 struct fib_info *fi, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322{
Thomas Grafbe403ea2006-08-17 18:15:17 -07001323 struct nlmsghdr *nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 struct rtmsg *rtm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
Eric W. Biederman15e47302012-09-07 20:12:54 +00001326 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags);
Ian Morris51456b22015-04-03 09:17:26 +01001327 if (!nlh)
Patrick McHardy26932562007-01-31 23:16:40 -08001328 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07001329
1330 rtm = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 rtm->rtm_family = AF_INET;
1332 rtm->rtm_dst_len = dst_len;
1333 rtm->rtm_src_len = 0;
1334 rtm->rtm_tos = tos;
Krzysztof Piotr Oledzki709772e2008-06-10 15:44:49 -07001335 if (tb_id < 256)
1336 rtm->rtm_table = tb_id;
1337 else
1338 rtm->rtm_table = RT_TABLE_COMPAT;
David S. Millerf3756b72012-04-01 20:39:02 -04001339 if (nla_put_u32(skb, RTA_TABLE, tb_id))
1340 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 rtm->rtm_type = type;
1342 rtm->rtm_flags = fi->fib_flags;
David S. Miller37e826c2011-03-24 18:06:47 -07001343 rtm->rtm_scope = fi->fib_scope;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 rtm->rtm_protocol = fi->fib_protocol;
Thomas Grafbe403ea2006-08-17 18:15:17 -07001345
David S. Millerf3756b72012-04-01 20:39:02 -04001346 if (rtm->rtm_dst_len &&
Jiri Benc930345e2015-03-29 16:59:25 +02001347 nla_put_in_addr(skb, RTA_DST, dst))
David S. Millerf3756b72012-04-01 20:39:02 -04001348 goto nla_put_failure;
1349 if (fi->fib_priority &&
1350 nla_put_u32(skb, RTA_PRIORITY, fi->fib_priority))
1351 goto nla_put_failure;
Eric Dumazet3fb07da2017-05-25 14:27:35 -07001352 if (rtnetlink_put_metrics(skb, fi->fib_metrics->metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07001353 goto nla_put_failure;
1354
David S. Millerf3756b72012-04-01 20:39:02 -04001355 if (fi->fib_prefsrc &&
Jiri Benc930345e2015-03-29 16:59:25 +02001356 nla_put_in_addr(skb, RTA_PREFSRC, fi->fib_prefsrc))
David S. Millerf3756b72012-04-01 20:39:02 -04001357 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 if (fi->fib_nhs == 1) {
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001359 struct in_device *in_dev;
1360
David S. Millerf3756b72012-04-01 20:39:02 -04001361 if (fi->fib_nh->nh_gw &&
Jiri Benc930345e2015-03-29 16:59:25 +02001362 nla_put_in_addr(skb, RTA_GATEWAY, fi->fib_nh->nh_gw))
David S. Millerf3756b72012-04-01 20:39:02 -04001363 goto nla_put_failure;
1364 if (fi->fib_nh->nh_oif &&
1365 nla_put_u32(skb, RTA_OIF, fi->fib_nh->nh_oif))
1366 goto nla_put_failure;
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001367 if (fi->fib_nh->nh_flags & RTNH_F_LINKDOWN) {
Andy Gospodarek96ac5cc2015-06-26 19:37:11 -04001368 in_dev = __in_dev_get_rtnl(fi->fib_nh->nh_dev);
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001369 if (in_dev &&
1370 IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))
1371 rtm->rtm_flags |= RTNH_F_DEAD;
1372 }
Ido Schimmel475abbf2017-08-02 09:56:01 +02001373 if (fi->fib_nh->nh_flags & RTNH_F_OFFLOAD)
1374 rtm->rtm_flags |= RTNH_F_OFFLOAD;
Patrick McHardyc7066f72011-01-14 13:36:42 +01001375#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04001376 if (fi->fib_nh[0].nh_tclassid &&
1377 nla_put_u32(skb, RTA_FLOW, fi->fib_nh[0].nh_tclassid))
1378 goto nla_put_failure;
Patrick McHardy8265abc2006-07-21 15:09:55 -07001379#endif
David Ahernea7a8082017-01-11 14:29:54 -08001380 if (fi->fib_nh->nh_lwtstate &&
1381 lwtunnel_fill_encap(skb, fi->fib_nh->nh_lwtstate) < 0)
1382 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 }
1384#ifdef CONFIG_IP_ROUTE_MULTIPATH
1385 if (fi->fib_nhs > 1) {
Thomas Grafbe403ea2006-08-17 18:15:17 -07001386 struct rtnexthop *rtnh;
1387 struct nlattr *mp;
1388
1389 mp = nla_nest_start(skb, RTA_MULTIPATH);
Ian Morris51456b22015-04-03 09:17:26 +01001390 if (!mp)
Thomas Grafbe403ea2006-08-17 18:15:17 -07001391 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
1393 for_nexthops(fi) {
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001394 struct in_device *in_dev;
1395
Thomas Grafbe403ea2006-08-17 18:15:17 -07001396 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
Ian Morris51456b22015-04-03 09:17:26 +01001397 if (!rtnh)
Thomas Grafbe403ea2006-08-17 18:15:17 -07001398 goto nla_put_failure;
1399
1400 rtnh->rtnh_flags = nh->nh_flags & 0xFF;
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001401 if (nh->nh_flags & RTNH_F_LINKDOWN) {
Andy Gospodarek96ac5cc2015-06-26 19:37:11 -04001402 in_dev = __in_dev_get_rtnl(nh->nh_dev);
Andy Gospodarek0eeb0752015-06-23 13:45:37 -04001403 if (in_dev &&
1404 IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))
1405 rtnh->rtnh_flags |= RTNH_F_DEAD;
1406 }
Thomas Grafbe403ea2006-08-17 18:15:17 -07001407 rtnh->rtnh_hops = nh->nh_weight - 1;
1408 rtnh->rtnh_ifindex = nh->nh_oif;
1409
David S. Millerf3756b72012-04-01 20:39:02 -04001410 if (nh->nh_gw &&
Jiri Benc930345e2015-03-29 16:59:25 +02001411 nla_put_in_addr(skb, RTA_GATEWAY, nh->nh_gw))
David S. Millerf3756b72012-04-01 20:39:02 -04001412 goto nla_put_failure;
Patrick McHardyc7066f72011-01-14 13:36:42 +01001413#ifdef CONFIG_IP_ROUTE_CLASSID
David S. Millerf3756b72012-04-01 20:39:02 -04001414 if (nh->nh_tclassid &&
1415 nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid))
1416 goto nla_put_failure;
Patrick McHardy8265abc2006-07-21 15:09:55 -07001417#endif
David Ahernea7a8082017-01-11 14:29:54 -08001418 if (nh->nh_lwtstate &&
1419 lwtunnel_fill_encap(skb, nh->nh_lwtstate) < 0)
1420 goto nla_put_failure;
1421
Thomas Grafbe403ea2006-08-17 18:15:17 -07001422 /* length of rtnetlink header + attributes */
1423 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *) rtnh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 } endfor_nexthops(fi);
Thomas Grafbe403ea2006-08-17 18:15:17 -07001425
1426 nla_nest_end(skb, mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 }
1428#endif
Johannes Berg053c0952015-01-16 22:09:00 +01001429 nlmsg_end(skb, nlh);
1430 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Thomas Grafbe403ea2006-08-17 18:15:17 -07001432nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08001433 nlmsg_cancel(skb, nlh);
1434 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435}
1436
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437/*
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001438 * Update FIB if:
1439 * - local address disappeared -> we must delete all the entries
1440 * referring to it.
1441 * - device went down -> we must shutdown all nexthops going via it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 */
Mark Tomlinson5a56a0b2016-09-05 10:20:20 +12001443int fib_sync_down_addr(struct net_device *dev, __be32 local)
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001444{
1445 int ret = 0;
1446 unsigned int hash = fib_laddr_hashfn(local);
1447 struct hlist_head *head = &fib_info_laddrhash[hash];
Mark Tomlinson5a56a0b2016-09-05 10:20:20 +12001448 struct net *net = dev_net(dev);
1449 int tb_id = l3mdev_fib_table(dev);
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001450 struct fib_info *fi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
Ian Morris51456b22015-04-03 09:17:26 +01001452 if (!fib_info_laddrhash || local == 0)
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001453 return 0;
1454
Sasha Levinb67bfe02013-02-27 17:06:00 -08001455 hlist_for_each_entry(fi, head, fib_lhash) {
Mark Tomlinson5a56a0b2016-09-05 10:20:20 +12001456 if (!net_eq(fi->fib_net, net) ||
1457 fi->fib_tb_id != tb_id)
Denis V. Lunev4814bdb2008-01-31 18:50:07 -08001458 continue;
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001459 if (fi->fib_prefsrc == local) {
1460 fi->fib_flags |= RTNH_F_DEAD;
1461 ret++;
1462 }
1463 }
1464 return ret;
1465}
1466
Ido Schimmel982acb92017-02-08 11:16:39 +01001467static int call_fib_nh_notifiers(struct fib_nh *fib_nh,
1468 enum fib_event_type event_type)
1469{
1470 struct in_device *in_dev = __in_dev_get_rtnl(fib_nh->nh_dev);
1471 struct fib_nh_notifier_info info = {
1472 .fib_nh = fib_nh,
1473 };
1474
1475 switch (event_type) {
1476 case FIB_EVENT_NH_ADD:
1477 if (fib_nh->nh_flags & RTNH_F_DEAD)
1478 break;
1479 if (IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
1480 fib_nh->nh_flags & RTNH_F_LINKDOWN)
1481 break;
Ido Schimmel04b1d4e2017-08-03 13:28:11 +02001482 return call_fib4_notifiers(dev_net(fib_nh->nh_dev), event_type,
1483 &info.info);
Ido Schimmel982acb92017-02-08 11:16:39 +01001484 case FIB_EVENT_NH_DEL:
Ido Schimmel71ed7ee2017-07-28 23:27:44 +03001485 if ((in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
Ido Schimmel982acb92017-02-08 11:16:39 +01001486 fib_nh->nh_flags & RTNH_F_LINKDOWN) ||
1487 (fib_nh->nh_flags & RTNH_F_DEAD))
Ido Schimmel04b1d4e2017-08-03 13:28:11 +02001488 return call_fib4_notifiers(dev_net(fib_nh->nh_dev),
1489 event_type, &info.info);
Ido Schimmel982acb92017-02-08 11:16:39 +01001490 default:
1491 break;
1492 }
1493
1494 return NOTIFY_DONE;
1495}
1496
Julian Anastasov4f823de2015-10-30 10:23:33 +02001497/* Event force Flags Description
1498 * NETDEV_CHANGE 0 LINKDOWN Carrier OFF, not for scope host
1499 * NETDEV_DOWN 0 LINKDOWN|DEAD Link down, not for scope host
1500 * NETDEV_DOWN 1 LINKDOWN|DEAD Last address removed
1501 * NETDEV_UNREGISTER 1 LINKDOWN|DEAD Device removed
1502 */
1503int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
1505 int ret = 0;
1506 int scope = RT_SCOPE_NOWHERE;
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001507 struct fib_info *prev_fi = NULL;
1508 unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1509 struct hlist_head *head = &fib_info_devhash[hash];
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001510 struct fib_nh *nh;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001511
Julian Anastasov4f823de2015-10-30 10:23:33 +02001512 if (force)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 scope = -1;
1514
Sasha Levinb67bfe02013-02-27 17:06:00 -08001515 hlist_for_each_entry(nh, head, nh_hash) {
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001516 struct fib_info *fi = nh->nh_parent;
1517 int dead;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001519 BUG_ON(!fi->fib_nhs);
1520 if (nh->nh_dev != dev || fi == prev_fi)
1521 continue;
1522 prev_fi = fi;
1523 dead = 0;
1524 change_nexthops(fi) {
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001525 if (nexthop_nh->nh_flags & RTNH_F_DEAD)
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001526 dead++;
David S. Miller71fceff2010-01-15 01:16:40 -08001527 else if (nexthop_nh->nh_dev == dev &&
1528 nexthop_nh->nh_scope != scope) {
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001529 switch (event) {
1530 case NETDEV_DOWN:
1531 case NETDEV_UNREGISTER:
1532 nexthop_nh->nh_flags |= RTNH_F_DEAD;
1533 /* fall through */
1534 case NETDEV_CHANGE:
1535 nexthop_nh->nh_flags |= RTNH_F_LINKDOWN;
1536 break;
1537 }
Ido Schimmel982acb92017-02-08 11:16:39 +01001538 call_fib_nh_notifiers(nexthop_nh,
1539 FIB_EVENT_NH_DEL);
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001540 dead++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 }
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001542#ifdef CONFIG_IP_ROUTE_MULTIPATH
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001543 if (event == NETDEV_UNREGISTER &&
1544 nexthop_nh->nh_dev == dev) {
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001545 dead = fi->fib_nhs;
1546 break;
1547 }
1548#endif
1549 } endfor_nexthops(fi)
1550 if (dead == fi->fib_nhs) {
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001551 switch (event) {
1552 case NETDEV_DOWN:
1553 case NETDEV_UNREGISTER:
1554 fi->fib_flags |= RTNH_F_DEAD;
1555 /* fall through */
1556 case NETDEV_CHANGE:
1557 fi->fib_flags |= RTNH_F_LINKDOWN;
1558 break;
1559 }
Denis V. Lunev85326fa2008-01-31 18:48:47 -08001560 ret++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 }
Peter Nørlund0e884c72015-09-30 10:12:21 +02001562
1563 fib_rebalance(fi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 }
1565
1566 return ret;
1567}
1568
David S. Miller0c838ff2011-01-31 16:16:50 -08001569/* Must be invoked inside of an RCU protected region. */
David Ahernc7b371e2017-01-05 19:33:59 -08001570static void fib_select_default(const struct flowi4 *flp, struct fib_result *res)
David S. Miller0c838ff2011-01-31 16:16:50 -08001571{
1572 struct fib_info *fi = NULL, *last_resort = NULL;
Alexander Duyck56315f92015-02-25 15:31:31 -08001573 struct hlist_head *fa_head = res->fa_head;
David S. Miller0c838ff2011-01-31 16:16:50 -08001574 struct fib_table *tb = res->table;
Julian Anastasov18a912e92015-07-22 10:43:22 +03001575 u8 slen = 32 - res->prefixlen;
David S. Miller0c838ff2011-01-31 16:16:50 -08001576 int order = -1, last_idx = -1;
Julian Anastasov2392deb2015-07-22 10:43:23 +03001577 struct fib_alias *fa, *fa1 = NULL;
1578 u32 last_prio = res->fi->fib_priority;
1579 u8 last_tos = 0;
David S. Miller0c838ff2011-01-31 16:16:50 -08001580
Alexander Duyck56315f92015-02-25 15:31:31 -08001581 hlist_for_each_entry_rcu(fa, fa_head, fa_list) {
David S. Miller0c838ff2011-01-31 16:16:50 -08001582 struct fib_info *next_fi = fa->fa_info;
1583
Julian Anastasov18a912e92015-07-22 10:43:22 +03001584 if (fa->fa_slen != slen)
1585 continue;
Julian Anastasov2392deb2015-07-22 10:43:23 +03001586 if (fa->fa_tos && fa->fa_tos != flp->flowi4_tos)
1587 continue;
Julian Anastasov18a912e92015-07-22 10:43:22 +03001588 if (fa->tb_id != tb->tb_id)
1589 continue;
Julian Anastasov2392deb2015-07-22 10:43:23 +03001590 if (next_fi->fib_priority > last_prio &&
1591 fa->fa_tos == last_tos) {
1592 if (last_tos)
1593 continue;
1594 break;
1595 }
1596 if (next_fi->fib_flags & RTNH_F_DEAD)
1597 continue;
1598 last_tos = fa->fa_tos;
1599 last_prio = next_fi->fib_priority;
1600
David S. Miller37e826c2011-03-24 18:06:47 -07001601 if (next_fi->fib_scope != res->scope ||
David S. Miller0c838ff2011-01-31 16:16:50 -08001602 fa->fa_type != RTN_UNICAST)
1603 continue;
David S. Miller0c838ff2011-01-31 16:16:50 -08001604 if (!next_fi->fib_nh[0].nh_gw ||
1605 next_fi->fib_nh[0].nh_scope != RT_SCOPE_LINK)
1606 continue;
1607
1608 fib_alias_accessed(fa);
1609
Ian Morris51456b22015-04-03 09:17:26 +01001610 if (!fi) {
David S. Miller0c838ff2011-01-31 16:16:50 -08001611 if (next_fi != res->fi)
1612 break;
Julian Anastasov2392deb2015-07-22 10:43:23 +03001613 fa1 = fa;
David S. Miller0c838ff2011-01-31 16:16:50 -08001614 } else if (!fib_detect_death(fi, order, &last_resort,
Julian Anastasov2392deb2015-07-22 10:43:23 +03001615 &last_idx, fa1->fa_default)) {
David S. Miller0c838ff2011-01-31 16:16:50 -08001616 fib_result_assign(res, fi);
Julian Anastasov2392deb2015-07-22 10:43:23 +03001617 fa1->fa_default = order;
David S. Miller0c838ff2011-01-31 16:16:50 -08001618 goto out;
1619 }
1620 fi = next_fi;
1621 order++;
1622 }
1623
Ian Morris51456b22015-04-03 09:17:26 +01001624 if (order <= 0 || !fi) {
Julian Anastasov2392deb2015-07-22 10:43:23 +03001625 if (fa1)
1626 fa1->fa_default = -1;
David S. Miller0c838ff2011-01-31 16:16:50 -08001627 goto out;
1628 }
1629
1630 if (!fib_detect_death(fi, order, &last_resort, &last_idx,
Julian Anastasov2392deb2015-07-22 10:43:23 +03001631 fa1->fa_default)) {
David S. Miller0c838ff2011-01-31 16:16:50 -08001632 fib_result_assign(res, fi);
Julian Anastasov2392deb2015-07-22 10:43:23 +03001633 fa1->fa_default = order;
David S. Miller0c838ff2011-01-31 16:16:50 -08001634 goto out;
1635 }
1636
1637 if (last_idx >= 0)
1638 fib_result_assign(res, last_resort);
Julian Anastasov2392deb2015-07-22 10:43:23 +03001639 fa1->fa_default = last_idx;
David S. Miller0c838ff2011-01-31 16:16:50 -08001640out:
Eric Dumazet31d40932011-02-14 11:23:04 -08001641 return;
David S. Miller0c838ff2011-01-31 16:16:50 -08001642}
1643
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644/*
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001645 * Dead device goes up. We wake up dead nexthops.
1646 * It takes sense only on multipath routes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 */
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001648int fib_sync_up(struct net_device *dev, unsigned int nh_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649{
1650 struct fib_info *prev_fi;
1651 unsigned int hash;
1652 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 struct fib_nh *nh;
1654 int ret;
1655
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001656 if (!(dev->flags & IFF_UP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 return 0;
1658
Julian Anastasovc9b32922015-10-30 10:23:34 +02001659 if (nh_flags & RTNH_F_DEAD) {
1660 unsigned int flags = dev_get_flags(dev);
1661
1662 if (flags & (IFF_RUNNING | IFF_LOWER_UP))
1663 nh_flags |= RTNH_F_LINKDOWN;
1664 }
1665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 prev_fi = NULL;
1667 hash = fib_devindex_hashfn(dev->ifindex);
1668 head = &fib_info_devhash[hash];
1669 ret = 0;
1670
Sasha Levinb67bfe02013-02-27 17:06:00 -08001671 hlist_for_each_entry(nh, head, nh_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 struct fib_info *fi = nh->nh_parent;
1673 int alive;
1674
1675 BUG_ON(!fi->fib_nhs);
1676 if (nh->nh_dev != dev || fi == prev_fi)
1677 continue;
1678
1679 prev_fi = fi;
1680 alive = 0;
1681 change_nexthops(fi) {
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001682 if (!(nexthop_nh->nh_flags & nh_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 alive++;
1684 continue;
1685 }
Ian Morris51456b22015-04-03 09:17:26 +01001686 if (!nexthop_nh->nh_dev ||
Eric Dumazet6a31d2a2010-10-04 20:00:18 +00001687 !(nexthop_nh->nh_dev->flags & IFF_UP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 continue;
David S. Miller71fceff2010-01-15 01:16:40 -08001689 if (nexthop_nh->nh_dev != dev ||
1690 !__in_dev_get_rtnl(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 continue;
1692 alive++;
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001693 nexthop_nh->nh_flags &= ~nh_flags;
Ido Schimmel982acb92017-02-08 11:16:39 +01001694 call_fib_nh_notifiers(nexthop_nh, FIB_EVENT_NH_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 } endfor_nexthops(fi)
1696
1697 if (alive > 0) {
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001698 fi->fib_flags &= ~nh_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 ret++;
1700 }
Peter Nørlund0e884c72015-09-30 10:12:21 +02001701
1702 fib_rebalance(fi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704
1705 return ret;
1706}
1707
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001708#ifdef CONFIG_IP_ROUTE_MULTIPATH
David Aherna6db4492016-04-07 07:21:00 -07001709static bool fib_good_nh(const struct fib_nh *nh)
1710{
1711 int state = NUD_REACHABLE;
1712
1713 if (nh->nh_scope == RT_SCOPE_LINK) {
1714 struct neighbour *n;
1715
1716 rcu_read_lock_bh();
1717
Eric Dumazetd985d152016-08-18 10:19:34 -07001718 n = __ipv4_neigh_lookup_noref(nh->nh_dev,
1719 (__force u32)nh->nh_gw);
David Aherna6db4492016-04-07 07:21:00 -07001720 if (n)
1721 state = n->nud_state;
1722
1723 rcu_read_unlock_bh();
1724 }
1725
1726 return !!(state & NUD_VALID);
1727}
Andy Gospodarek8a3d0312015-06-23 13:45:36 -04001728
Peter Nørlund0e884c72015-09-30 10:12:21 +02001729void fib_select_multipath(struct fib_result *res, int hash)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730{
1731 struct fib_info *fi = res->fi;
David Aherna6db4492016-04-07 07:21:00 -07001732 struct net *net = fi->fib_net;
1733 bool first = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
Peter Nørlund0e884c72015-09-30 10:12:21 +02001735 for_nexthops(fi) {
1736 if (hash > atomic_read(&nh->nh_upper_bound))
1737 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
David Aherna6db4492016-04-07 07:21:00 -07001739 if (!net->ipv4.sysctl_fib_multipath_use_neigh ||
1740 fib_good_nh(nh)) {
1741 res->nh_sel = nhsel;
1742 return;
1743 }
1744 if (!first) {
1745 res->nh_sel = nhsel;
1746 first = true;
1747 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 } endfor_nexthops(fi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749}
1750#endif
David Ahern3ce58d82015-10-05 08:51:25 -07001751
1752void fib_select_path(struct net *net, struct fib_result *res,
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001753 struct flowi4 *fl4, const struct sk_buff *skb)
David Ahern3ce58d82015-10-05 08:51:25 -07001754{
David Ahern7a18c5b2017-01-10 14:37:35 -08001755 bool oif_check;
1756
1757 oif_check = (fl4->flowi4_oif == 0 ||
1758 fl4->flowi4_flags & FLOWI_FLAG_SKIP_NH_OIF);
1759
David Ahern3ce58d82015-10-05 08:51:25 -07001760#ifdef CONFIG_IP_ROUTE_MULTIPATH
David Ahern7a18c5b2017-01-10 14:37:35 -08001761 if (res->fi->fib_nhs > 1 && oif_check) {
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001762 int h = fib_multipath_hash(res->fi, fl4, skb);
Paolo Abeni9920e482015-10-29 22:20:40 +01001763
Nikolay Aleksandrovbf4e0a32017-03-16 15:28:00 +02001764 fib_select_multipath(res, h);
David Ahern3ce58d82015-10-05 08:51:25 -07001765 }
1766 else
1767#endif
1768 if (!res->prefixlen &&
1769 res->table->tb_num_default > 1 &&
David Ahern7a18c5b2017-01-10 14:37:35 -08001770 res->type == RTN_UNICAST && oif_check)
David Ahern3ce58d82015-10-05 08:51:25 -07001771 fib_select_default(fl4, res);
1772
1773 if (!fl4->saddr)
1774 fl4->saddr = FIB_RES_PREFSRC(net, *res);
1775}
1776EXPORT_SYMBOL_GPL(fib_select_path);