~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* INET An implementation of the TCP/IP protocol suite for the LINUX
3	4	* operating system. INET is implemented using the BSD Socket
..	..	@@ -6,11 +7,6 @@
6	7	* IPv4 Forwarding Information Base: semantics.
7	8	*
8	9	* 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	10	*/
15	11
16	12	#include <linux/uaccess.h>
..	..	@@ -33,6 +29,7 @@
33	29	#include <linux/init.h>
34	30	#include <linux/slab.h>
35	31	#include <linux/netlink.h>
	32	+#include <linux/hash.h>
36	33
37	34	#include <net/arp.h>
38	35	#include <net/ip.h>
..	..	@@ -41,10 +38,13 @@
41	38	#include <net/tcp.h>
42	39	#include <net/sock.h>
43	40	#include <net/ip_fib.h>
44		-#include <net/netlink.h>
	41	+#include <net/ip6_fib.h>
45	42	#include <net/nexthop.h>
	43	+#include <net/netlink.h>
	44	+#include <net/rtnh.h>
46	45	#include <net/lwtunnel.h>
47	46	#include <net/fib_notifier.h>
	47	+#include <net/addrconf.h>
48	48
49	49	#include "fib_lookup.h"
50	50
..	..	@@ -58,18 +58,21 @@
58	58	#define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS)
59	59	static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE];
60	60
	61	+/* for_nexthops and change_nexthops only used when nexthop object
	62	+ * is not set in a fib_info. The logic within can reference fib_nh.
	63	+ */
61	64	#ifdef CONFIG_IP_ROUTE_MULTIPATH
62	65
63	66	#define for_nexthops(fi) { \
64	67	int nhsel; const struct fib_nh *nh; \
65	68	for (nhsel = 0, nh = (fi)->fib_nh; \
66		- nhsel < (fi)->fib_nhs; \
	69	+ nhsel < fib_info_num_path((fi)); \
67	70	nh++, nhsel++)
68	71
69	72	#define change_nexthops(fi) { \
70	73	int nhsel; struct fib_nh *nexthop_nh; \
71	74	for (nhsel = 0, nexthop_nh = (struct fib_nh *)((fi)->fib_nh); \
72		- nhsel < (fi)->fib_nhs; \
	75	+ nhsel < fib_info_num_path((fi)); \
73	76	nexthop_nh++, nhsel++)
74	77
75	78	#else /* CONFIG_IP_ROUTE_MULTIPATH */
..	..	@@ -157,12 +160,12 @@
157	160	dst_release_immediate(&rt->dst);
158	161	}
159	162
160		-static void free_nh_exceptions(struct fib_nh *nh)
	163	+static void free_nh_exceptions(struct fib_nh_common *nhc)
161	164	{
162	165	struct fnhe_hash_bucket *hash;
163	166	int i;
164	167
165		- hash = rcu_dereference_protected(nh->nh_exceptions, 1);
	168	+ hash = rcu_dereference_protected(nhc->nhc_exceptions, 1);
166	169	if (!hash)
167	170	return;
168	171	for (i = 0; i < FNHE_HASH_SIZE; i++) {
..	..	@@ -204,24 +207,42 @@
204	207	free_percpu(rtp);
205	208	}
206	209
	210	+void fib_nh_common_release(struct fib_nh_common *nhc)
	211	+{
	212	+ if (nhc->nhc_dev)
	213	+ dev_put(nhc->nhc_dev);
	214	+
	215	+ lwtstate_put(nhc->nhc_lwtstate);
	216	+ rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
	217	+ rt_fibinfo_free(&nhc->nhc_rth_input);
	218	+ free_nh_exceptions(nhc);
	219	+}
	220	+EXPORT_SYMBOL_GPL(fib_nh_common_release);
	221	+
	222	+void fib_nh_release(struct net net, struct fib_nh fib_nh)
	223	+{
	224	+#ifdef CONFIG_IP_ROUTE_CLASSID
	225	+ if (fib_nh->nh_tclassid)
	226	+ atomic_dec(&net->ipv4.fib_num_tclassid_users);
	227	+#endif
	228	+ fib_nh_common_release(&fib_nh->nh_common);
	229	+}
	230	+
207	231	/* Release a nexthop info record */
208	232	static void free_fib_info_rcu(struct rcu_head *head)
209	233	{
210	234	struct fib_info *fi = container_of(head, struct fib_info, rcu);
211		- struct dst_metrics *m;
212	235
213		- change_nexthops(fi) {
214		- if (nexthop_nh->nh_dev)
215		- dev_put(nexthop_nh->nh_dev);
216		- lwtstate_put(nexthop_nh->nh_lwtstate);
217		- free_nh_exceptions(nexthop_nh);
218		- rt_fibinfo_free_cpus(nexthop_nh->nh_pcpu_rth_output);
219		- rt_fibinfo_free(&nexthop_nh->nh_rth_input);
220		- } endfor_nexthops(fi);
	236	+ if (fi->nh) {
	237	+ nexthop_put(fi->nh);
	238	+ } else {
	239	+ change_nexthops(fi) {
	240	+ fib_nh_release(fi->fib_net, nexthop_nh);
	241	+ } endfor_nexthops(fi);
	242	+ }
221	243
222		- m = fi->fib_metrics;
223		- if (m != &dst_default_metrics && refcount_dec_and_test(&m->refcnt))
224		- kfree(m);
	244	+ ip_fib_metrics_put(fi->fib_metrics);
	245	+
225	246	kfree(fi);
226	247	}
227	248
..	..	@@ -231,13 +252,7 @@
231	252	pr_warn("Freeing alive fib_info %p\n", fi);
232	253	return;
233	254	}
234		- fib_info_cnt--;
235		-#ifdef CONFIG_IP_ROUTE_CLASSID
236		- change_nexthops(fi) {
237		- if (nexthop_nh->nh_tclassid)
238		- fi->fib_net->ipv4.fib_num_tclassid_users--;
239		- } endfor_nexthops(fi);
240		-#endif
	255	+
241	256	call_rcu(&fi->rcu, free_fib_info_rcu);
242	257	}
243	258	EXPORT_SYMBOL_GPL(free_fib_info);
..	..	@@ -247,66 +262,149 @@
247	262	spin_lock_bh(&fib_info_lock);
248	263	if (fi && --fi->fib_treeref == 0) {
249	264	hlist_del(&fi->fib_hash);
	265	+
	266	+ /* Paired with READ_ONCE() in fib_create_info(). */
	267	+ WRITE_ONCE(fib_info_cnt, fib_info_cnt - 1);
	268	+
250	269	if (fi->fib_prefsrc)
251	270	hlist_del(&fi->fib_lhash);
252		- change_nexthops(fi) {
253		- if (!nexthop_nh->nh_dev)
254		- continue;
255		- hlist_del(&nexthop_nh->nh_hash);
256		- } endfor_nexthops(fi)
	271	+ if (fi->nh) {
	272	+ list_del(&fi->nh_list);
	273	+ } else {
	274	+ change_nexthops(fi) {
	275	+ if (!nexthop_nh->fib_nh_dev)
	276	+ continue;
	277	+ hlist_del(&nexthop_nh->nh_hash);
	278	+ } endfor_nexthops(fi)
	279	+ }
257	280	fi->fib_dead = 1;
258	281	fib_info_put(fi);
259	282	}
260	283	spin_unlock_bh(&fib_info_lock);
261	284	}
262	285
263		-static inline int nh_comp(const struct fib_info fi, const struct fib_info ofi)
	286	+static inline int nh_comp(struct fib_info fi, struct fib_info ofi)
264	287	{
265		- const struct fib_nh *onh = ofi->fib_nh;
	288	+ const struct fib_nh *onh;
	289	+
	290	+ if (fi->nh \|\| ofi->nh)
	291	+ return nexthop_cmp(fi->nh, ofi->nh) ? 0 : -1;
	292	+
	293	+ if (ofi->fib_nhs == 0)
	294	+ return 0;
266	295
267	296	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 \|\|
	297	+ onh = fib_info_nh(ofi, nhsel);
	298	+
	299	+ if (nh->fib_nh_oif != onh->fib_nh_oif \|\|
	300	+ nh->fib_nh_gw_family != onh->fib_nh_gw_family \|\|
	301	+ nh->fib_nh_scope != onh->fib_nh_scope \|\|
271	302	#ifdef CONFIG_IP_ROUTE_MULTIPATH
272		- nh->nh_weight != onh->nh_weight \|\|
	303	+ nh->fib_nh_weight != onh->fib_nh_weight \|\|
273	304	#endif
274	305	#ifdef CONFIG_IP_ROUTE_CLASSID
275	306	nh->nh_tclassid != onh->nh_tclassid \|\|
276	307	#endif
277		- lwtunnel_cmp_encap(nh->nh_lwtstate, onh->nh_lwtstate) \|\|
278		- ((nh->nh_flags ^ onh->nh_flags) & ~RTNH_COMPARE_MASK))
	308	+ lwtunnel_cmp_encap(nh->fib_nh_lws, onh->fib_nh_lws) \|\|
	309	+ ((nh->fib_nh_flags ^ onh->fib_nh_flags) & ~RTNH_COMPARE_MASK))
279	310	return -1;
280		- onh++;
	311	+
	312	+ if (nh->fib_nh_gw_family == AF_INET &&
	313	+ nh->fib_nh_gw4 != onh->fib_nh_gw4)
	314	+ return -1;
	315	+
	316	+ if (nh->fib_nh_gw_family == AF_INET6 &&
	317	+ ipv6_addr_cmp(&nh->fib_nh_gw6, &onh->fib_nh_gw6))
	318	+ return -1;
281	319	} endfor_nexthops(fi);
282	320	return 0;
283	321	}
284	322
285	323	static inline unsigned int fib_devindex_hashfn(unsigned int val)
286	324	{
287		- unsigned int mask = DEVINDEX_HASHSIZE - 1;
288		-
289		- return (val ^
290		- (val >> DEVINDEX_HASHBITS) ^
291		- (val >> (DEVINDEX_HASHBITS * 2))) & mask;
	325	+ return hash_32(val, DEVINDEX_HASHBITS);
292	326	}
293	327
294		-static inline unsigned int fib_info_hashfn(const struct fib_info *fi)
	328	+static struct hlist_head *
	329	+fib_info_devhash_bucket(const struct net_device *dev)
	330	+{
	331	+ u32 val = net_hash_mix(dev_net(dev)) ^ dev->ifindex;
	332	+
	333	+ return &fib_info_devhash[fib_devindex_hashfn(val)];
	334	+}
	335	+
	336	+static unsigned int fib_info_hashfn_1(int init_val, u8 protocol, u8 scope,
	337	+ u32 prefsrc, u32 priority)
	338	+{
	339	+ unsigned int val = init_val;
	340	+
	341	+ val ^= (protocol << 8) \| scope;
	342	+ val ^= prefsrc;
	343	+ val ^= priority;
	344	+
	345	+ return val;
	346	+}
	347	+
	348	+static unsigned int fib_info_hashfn_result(unsigned int val)
295	349	{
296	350	unsigned int mask = (fib_info_hash_size - 1);
297		- unsigned int val = fi->fib_nhs;
298		-
299		- val ^= (fi->fib_protocol << 8) \| fi->fib_scope;
300		- val ^= (__force u32)fi->fib_prefsrc;
301		- val ^= fi->fib_priority;
302		- for_nexthops(fi) {
303		- val ^= fib_devindex_hashfn(nh->nh_oif);
304		- } endfor_nexthops(fi)
305	351
306	352	return (val ^ (val >> 7) ^ (val >> 12)) & mask;
307	353	}
308	354
309		-static struct fib_info fib_find_info(const struct fib_info nfi)
	355	+static inline unsigned int fib_info_hashfn(struct fib_info *fi)
	356	+{
	357	+ unsigned int val;
	358	+
	359	+ val = fib_info_hashfn_1(fi->fib_nhs, fi->fib_protocol,
	360	+ fi->fib_scope, (__force u32)fi->fib_prefsrc,
	361	+ fi->fib_priority);
	362	+
	363	+ if (fi->nh) {
	364	+ val ^= fib_devindex_hashfn(fi->nh->id);
	365	+ } else {
	366	+ for_nexthops(fi) {
	367	+ val ^= fib_devindex_hashfn(nh->fib_nh_oif);
	368	+ } endfor_nexthops(fi)
	369	+ }
	370	+
	371	+ return fib_info_hashfn_result(val);
	372	+}
	373	+
	374	+/* no metrics, only nexthop id */
	375	+static struct fib_info fib_find_info_nh(struct net net,
	376	+ const struct fib_config *cfg)
	377	+{
	378	+ struct hlist_head *head;
	379	+ struct fib_info *fi;
	380	+ unsigned int hash;
	381	+
	382	+ hash = fib_info_hashfn_1(fib_devindex_hashfn(cfg->fc_nh_id),
	383	+ cfg->fc_protocol, cfg->fc_scope,
	384	+ (__force u32)cfg->fc_prefsrc,
	385	+ cfg->fc_priority);
	386	+ hash = fib_info_hashfn_result(hash);
	387	+ head = &fib_info_hash[hash];
	388	+
	389	+ hlist_for_each_entry(fi, head, fib_hash) {
	390	+ if (!net_eq(fi->fib_net, net))
	391	+ continue;
	392	+ if (!fi->nh \|\| fi->nh->id != cfg->fc_nh_id)
	393	+ continue;
	394	+ if (cfg->fc_protocol == fi->fib_protocol &&
	395	+ cfg->fc_scope == fi->fib_scope &&
	396	+ cfg->fc_prefsrc == fi->fib_prefsrc &&
	397	+ cfg->fc_priority == fi->fib_priority &&
	398	+ cfg->fc_type == fi->fib_type &&
	399	+ cfg->fc_table == fi->fib_tb_id &&
	400	+ !((cfg->fc_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK))
	401	+ return fi;
	402	+ }
	403	+
	404	+ return NULL;
	405	+}
	406	+
	407	+static struct fib_info fib_find_info(struct fib_info nfi)
310	408	{
311	409	struct hlist_head *head;
312	410	struct fib_info *fi;
..	..	@@ -325,10 +423,11 @@
325	423	nfi->fib_prefsrc == fi->fib_prefsrc &&
326	424	nfi->fib_priority == fi->fib_priority &&
327	425	nfi->fib_type == fi->fib_type &&
	426	+ nfi->fib_tb_id == fi->fib_tb_id &&
328	427	memcmp(nfi->fib_metrics, fi->fib_metrics,
329	428	sizeof(u32) * RTAX_MAX) == 0 &&
330	429	!((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) &&
331		- (nfi->fib_nhs == 0 \|\| nh_comp(fi, nfi) == 0))
	430	+ nh_comp(fi, nfi) == 0)
332	431	return fi;
333	432	}
334	433
..	..	@@ -342,16 +441,15 @@
342	441	{
343	442	struct hlist_head *head;
344	443	struct fib_nh *nh;
345		- unsigned int hash;
346	444
347	445	spin_lock(&fib_info_lock);
348	446
349		- hash = fib_devindex_hashfn(dev->ifindex);
350		- head = &fib_info_devhash[hash];
	447	+ head = fib_info_devhash_bucket(dev);
	448	+
351	449	hlist_for_each_entry(nh, head, nh_hash) {
352		- if (nh->nh_dev == dev &&
353		- nh->nh_gw == gw &&
354		- !(nh->nh_flags & RTNH_F_DEAD)) {
	450	+ if (nh->fib_nh_dev == dev &&
	451	+ nh->fib_nh_gw4 == gw &&
	452	+ !(nh->fib_nh_flags & RTNH_F_DEAD)) {
355	453	spin_unlock(&fib_info_lock);
356	454	return 0;
357	455	}
..	..	@@ -370,34 +468,40 @@
370	468	+ nla_total_size(4) /* RTA_PRIORITY */
371	469	+ nla_total_size(4) /* RTA_PREFSRC */
372	470	+ nla_total_size(TCP_CA_NAME_MAX); /* RTAX_CC_ALGO */
	471	+ unsigned int nhs = fib_info_num_path(fi);
373	472
374	473	/* space for nested metrics */
375	474	payload += nla_total_size((RTAX_MAX * nla_total_size(4)));
376	475
377		- if (fi->fib_nhs) {
	476	+ if (fi->nh)
	477	+ payload += nla_total_size(4); /* RTA_NH_ID */
	478	+
	479	+ if (nhs) {
378	480	size_t nh_encapsize = 0;
379		- /* Also handles the special case fib_nhs == 1 */
	481	+ /* Also handles the special case nhs == 1 */
380	482
381	483	/* each nexthop is packed in an attribute */
382	484	size_t nhsize = nla_total_size(sizeof(struct rtnexthop));
	485	+ unsigned int i;
383	486
384	487	/* may contain flow and gateway attribute */
385	488	nhsize += 2 * nla_total_size(4);
386	489
387	490	/* grab encap info */
388		- for_nexthops(fi) {
389		- if (nh->nh_lwtstate) {
	491	+ for (i = 0; i < fib_info_num_path(fi); i++) {
	492	+ struct fib_nh_common *nhc = fib_info_nhc(fi, i);
	493	+
	494	+ if (nhc->nhc_lwtstate) {
390	495	/* RTA_ENCAP_TYPE */
391	496	nh_encapsize += lwtunnel_get_encap_size(
392		- nh->nh_lwtstate);
	497	+ nhc->nhc_lwtstate);
393	498	/* RTA_ENCAP */
394	499	nh_encapsize += nla_total_size(2);
395	500	}
396		- } endfor_nexthops(fi);
	501	+ }
397	502
398	503	/* all nexthops are packed in a nested attribute */
399		- payload += nla_total_size((fi->fib_nhs * nhsize) +
400		- nh_encapsize);
	504	+ payload += nla_total_size((nhs * nhsize) + nh_encapsize);
401	505
402	506	}
403	507
..	..	@@ -408,6 +512,7 @@
408	512	int dst_len, u32 tb_id, const struct nl_info *info,
409	513	unsigned int nlm_flags)
410	514	{
	515	+ struct fib_rt_info fri;
411	516	struct sk_buff *skb;
412	517	u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
413	518	int err = -ENOBUFS;
..	..	@@ -416,9 +521,15 @@
416	521	if (!skb)
417	522	goto errout;
418	523
419		- err = fib_dump_info(skb, info->portid, seq, event, tb_id,
420		- fa->fa_type, key, dst_len,
421		- fa->fa_tos, fa->fa_info, nlm_flags);
	524	+ fri.fi = fa->fa_info;
	525	+ fri.tb_id = tb_id;
	526	+ fri.dst = key;
	527	+ fri.dst_len = dst_len;
	528	+ fri.tos = fa->fa_tos;
	529	+ fri.type = fa->fa_type;
	530	+ fri.offload = fa->offload;
	531	+ fri.trap = fa->trap;
	532	+ err = fib_dump_info(skb, info->portid, seq, event, &fri, nlm_flags);
422	533	if (err < 0) {
423	534	/* -EMSGSIZE implies BUG in fib_nlmsg_size() */
424	535	WARN_ON(err == -EMSGSIZE);
..	..	@@ -437,10 +548,18 @@
437	548	struct fib_info *last_resort, int last_idx,
438	549	int dflt)
439	550	{
	551	+ const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
440	552	struct neighbour *n;
441	553	int state = NUD_NONE;
442	554
443		- n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
	555	+ if (likely(nhc->nhc_gw_family == AF_INET))
	556	+ n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev);
	557	+ else if (nhc->nhc_gw_family == AF_INET6)
	558	+ n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6,
	559	+ nhc->nhc_dev);
	560	+ else
	561	+ n = NULL;
	562	+
444	563	if (n) {
445	564	state = n->nud_state;
446	565	neigh_release(n);
..	..	@@ -457,6 +576,77 @@
457	576	*last_idx = order;
458	577	}
459	578	return 1;
	579	+}
	580	+
	581	+int fib_nh_common_init(struct net net, struct fib_nh_common nhc,
	582	+ struct nlattr *encap, u16 encap_type,
	583	+ void *cfg, gfp_t gfp_flags,
	584	+ struct netlink_ext_ack *extack)
	585	+{
	586	+ int err;
	587	+
	588	+ nhc->nhc_pcpu_rth_output = alloc_percpu_gfp(struct rtable __rcu *,
	589	+ gfp_flags);
	590	+ if (!nhc->nhc_pcpu_rth_output)
	591	+ return -ENOMEM;
	592	+
	593	+ if (encap) {
	594	+ struct lwtunnel_state *lwtstate;
	595	+
	596	+ if (encap_type == LWTUNNEL_ENCAP_NONE) {
	597	+ NL_SET_ERR_MSG(extack, "LWT encap type not specified");
	598	+ err = -EINVAL;
	599	+ goto lwt_failure;
	600	+ }
	601	+ err = lwtunnel_build_state(net, encap_type, encap,
	602	+ nhc->nhc_family, cfg, &lwtstate,
	603	+ extack);
	604	+ if (err)
	605	+ goto lwt_failure;
	606	+
	607	+ nhc->nhc_lwtstate = lwtstate_get(lwtstate);
	608	+ }
	609	+
	610	+ return 0;
	611	+
	612	+lwt_failure:
	613	+ rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
	614	+ nhc->nhc_pcpu_rth_output = NULL;
	615	+ return err;
	616	+}
	617	+EXPORT_SYMBOL_GPL(fib_nh_common_init);
	618	+
	619	+int fib_nh_init(struct net net, struct fib_nh nh,
	620	+ struct fib_config *cfg, int nh_weight,
	621	+ struct netlink_ext_ack *extack)
	622	+{
	623	+ int err;
	624	+
	625	+ nh->fib_nh_family = AF_INET;
	626	+
	627	+ err = fib_nh_common_init(net, &nh->nh_common, cfg->fc_encap,
	628	+ cfg->fc_encap_type, cfg, GFP_KERNEL, extack);
	629	+ if (err)
	630	+ return err;
	631	+
	632	+ nh->fib_nh_oif = cfg->fc_oif;
	633	+ nh->fib_nh_gw_family = cfg->fc_gw_family;
	634	+ if (cfg->fc_gw_family == AF_INET)
	635	+ nh->fib_nh_gw4 = cfg->fc_gw4;
	636	+ else if (cfg->fc_gw_family == AF_INET6)
	637	+ nh->fib_nh_gw6 = cfg->fc_gw6;
	638	+
	639	+ nh->fib_nh_flags = cfg->fc_flags;
	640	+
	641	+#ifdef CONFIG_IP_ROUTE_CLASSID
	642	+ nh->nh_tclassid = cfg->fc_flow;
	643	+ if (nh->nh_tclassid)
	644	+ atomic_inc(&net->ipv4.fib_num_tclassid_users);
	645	+#endif
	646	+#ifdef CONFIG_IP_ROUTE_MULTIPATH
	647	+ nh->fib_nh_weight = nh_weight;
	648	+#endif
	649	+ return 0;
460	650	}
461	651
462	652	#ifdef CONFIG_IP_ROUTE_MULTIPATH
..	..	@@ -481,14 +671,33 @@
481	671	return nhs;
482	672	}
483	673
	674	+static int fib_gw_from_attr(__be32 gw, struct nlattr nla,
	675	+ struct netlink_ext_ack *extack)
	676	+{
	677	+ if (nla_len(nla) < sizeof(*gw)) {
	678	+ NL_SET_ERR_MSG(extack, "Invalid IPv4 address in RTA_GATEWAY");
	679	+ return -EINVAL;
	680	+ }
	681	+
	682	+ *gw = nla_get_in_addr(nla);
	683	+
	684	+ return 0;
	685	+}
	686	+
	687	+/* only called when fib_nh is integrated into fib_info */
484	688	static int fib_get_nhs(struct fib_info fi, struct rtnexthop rtnh,
485	689	int remaining, struct fib_config *cfg,
486	690	struct netlink_ext_ack *extack)
487	691	{
	692	+ struct net *net = fi->fib_net;
	693	+ struct fib_config fib_cfg;
	694	+ struct fib_nh *nh;
488	695	int ret;
489	696
490	697	change_nexthops(fi) {
491	698	int attrlen;
	699	+
	700	+ memset(&fib_cfg, 0, sizeof(fib_cfg));
492	701
493	702	if (!rtnh_ok(rtnh, remaining)) {
494	703	NL_SET_ERR_MSG(extack,
..	..	@@ -502,112 +711,145 @@
502	711	return -EINVAL;
503	712	}
504	713
505		- 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;
	714	+ fib_cfg.fc_flags = (cfg->fc_flags & ~0xFF) \| rtnh->rtnh_flags;
	715	+ fib_cfg.fc_oif = rtnh->rtnh_ifindex;
509	716
510	717	attrlen = rtnh_attrlen(rtnh);
511	718	if (attrlen > 0) {
512		- struct nlattr nla, attrs = rtnh_attrs(rtnh);
	719	+ struct nlattr nla, nlav, *attrs = rtnh_attrs(rtnh);
513	720
514	721	nla = nla_find(attrs, attrlen, RTA_GATEWAY);
515		- nexthop_nh->nh_gw = nla ? nla_get_in_addr(nla) : 0;
516		-#ifdef CONFIG_IP_ROUTE_CLASSID
517		- nla = nla_find(attrs, attrlen, RTA_FLOW);
518		- nexthop_nh->nh_tclassid = nla ? nla_get_u32(nla) : 0;
519		- if (nexthop_nh->nh_tclassid)
520		- fi->fib_net->ipv4.fib_num_tclassid_users++;
521		-#endif
522		- nla = nla_find(attrs, attrlen, RTA_ENCAP);
	722	+ nlav = nla_find(attrs, attrlen, RTA_VIA);
	723	+ if (nla && nlav) {
	724	+ NL_SET_ERR_MSG(extack,
	725	+ "Nexthop configuration can not contain both GATEWAY and VIA");
	726	+ return -EINVAL;
	727	+ }
523	728	if (nla) {
524		- struct lwtunnel_state *lwtstate;
525		- struct nlattr *nla_entype;
526		-
527		- nla_entype = nla_find(attrs, attrlen,
528		- RTA_ENCAP_TYPE);
529		- if (!nla_entype) {
530		- NL_SET_BAD_ATTR(extack, nla);
531		- NL_SET_ERR_MSG(extack,
532		- "Encap type is missing");
533		- goto err_inval;
534		- }
535		-
536		- ret = lwtunnel_build_state(nla_get_u16(
537		- nla_entype),
538		- nla, AF_INET, cfg,
539		- &lwtstate, extack);
	729	+ ret = fib_gw_from_attr(&fib_cfg.fc_gw4, nla,
	730	+ extack);
540	731	if (ret)
541	732	goto errout;
542		- nexthop_nh->nh_lwtstate =
543		- lwtstate_get(lwtstate);
	733	+
	734	+ if (fib_cfg.fc_gw4)
	735	+ fib_cfg.fc_gw_family = AF_INET;
	736	+ } else if (nlav) {
	737	+ ret = fib_gw_from_via(&fib_cfg, nlav, extack);
	738	+ if (ret)
	739	+ goto errout;
544	740	}
	741	+
	742	+ nla = nla_find(attrs, attrlen, RTA_FLOW);
	743	+ if (nla) {
	744	+ if (nla_len(nla) < sizeof(u32)) {
	745	+ NL_SET_ERR_MSG(extack, "Invalid RTA_FLOW");
	746	+ return -EINVAL;
	747	+ }
	748	+ fib_cfg.fc_flow = nla_get_u32(nla);
	749	+ }
	750	+
	751	+ fib_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
	752	+ /* RTA_ENCAP_TYPE length checked in
	753	+ * lwtunnel_valid_encap_type_attr
	754	+ */
	755	+ nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
	756	+ if (nla)
	757	+ fib_cfg.fc_encap_type = nla_get_u16(nla);
545	758	}
	759	+
	760	+ ret = fib_nh_init(net, nexthop_nh, &fib_cfg,
	761	+ rtnh->rtnh_hops + 1, extack);
	762	+ if (ret)
	763	+ goto errout;
546	764
547	765	rtnh = rtnh_next(rtnh, &remaining);
548	766	} endfor_nexthops(fi);
549	767
550		- return 0;
551		-
552		-err_inval:
553	768	ret = -EINVAL;
554		-
	769	+ nh = fib_info_nh(fi, 0);
	770	+ if (cfg->fc_oif && nh->fib_nh_oif != cfg->fc_oif) {
	771	+ NL_SET_ERR_MSG(extack,
	772	+ "Nexthop device index does not match RTA_OIF");
	773	+ goto errout;
	774	+ }
	775	+ if (cfg->fc_gw_family) {
	776	+ if (cfg->fc_gw_family != nh->fib_nh_gw_family \|\|
	777	+ (cfg->fc_gw_family == AF_INET &&
	778	+ nh->fib_nh_gw4 != cfg->fc_gw4) \|\|
	779	+ (cfg->fc_gw_family == AF_INET6 &&
	780	+ ipv6_addr_cmp(&nh->fib_nh_gw6, &cfg->fc_gw6))) {
	781	+ NL_SET_ERR_MSG(extack,
	782	+ "Nexthop gateway does not match RTA_GATEWAY or RTA_VIA");
	783	+ goto errout;
	784	+ }
	785	+ }
	786	+#ifdef CONFIG_IP_ROUTE_CLASSID
	787	+ if (cfg->fc_flow && nh->nh_tclassid != cfg->fc_flow) {
	788	+ NL_SET_ERR_MSG(extack,
	789	+ "Nexthop class id does not match RTA_FLOW");
	790	+ goto errout;
	791	+ }
	792	+#endif
	793	+ ret = 0;
555	794	errout:
556	795	return ret;
557	796	}
558	797
	798	+/* only called when fib_nh is integrated into fib_info */
559	799	static void fib_rebalance(struct fib_info *fi)
560	800	{
561	801	int total;
562	802	int w;
563		- struct in_device *in_dev;
564	803
565		- if (fi->fib_nhs < 2)
	804	+ if (fib_info_num_path(fi) < 2)
566	805	return;
567	806
568	807	total = 0;
569	808	for_nexthops(fi) {
570		- if (nh->nh_flags & RTNH_F_DEAD)
	809	+ if (nh->fib_nh_flags & RTNH_F_DEAD)
571	810	continue;
572	811
573		- in_dev = __in_dev_get_rtnl(nh->nh_dev);
574		-
575		- if (in_dev &&
576		- IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
577		- nh->nh_flags & RTNH_F_LINKDOWN)
	812	+ if (ip_ignore_linkdown(nh->fib_nh_dev) &&
	813	+ nh->fib_nh_flags & RTNH_F_LINKDOWN)
578	814	continue;
579	815
580		- total += nh->nh_weight;
	816	+ total += nh->fib_nh_weight;
581	817	} endfor_nexthops(fi);
582	818
583	819	w = 0;
584	820	change_nexthops(fi) {
585	821	int upper_bound;
586	822
587		- in_dev = __in_dev_get_rtnl(nexthop_nh->nh_dev);
588		-
589		- if (nexthop_nh->nh_flags & RTNH_F_DEAD) {
	823	+ if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) {
590	824	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) {
	825	+ } else if (ip_ignore_linkdown(nexthop_nh->fib_nh_dev) &&
	826	+ nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) {
594	827	upper_bound = -1;
595	828	} else {
596		- w += nexthop_nh->nh_weight;
	829	+ w += nexthop_nh->fib_nh_weight;
597	830	upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31,
598	831	total) - 1;
599	832	}
600	833
601		- atomic_set(&nexthop_nh->nh_upper_bound, upper_bound);
	834	+ atomic_set(&nexthop_nh->fib_nh_upper_bound, upper_bound);
602	835	} endfor_nexthops(fi);
603	836	}
604	837	#else /* CONFIG_IP_ROUTE_MULTIPATH */
	838	+
	839	+static int fib_get_nhs(struct fib_info fi, struct rtnexthop rtnh,
	840	+ int remaining, struct fib_config *cfg,
	841	+ struct netlink_ext_ack *extack)
	842	+{
	843	+ NL_SET_ERR_MSG(extack, "Multipath support not enabled in kernel");
	844	+
	845	+ return -EINVAL;
	846	+}
605	847
606	848	#define fib_rebalance(fi) do { } while (0)
607	849
608	850	#endif /* CONFIG_IP_ROUTE_MULTIPATH */
609	851
610		-static int fib_encap_match(u16 encap_type,
	852	+static int fib_encap_match(struct net *net, u16 encap_type,
611	853	struct nlattr *encap,
612	854	const struct fib_nh *nh,
613	855	const struct fib_config *cfg,
..	..	@@ -619,17 +861,17 @@
619	861	if (encap_type == LWTUNNEL_ENCAP_NONE)
620	862	return 0;
621	863
622		- ret = lwtunnel_build_state(encap_type, encap, AF_INET,
	864	+ ret = lwtunnel_build_state(net, encap_type, encap, AF_INET,
623	865	cfg, &lwtstate, extack);
624	866	if (!ret) {
625		- result = lwtunnel_cmp_encap(lwtstate, nh->nh_lwtstate);
	867	+ result = lwtunnel_cmp_encap(lwtstate, nh->fib_nh_lws);
626	868	lwtstate_free(lwtstate);
627	869	}
628	870
629	871	return result;
630	872	}
631	873
632		-int fib_nh_match(struct fib_config cfg, struct fib_info fi,
	874	+int fib_nh_match(struct net net, struct fib_config cfg, struct fib_info *fi,
633	875	struct netlink_ext_ack *extack)
634	876	{
635	877	#ifdef CONFIG_IP_ROUTE_MULTIPATH
..	..	@@ -640,21 +882,46 @@
640	882	if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority)
641	883	return 1;
642	884
643		- if (cfg->fc_oif \|\| cfg->fc_gw) {
	885	+ if (cfg->fc_nh_id) {
	886	+ if (fi->nh && cfg->fc_nh_id == fi->nh->id)
	887	+ return 0;
	888	+ return 1;
	889	+ }
	890	+
	891	+ if (fi->nh) {
	892	+ if (cfg->fc_oif \|\| cfg->fc_gw_family \|\| cfg->fc_mp)
	893	+ return 1;
	894	+ return 0;
	895	+ }
	896	+
	897	+ if (cfg->fc_oif \|\| cfg->fc_gw_family) {
	898	+ struct fib_nh *nh;
	899	+
	900	+ nh = fib_info_nh(fi, 0);
644	901	if (cfg->fc_encap) {
645		- if (fib_encap_match(cfg->fc_encap_type, cfg->fc_encap,
646		- fi->fib_nh, cfg, extack))
	902	+ if (fib_encap_match(net, cfg->fc_encap_type,
	903	+ cfg->fc_encap, nh, cfg, extack))
647	904	return 1;
648	905	}
649	906	#ifdef CONFIG_IP_ROUTE_CLASSID
650	907	if (cfg->fc_flow &&
651		- cfg->fc_flow != fi->fib_nh->nh_tclassid)
	908	+ cfg->fc_flow != nh->nh_tclassid)
652	909	return 1;
653	910	#endif
654		- if ((!cfg->fc_oif \|\| cfg->fc_oif == fi->fib_nh->nh_oif) &&
655		- (!cfg->fc_gw \|\| cfg->fc_gw == fi->fib_nh->nh_gw))
656		- return 0;
657		- return 1;
	911	+ if ((cfg->fc_oif && cfg->fc_oif != nh->fib_nh_oif) \|\|
	912	+ (cfg->fc_gw_family &&
	913	+ cfg->fc_gw_family != nh->fib_nh_gw_family))
	914	+ return 1;
	915	+
	916	+ if (cfg->fc_gw_family == AF_INET &&
	917	+ cfg->fc_gw4 != nh->fib_nh_gw4)
	918	+ return 1;
	919	+
	920	+ if (cfg->fc_gw_family == AF_INET6 &&
	921	+ ipv6_addr_cmp(&cfg->fc_gw6, &nh->fib_nh_gw6))
	922	+ return 1;
	923	+
	924	+ return 0;
658	925	}
659	926
660	927	#ifdef CONFIG_IP_ROUTE_MULTIPATH
..	..	@@ -670,20 +937,64 @@
670	937	if (!rtnh_ok(rtnh, remaining))
671	938	return -EINVAL;
672	939
673		- if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->nh_oif)
	940	+ if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->fib_nh_oif)
674	941	return 1;
675	942
676	943	attrlen = rtnh_attrlen(rtnh);
677	944	if (attrlen > 0) {
678		- struct nlattr nla, attrs = rtnh_attrs(rtnh);
	945	+ struct nlattr nla, nlav, *attrs = rtnh_attrs(rtnh);
	946	+ int err;
679	947
680	948	nla = nla_find(attrs, attrlen, RTA_GATEWAY);
681		- if (nla && nla_get_in_addr(nla) != nh->nh_gw)
682		- return 1;
	949	+ nlav = nla_find(attrs, attrlen, RTA_VIA);
	950	+ if (nla && nlav) {
	951	+ NL_SET_ERR_MSG(extack,
	952	+ "Nexthop configuration can not contain both GATEWAY and VIA");
	953	+ return -EINVAL;
	954	+ }
	955	+
	956	+ if (nla) {
	957	+ __be32 gw;
	958	+
	959	+ err = fib_gw_from_attr(&gw, nla, extack);
	960	+ if (err)
	961	+ return err;
	962	+
	963	+ if (nh->fib_nh_gw_family != AF_INET \|\|
	964	+ gw != nh->fib_nh_gw4)
	965	+ return 1;
	966	+ } else if (nlav) {
	967	+ struct fib_config cfg2;
	968	+
	969	+ err = fib_gw_from_via(&cfg2, nlav, extack);
	970	+ if (err)
	971	+ return err;
	972	+
	973	+ switch (nh->fib_nh_gw_family) {
	974	+ case AF_INET:
	975	+ if (cfg2.fc_gw_family != AF_INET \|\|
	976	+ cfg2.fc_gw4 != nh->fib_nh_gw4)
	977	+ return 1;
	978	+ break;
	979	+ case AF_INET6:
	980	+ if (cfg2.fc_gw_family != AF_INET6 \|\|
	981	+ ipv6_addr_cmp(&cfg2.fc_gw6,
	982	+ &nh->fib_nh_gw6))
	983	+ return 1;
	984	+ break;
	985	+ }
	986	+ }
	987	+
683	988	#ifdef CONFIG_IP_ROUTE_CLASSID
684	989	nla = nla_find(attrs, attrlen, RTA_FLOW);
685		- if (nla && nla_get_u32(nla) != nh->nh_tclassid)
686		- return 1;
	990	+ if (nla) {
	991	+ if (nla_len(nla) < sizeof(u32)) {
	992	+ NL_SET_ERR_MSG(extack, "Invalid RTA_FLOW");
	993	+ return -EINVAL;
	994	+ }
	995	+ if (nla_get_u32(nla) != nh->nh_tclassid)
	996	+ return 1;
	997	+ }
687	998	#endif
688	999	}
689	1000
..	..	@@ -733,6 +1044,30 @@
733	1044	return true;
734	1045	}
735	1046
	1047	+static int fib_check_nh_v6_gw(struct net net, struct fib_nh nh,
	1048	+ u32 table, struct netlink_ext_ack *extack)
	1049	+{
	1050	+ struct fib6_config cfg = {
	1051	+ .fc_table = table,
	1052	+ .fc_flags = nh->fib_nh_flags \| RTF_GATEWAY,
	1053	+ .fc_ifindex = nh->fib_nh_oif,
	1054	+ .fc_gateway = nh->fib_nh_gw6,
	1055	+ };
	1056	+ struct fib6_nh fib6_nh = {};
	1057	+ int err;
	1058	+
	1059	+ err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack);
	1060	+ if (!err) {
	1061	+ nh->fib_nh_dev = fib6_nh.fib_nh_dev;
	1062	+ dev_hold(nh->fib_nh_dev);
	1063	+ nh->fib_nh_oif = nh->fib_nh_dev->ifindex;
	1064	+ nh->fib_nh_scope = RT_SCOPE_LINK;
	1065	+
	1066	+ ipv6_stub->fib6_nh_release(&fib6_nh);
	1067	+ }
	1068	+
	1069	+ return err;
	1070	+}
736	1071
737	1072	/*
738	1073	* Picture
..	..	@@ -777,128 +1112,147 @@
777	1112	* \|
778	1113	* \|-> {local prefix} (terminal node)
779	1114	*/
780		-static int fib_check_nh(struct fib_config cfg, struct fib_nh nh,
781		- struct netlink_ext_ack *extack)
	1115	+static int fib_check_nh_v4_gw(struct net net, struct fib_nh nh, u32 table,
	1116	+ u8 scope, struct netlink_ext_ack *extack)
782	1117	{
783		- int err = 0;
784		- struct net *net;
785	1118	struct net_device *dev;
	1119	+ struct fib_result res;
	1120	+ int err = 0;
786	1121
787		- net = cfg->fc_nlinfo.nl_net;
788		- if (nh->nh_gw) {
789		- struct fib_result res;
	1122	+ if (nh->fib_nh_flags & RTNH_F_ONLINK) {
	1123	+ unsigned int addr_type;
790	1124
791		- if (nh->nh_flags & RTNH_F_ONLINK) {
792		- unsigned int addr_type;
793		-
794		- if (cfg->fc_scope >= RT_SCOPE_LINK) {
795		- NL_SET_ERR_MSG(extack,
796		- "Nexthop has invalid scope");
797		- return -EINVAL;
798		- }
799		- dev = __dev_get_by_index(net, nh->nh_oif);
800		- if (!dev)
801		- return -ENODEV;
802		- if (!(dev->flags & IFF_UP)) {
803		- NL_SET_ERR_MSG(extack,
804		- "Nexthop device is not up");
805		- return -ENETDOWN;
806		- }
807		- addr_type = inet_addr_type_dev_table(net, dev, nh->nh_gw);
808		- if (addr_type != RTN_UNICAST) {
809		- NL_SET_ERR_MSG(extack,
810		- "Nexthop has invalid gateway");
811		- return -EINVAL;
812		- }
813		- if (!netif_carrier_ok(dev))
814		- nh->nh_flags \|= RTNH_F_LINKDOWN;
815		- nh->nh_dev = dev;
816		- dev_hold(dev);
817		- nh->nh_scope = RT_SCOPE_LINK;
818		- return 0;
	1125	+ if (scope >= RT_SCOPE_LINK) {
	1126	+ NL_SET_ERR_MSG(extack, "Nexthop has invalid scope");
	1127	+ return -EINVAL;
819	1128	}
820		- rcu_read_lock();
821		- {
822		- struct fib_table *tbl = NULL;
823		- struct flowi4 fl4 = {
824		- .daddr = nh->nh_gw,
825		- .flowi4_scope = cfg->fc_scope + 1,
826		- .flowi4_oif = nh->nh_oif,
827		- .flowi4_iif = LOOPBACK_IFINDEX,
828		- };
829		-
830		- /* It is not necessary, but requires a bit of thinking */
831		- if (fl4.flowi4_scope < RT_SCOPE_LINK)
832		- fl4.flowi4_scope = RT_SCOPE_LINK;
833		-
834		- if (cfg->fc_table && cfg->fc_table != RT_TABLE_MAIN)
835		- tbl = fib_get_table(net, cfg->fc_table);
836		-
837		- if (tbl)
838		- err = fib_table_lookup(tbl, &fl4, &res,
839		- FIB_LOOKUP_IGNORE_LINKSTATE \|
840		- FIB_LOOKUP_NOREF);
841		-
842		- /* on error or if no table given do full lookup. This
843		- * is needed for example when nexthops are in the local
844		- * table rather than the given table
845		- */
846		- if (!tbl \|\| err) {
847		- err = fib_lookup(net, &fl4, &res,
848		- FIB_LOOKUP_IGNORE_LINKSTATE);
849		- }
850		-
851		- if (err) {
852		- NL_SET_ERR_MSG(extack,
853		- "Nexthop has invalid gateway");
854		- rcu_read_unlock();
855		- return err;
856		- }
	1129	+ dev = __dev_get_by_index(net, nh->fib_nh_oif);
	1130	+ if (!dev) {
	1131	+ NL_SET_ERR_MSG(extack, "Nexthop device required for onlink");
	1132	+ return -ENODEV;
857	1133	}
858		- err = -EINVAL;
859		- if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) {
	1134	+ if (!(dev->flags & IFF_UP)) {
	1135	+ NL_SET_ERR_MSG(extack, "Nexthop device is not up");
	1136	+ return -ENETDOWN;
	1137	+ }
	1138	+ addr_type = inet_addr_type_dev_table(net, dev, nh->fib_nh_gw4);
	1139	+ if (addr_type != RTN_UNICAST) {
	1140	+ NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
	1141	+ return -EINVAL;
	1142	+ }
	1143	+ if (!netif_carrier_ok(dev))
	1144	+ nh->fib_nh_flags \|= RTNH_F_LINKDOWN;
	1145	+ nh->fib_nh_dev = dev;
	1146	+ dev_hold(dev);
	1147	+ nh->fib_nh_scope = RT_SCOPE_LINK;
	1148	+ return 0;
	1149	+ }
	1150	+ rcu_read_lock();
	1151	+ {
	1152	+ struct fib_table *tbl = NULL;
	1153	+ struct flowi4 fl4 = {
	1154	+ .daddr = nh->fib_nh_gw4,
	1155	+ .flowi4_scope = scope + 1,
	1156	+ .flowi4_oif = nh->fib_nh_oif,
	1157	+ .flowi4_iif = LOOPBACK_IFINDEX,
	1158	+ };
	1159	+
	1160	+ /* It is not necessary, but requires a bit of thinking */
	1161	+ if (fl4.flowi4_scope < RT_SCOPE_LINK)
	1162	+ fl4.flowi4_scope = RT_SCOPE_LINK;
	1163	+
	1164	+ if (table && table != RT_TABLE_MAIN)
	1165	+ tbl = fib_get_table(net, table);
	1166	+
	1167	+ if (tbl)
	1168	+ err = fib_table_lookup(tbl, &fl4, &res,
	1169	+ FIB_LOOKUP_IGNORE_LINKSTATE \|
	1170	+ FIB_LOOKUP_NOREF);
	1171	+
	1172	+ /* on error or if no table given do full lookup. This
	1173	+ * is needed for example when nexthops are in the local
	1174	+ * table rather than the given table
	1175	+ */
	1176	+ if (!tbl \|\| err) {
	1177	+ err = fib_lookup(net, &fl4, &res,
	1178	+ FIB_LOOKUP_IGNORE_LINKSTATE);
	1179	+ }
	1180	+
	1181	+ if (err) {
860	1182	NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
861	1183	goto out;
862	1184	}
863		- nh->nh_scope = res.scope;
864		- nh->nh_oif = FIB_RES_OIF(res);
865		- nh->nh_dev = dev = FIB_RES_DEV(res);
866		- if (!dev) {
867		- NL_SET_ERR_MSG(extack,
868		- "No egress device for nexthop gateway");
869		- goto out;
870		- }
871		- dev_hold(dev);
872		- if (!netif_carrier_ok(dev))
873		- nh->nh_flags \|= RTNH_F_LINKDOWN;
874		- err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN;
875		- } else {
876		- struct in_device *in_dev;
877		-
878		- if (nh->nh_flags & (RTNH_F_PERVASIVE \| RTNH_F_ONLINK)) {
879		- NL_SET_ERR_MSG(extack,
880		- "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set");
881		- return -EINVAL;
882		- }
883		- rcu_read_lock();
884		- err = -ENODEV;
885		- in_dev = inetdev_by_index(net, nh->nh_oif);
886		- if (!in_dev)
887		- goto out;
888		- err = -ENETDOWN;
889		- if (!(in_dev->dev->flags & IFF_UP)) {
890		- NL_SET_ERR_MSG(extack, "Device for nexthop is not up");
891		- goto out;
892		- }
893		- nh->nh_dev = in_dev->dev;
894		- dev_hold(nh->nh_dev);
895		- nh->nh_scope = RT_SCOPE_HOST;
896		- if (!netif_carrier_ok(nh->nh_dev))
897		- nh->nh_flags \|= RTNH_F_LINKDOWN;
898		- err = 0;
899	1185	}
	1186	+
	1187	+ err = -EINVAL;
	1188	+ if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) {
	1189	+ NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
	1190	+ goto out;
	1191	+ }
	1192	+ nh->fib_nh_scope = res.scope;
	1193	+ nh->fib_nh_oif = FIB_RES_OIF(res);
	1194	+ nh->fib_nh_dev = dev = FIB_RES_DEV(res);
	1195	+ if (!dev) {
	1196	+ NL_SET_ERR_MSG(extack,
	1197	+ "No egress device for nexthop gateway");
	1198	+ goto out;
	1199	+ }
	1200	+ dev_hold(dev);
	1201	+ if (!netif_carrier_ok(dev))
	1202	+ nh->fib_nh_flags \|= RTNH_F_LINKDOWN;
	1203	+ err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN;
900	1204	out:
901	1205	rcu_read_unlock();
	1206	+ return err;
	1207	+}
	1208	+
	1209	+static int fib_check_nh_nongw(struct net net, struct fib_nh nh,
	1210	+ struct netlink_ext_ack *extack)
	1211	+{
	1212	+ struct in_device *in_dev;
	1213	+ int err;
	1214	+
	1215	+ if (nh->fib_nh_flags & (RTNH_F_PERVASIVE \| RTNH_F_ONLINK)) {
	1216	+ NL_SET_ERR_MSG(extack,
	1217	+ "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set");
	1218	+ return -EINVAL;
	1219	+ }
	1220	+
	1221	+ rcu_read_lock();
	1222	+
	1223	+ err = -ENODEV;
	1224	+ in_dev = inetdev_by_index(net, nh->fib_nh_oif);
	1225	+ if (!in_dev)
	1226	+ goto out;
	1227	+ err = -ENETDOWN;
	1228	+ if (!(in_dev->dev->flags & IFF_UP)) {
	1229	+ NL_SET_ERR_MSG(extack, "Device for nexthop is not up");
	1230	+ goto out;
	1231	+ }
	1232	+
	1233	+ nh->fib_nh_dev = in_dev->dev;
	1234	+ dev_hold(nh->fib_nh_dev);
	1235	+ nh->fib_nh_scope = RT_SCOPE_LINK;
	1236	+ if (!netif_carrier_ok(nh->fib_nh_dev))
	1237	+ nh->fib_nh_flags \|= RTNH_F_LINKDOWN;
	1238	+ err = 0;
	1239	+out:
	1240	+ rcu_read_unlock();
	1241	+ return err;
	1242	+}
	1243	+
	1244	+int fib_check_nh(struct net net, struct fib_nh nh, u32 table, u8 scope,
	1245	+ struct netlink_ext_ack *extack)
	1246	+{
	1247	+ int err;
	1248	+
	1249	+ if (nh->fib_nh_gw_family == AF_INET)
	1250	+ err = fib_check_nh_v4_gw(net, nh, table, scope, extack);
	1251	+ else if (nh->fib_nh_gw_family == AF_INET6)
	1252	+ err = fib_check_nh_v6_gw(net, nh, table, extack);
	1253	+ else
	1254	+ err = fib_check_nh_nongw(net, nh, extack);
	1255	+
902	1256	return err;
903	1257	}
904	1258
..	..	@@ -984,14 +1338,37 @@
984	1338	fib_info_hash_free(old_laddrhash, bytes);
985	1339	}
986	1340
987		-__be32 fib_info_update_nh_saddr(struct net net, struct fib_nh nh)
	1341	+__be32 fib_info_update_nhc_saddr(struct net net, struct fib_nh_common nhc,
	1342	+ unsigned char scope)
988	1343	{
989		- nh->nh_saddr = inet_select_addr(nh->nh_dev,
990		- nh->nh_gw,
991		- nh->nh_parent->fib_scope);
	1344	+ struct fib_nh *nh;
	1345	+
	1346	+ if (nhc->nhc_family != AF_INET)
	1347	+ return inet_select_addr(nhc->nhc_dev, 0, scope);
	1348	+
	1349	+ nh = container_of(nhc, struct fib_nh, nh_common);
	1350	+ nh->nh_saddr = inet_select_addr(nh->fib_nh_dev, nh->fib_nh_gw4, scope);
992	1351	nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid);
993	1352
994	1353	return nh->nh_saddr;
	1354	+}
	1355	+
	1356	+__be32 fib_result_prefsrc(struct net net, struct fib_result res)
	1357	+{
	1358	+ struct fib_nh_common *nhc = res->nhc;
	1359	+
	1360	+ if (res->fi->fib_prefsrc)
	1361	+ return res->fi->fib_prefsrc;
	1362	+
	1363	+ if (nhc->nhc_family == AF_INET) {
	1364	+ struct fib_nh *nh;
	1365	+
	1366	+ nh = container_of(nhc, struct fib_nh, nh_common);
	1367	+ if (nh->nh_saddr_genid == atomic_read(&net->ipv4.dev_addr_genid))
	1368	+ return nh->nh_saddr;
	1369	+ }
	1370	+
	1371	+ return fib_info_update_nhc_saddr(net, nhc, res->fi->fib_scope);
995	1372	}
996	1373
997	1374	static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc)
..	..	@@ -1018,18 +1395,12 @@
1018	1395	return true;
1019	1396	}
1020	1397
1021		-static int
1022		-fib_convert_metrics(struct fib_info fi, const struct fib_config cfg)
1023		-{
1024		- return ip_metrics_convert(fi->fib_net, cfg->fc_mx, cfg->fc_mx_len,
1025		- fi->fib_metrics->metrics);
1026		-}
1027		-
1028	1398	struct fib_info fib_create_info(struct fib_config cfg,
1029	1399	struct netlink_ext_ack *extack)
1030	1400	{
1031	1401	int err;
1032	1402	struct fib_info *fi = NULL;
	1403	+ struct nexthop *nh = NULL;
1033	1404	struct fib_info *ofi;
1034	1405	int nhs = 1;
1035	1406	struct net *net = cfg->fc_nlinfo.nl_net;
..	..	@@ -1049,6 +1420,23 @@
1049	1420	goto err_inval;
1050	1421	}
1051	1422
	1423	+ if (cfg->fc_nh_id) {
	1424	+ if (!cfg->fc_mx) {
	1425	+ fi = fib_find_info_nh(net, cfg);
	1426	+ if (fi) {
	1427	+ fi->fib_treeref++;
	1428	+ return fi;
	1429	+ }
	1430	+ }
	1431	+
	1432	+ nh = nexthop_find_by_id(net, cfg->fc_nh_id);
	1433	+ if (!nh) {
	1434	+ NL_SET_ERR_MSG(extack, "Nexthop id does not exist");
	1435	+ goto err_inval;
	1436	+ }
	1437	+ nhs = 0;
	1438	+ }
	1439	+
1052	1440	#ifdef CONFIG_IP_ROUTE_MULTIPATH
1053	1441	if (cfg->fc_mp) {
1054	1442	nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack);
..	..	@@ -1058,7 +1446,9 @@
1058	1446	#endif
1059	1447
1060	1448	err = -ENOBUFS;
1061		- if (fib_info_cnt >= fib_info_hash_size) {
	1449	+
	1450	+ /* Paired with WRITE_ONCE() in fib_release_info() */
	1451	+ if (READ_ONCE(fib_info_cnt) >= fib_info_hash_size) {
1062	1452	unsigned int new_size = fib_info_hash_size << 1;
1063	1453	struct hlist_head *new_info_hash;
1064	1454	struct hlist_head *new_laddrhash;
..	..	@@ -1079,20 +1469,17 @@
1079	1469	goto failure;
1080	1470	}
1081	1471
1082		- fi = kzalloc(sizeof(fi)+nhssizeof(struct fib_nh), GFP_KERNEL);
	1472	+ fi = kzalloc(struct_size(fi, fib_nh, nhs), GFP_KERNEL);
1083	1473	if (!fi)
1084	1474	goto failure;
1085		- if (cfg->fc_mx) {
1086		- fi->fib_metrics = kzalloc(sizeof(*fi->fib_metrics), GFP_KERNEL);
1087		- if (unlikely(!fi->fib_metrics)) {
1088		- kfree(fi);
1089		- return ERR_PTR(err);
1090		- }
1091		- refcount_set(&fi->fib_metrics->refcnt, 1);
1092		- } else {
1093		- fi->fib_metrics = (struct dst_metrics *)&dst_default_metrics;
	1475	+ fi->fib_metrics = ip_fib_metrics_init(fi->fib_net, cfg->fc_mx,
	1476	+ cfg->fc_mx_len, extack);
	1477	+ if (IS_ERR(fi->fib_metrics)) {
	1478	+ err = PTR_ERR(fi->fib_metrics);
	1479	+ kfree(fi);
	1480	+ return ERR_PTR(err);
1094	1481	}
1095		- fib_info_cnt++;
	1482	+
1096	1483	fi->fib_net = net;
1097	1484	fi->fib_protocol = cfg->fc_protocol;
1098	1485	fi->fib_scope = cfg->fc_scope;
..	..	@@ -1103,78 +1490,31 @@
1103	1490	fi->fib_tb_id = cfg->fc_table;
1104	1491
1105	1492	fi->fib_nhs = nhs;
1106		- change_nexthops(fi) {
1107		- nexthop_nh->nh_parent = fi;
1108		- nexthop_nh->nh_pcpu_rth_output = alloc_percpu(struct rtable __rcu *);
1109		- if (!nexthop_nh->nh_pcpu_rth_output)
1110		- goto failure;
1111		- } endfor_nexthops(fi)
1112		-
1113		- err = fib_convert_metrics(fi, cfg);
1114		- if (err)
1115		- goto failure;
1116		-
1117		- if (cfg->fc_mp) {
1118		-#ifdef CONFIG_IP_ROUTE_MULTIPATH
1119		- err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg, extack);
1120		- if (err != 0)
1121		- goto failure;
1122		- if (cfg->fc_oif && fi->fib_nh->nh_oif != cfg->fc_oif) {
1123		- NL_SET_ERR_MSG(extack,
1124		- "Nexthop device index does not match RTA_OIF");
1125		- goto err_inval;
	1493	+ if (nh) {
	1494	+ if (!nexthop_get(nh)) {
	1495	+ NL_SET_ERR_MSG(extack, "Nexthop has been deleted");
	1496	+ err = -EINVAL;
	1497	+ } else {
	1498	+ err = 0;
	1499	+ fi->nh = nh;
1126	1500	}
1127		- if (cfg->fc_gw && fi->fib_nh->nh_gw != cfg->fc_gw) {
1128		- NL_SET_ERR_MSG(extack,
1129		- "Nexthop gateway does not match RTA_GATEWAY");
1130		- goto err_inval;
1131		- }
1132		-#ifdef CONFIG_IP_ROUTE_CLASSID
1133		- if (cfg->fc_flow && fi->fib_nh->nh_tclassid != cfg->fc_flow) {
1134		- NL_SET_ERR_MSG(extack,
1135		- "Nexthop class id does not match RTA_FLOW");
1136		- goto err_inval;
1137		- }
1138		-#endif
1139		-#else
1140		- NL_SET_ERR_MSG(extack,
1141		- "Multipath support not enabled in kernel");
1142		- goto err_inval;
1143		-#endif
1144	1501	} else {
1145		- struct fib_nh *nh = fi->fib_nh;
	1502	+ change_nexthops(fi) {
	1503	+ nexthop_nh->nh_parent = fi;
	1504	+ } endfor_nexthops(fi)
1146	1505
1147		- if (cfg->fc_encap) {
1148		- struct lwtunnel_state *lwtstate;
1149		-
1150		- if (cfg->fc_encap_type == LWTUNNEL_ENCAP_NONE) {
1151		- NL_SET_ERR_MSG(extack,
1152		- "LWT encap type not specified");
1153		- goto err_inval;
1154		- }
1155		- err = lwtunnel_build_state(cfg->fc_encap_type,
1156		- cfg->fc_encap, AF_INET, cfg,
1157		- &lwtstate, extack);
1158		- if (err)
1159		- goto failure;
1160		-
1161		- nh->nh_lwtstate = lwtstate_get(lwtstate);
1162		- }
1163		- nh->nh_oif = cfg->fc_oif;
1164		- nh->nh_gw = cfg->fc_gw;
1165		- nh->nh_flags = cfg->fc_flags;
1166		-#ifdef CONFIG_IP_ROUTE_CLASSID
1167		- nh->nh_tclassid = cfg->fc_flow;
1168		- if (nh->nh_tclassid)
1169		- fi->fib_net->ipv4.fib_num_tclassid_users++;
1170		-#endif
1171		-#ifdef CONFIG_IP_ROUTE_MULTIPATH
1172		- nh->nh_weight = 1;
1173		-#endif
	1506	+ if (cfg->fc_mp)
	1507	+ err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg,
	1508	+ extack);
	1509	+ else
	1510	+ err = fib_nh_init(net, fi->fib_nh, cfg, 1, extack);
1174	1511	}
1175	1512
	1513	+ if (err != 0)
	1514	+ goto failure;
	1515	+
1176	1516	if (fib_props[cfg->fc_type].error) {
1177		- if (cfg->fc_gw \|\| cfg->fc_oif \|\| cfg->fc_mp) {
	1517	+ if (cfg->fc_gw_family \|\| cfg->fc_oif \|\| cfg->fc_mp) {
1178	1518	NL_SET_ERR_MSG(extack,
1179	1519	"Gateway, device and multipath can not be specified for this route type");
1180	1520	goto err_inval;
..	..	@@ -1199,7 +1539,11 @@
1199	1539	goto err_inval;
1200	1540	}
1201	1541
1202		- if (cfg->fc_scope == RT_SCOPE_HOST) {
	1542	+ if (fi->nh) {
	1543	+ err = fib_check_nexthop(fi->nh, cfg->fc_scope, extack);
	1544	+ if (err)
	1545	+ goto failure;
	1546	+ } else if (cfg->fc_scope == RT_SCOPE_HOST) {
1203	1547	struct fib_nh *nh = fi->fib_nh;
1204	1548
1205	1549	/* Local address is added. */
..	..	@@ -1208,24 +1552,26 @@
1208	1552	"Route with host scope can not have multiple nexthops");
1209	1553	goto err_inval;
1210	1554	}
1211		- if (nh->nh_gw) {
	1555	+ if (nh->fib_nh_gw_family) {
1212	1556	NL_SET_ERR_MSG(extack,
1213	1557	"Route with host scope can not have a gateway");
1214	1558	goto err_inval;
1215	1559	}
1216		- nh->nh_scope = RT_SCOPE_NOWHERE;
1217		- nh->nh_dev = dev_get_by_index(net, fi->fib_nh->nh_oif);
	1560	+ nh->fib_nh_scope = RT_SCOPE_NOWHERE;
	1561	+ nh->fib_nh_dev = dev_get_by_index(net, nh->fib_nh_oif);
1218	1562	err = -ENODEV;
1219		- if (!nh->nh_dev)
	1563	+ if (!nh->fib_nh_dev)
1220	1564	goto failure;
1221	1565	} else {
1222	1566	int linkdown = 0;
1223	1567
1224	1568	change_nexthops(fi) {
1225		- err = fib_check_nh(cfg, nexthop_nh, extack);
	1569	+ err = fib_check_nh(cfg->fc_nlinfo.nl_net, nexthop_nh,
	1570	+ cfg->fc_table, cfg->fc_scope,
	1571	+ extack);
1226	1572	if (err != 0)
1227	1573	goto failure;
1228		- if (nexthop_nh->nh_flags & RTNH_F_LINKDOWN)
	1574	+ if (nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN)
1229	1575	linkdown++;
1230	1576	} endfor_nexthops(fi)
1231	1577	if (linkdown == fi->fib_nhs)
..	..	@@ -1237,11 +1583,16 @@
1237	1583	goto err_inval;
1238	1584	}
1239	1585
1240		- change_nexthops(fi) {
1241		- fib_info_update_nh_saddr(net, nexthop_nh);
1242		- } endfor_nexthops(fi)
	1586	+ if (!fi->nh) {
	1587	+ change_nexthops(fi) {
	1588	+ fib_info_update_nhc_saddr(net, &nexthop_nh->nh_common,
	1589	+ fi->fib_scope);
	1590	+ if (nexthop_nh->fib_nh_gw_family == AF_INET6)
	1591	+ fi->fib_nh_is_v6 = true;
	1592	+ } endfor_nexthops(fi)
1243	1593
1244		- fib_rebalance(fi);
	1594	+ fib_rebalance(fi);
	1595	+ }
1245	1596
1246	1597	link_it:
1247	1598	ofi = fib_find_info(fi);
..	..	@@ -1255,6 +1606,7 @@
1255	1606	fi->fib_treeref++;
1256	1607	refcount_set(&fi->fib_clntref, 1);
1257	1608	spin_lock_bh(&fib_info_lock);
	1609	+ fib_info_cnt++;
1258	1610	hlist_add_head(&fi->fib_hash,
1259	1611	&fib_info_hash[fib_info_hashfn(fi)]);
1260	1612	if (fi->fib_prefsrc) {
..	..	@@ -1263,16 +1615,18 @@
1263	1615	head = &fib_info_laddrhash[fib_laddr_hashfn(fi->fib_prefsrc)];
1264	1616	hlist_add_head(&fi->fib_lhash, head);
1265	1617	}
1266		- change_nexthops(fi) {
1267		- struct hlist_head *head;
1268		- unsigned int hash;
	1618	+ if (fi->nh) {
	1619	+ list_add(&fi->nh_list, &nh->fi_list);
	1620	+ } else {
	1621	+ change_nexthops(fi) {
	1622	+ struct hlist_head *head;
1269	1623
1270		- if (!nexthop_nh->nh_dev)
1271		- continue;
1272		- hash = fib_devindex_hashfn(nexthop_nh->nh_dev->ifindex);
1273		- head = &fib_info_devhash[hash];
1274		- hlist_add_head(&nexthop_nh->nh_hash, head);
1275		- } endfor_nexthops(fi)
	1624	+ if (!nexthop_nh->fib_nh_dev)
	1625	+ continue;
	1626	+ head = fib_info_devhash_bucket(nexthop_nh->fib_nh_dev);
	1627	+ hlist_add_head(&nexthop_nh->nh_hash, head);
	1628	+ } endfor_nexthops(fi)
	1629	+ }
1276	1630	spin_unlock_bh(&fib_info_lock);
1277	1631	return fi;
1278	1632
..	..	@@ -1288,10 +1642,157 @@
1288	1642	return ERR_PTR(err);
1289	1643	}
1290	1644
1291		-int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
1292		- u32 tb_id, u8 type, __be32 dst, int dst_len, u8 tos,
1293		- struct fib_info *fi, unsigned int flags)
	1645	+int fib_nexthop_info(struct sk_buff skb, const struct fib_nh_common nhc,
	1646	+ u8 rt_family, unsigned char *flags, bool skip_oif)
1294	1647	{
	1648	+ if (nhc->nhc_flags & RTNH_F_DEAD)
	1649	+ *flags \|= RTNH_F_DEAD;
	1650	+
	1651	+ if (nhc->nhc_flags & RTNH_F_LINKDOWN) {
	1652	+ *flags \|= RTNH_F_LINKDOWN;
	1653	+
	1654	+ rcu_read_lock();
	1655	+ switch (nhc->nhc_family) {
	1656	+ case AF_INET:
	1657	+ if (ip_ignore_linkdown(nhc->nhc_dev))
	1658	+ *flags \|= RTNH_F_DEAD;
	1659	+ break;
	1660	+ case AF_INET6:
	1661	+ if (ip6_ignore_linkdown(nhc->nhc_dev))
	1662	+ *flags \|= RTNH_F_DEAD;
	1663	+ break;
	1664	+ }
	1665	+ rcu_read_unlock();
	1666	+ }
	1667	+
	1668	+ switch (nhc->nhc_gw_family) {
	1669	+ case AF_INET:
	1670	+ if (nla_put_in_addr(skb, RTA_GATEWAY, nhc->nhc_gw.ipv4))
	1671	+ goto nla_put_failure;
	1672	+ break;
	1673	+ case AF_INET6:
	1674	+ /* if gateway family does not match nexthop family
	1675	+ * gateway is encoded as RTA_VIA
	1676	+ */
	1677	+ if (rt_family != nhc->nhc_gw_family) {
	1678	+ int alen = sizeof(struct in6_addr);
	1679	+ struct nlattr *nla;
	1680	+ struct rtvia *via;
	1681	+
	1682	+ nla = nla_reserve(skb, RTA_VIA, alen + 2);
	1683	+ if (!nla)
	1684	+ goto nla_put_failure;
	1685	+
	1686	+ via = nla_data(nla);
	1687	+ via->rtvia_family = AF_INET6;
	1688	+ memcpy(via->rtvia_addr, &nhc->nhc_gw.ipv6, alen);
	1689	+ } else if (nla_put_in6_addr(skb, RTA_GATEWAY,
	1690	+ &nhc->nhc_gw.ipv6) < 0) {
	1691	+ goto nla_put_failure;
	1692	+ }
	1693	+ break;
	1694	+ }
	1695	+
	1696	+ *flags \|= (nhc->nhc_flags & RTNH_F_ONLINK);
	1697	+ if (nhc->nhc_flags & RTNH_F_OFFLOAD)
	1698	+ *flags \|= RTNH_F_OFFLOAD;
	1699	+
	1700	+ if (!skip_oif && nhc->nhc_dev &&
	1701	+ nla_put_u32(skb, RTA_OIF, nhc->nhc_dev->ifindex))
	1702	+ goto nla_put_failure;
	1703	+
	1704	+ if (nhc->nhc_lwtstate &&
	1705	+ lwtunnel_fill_encap(skb, nhc->nhc_lwtstate,
	1706	+ RTA_ENCAP, RTA_ENCAP_TYPE) < 0)
	1707	+ goto nla_put_failure;
	1708	+
	1709	+ return 0;
	1710	+
	1711	+nla_put_failure:
	1712	+ return -EMSGSIZE;
	1713	+}
	1714	+EXPORT_SYMBOL_GPL(fib_nexthop_info);
	1715	+
	1716	+#if IS_ENABLED(CONFIG_IP_ROUTE_MULTIPATH) \|\| IS_ENABLED(CONFIG_IPV6)
	1717	+int fib_add_nexthop(struct sk_buff skb, const struct fib_nh_common nhc,
	1718	+ int nh_weight, u8 rt_family, u32 nh_tclassid)
	1719	+{
	1720	+ const struct net_device *dev = nhc->nhc_dev;
	1721	+ struct rtnexthop *rtnh;
	1722	+ unsigned char flags = 0;
	1723	+
	1724	+ rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
	1725	+ if (!rtnh)
	1726	+ goto nla_put_failure;
	1727	+
	1728	+ rtnh->rtnh_hops = nh_weight - 1;
	1729	+ rtnh->rtnh_ifindex = dev ? dev->ifindex : 0;
	1730	+
	1731	+ if (fib_nexthop_info(skb, nhc, rt_family, &flags, true) < 0)
	1732	+ goto nla_put_failure;
	1733	+
	1734	+ rtnh->rtnh_flags = flags;
	1735	+
	1736	+ if (nh_tclassid && nla_put_u32(skb, RTA_FLOW, nh_tclassid))
	1737	+ goto nla_put_failure;
	1738	+
	1739	+ /* length of rtnetlink header + attributes */
	1740	+ rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
	1741	+
	1742	+ return 0;
	1743	+
	1744	+nla_put_failure:
	1745	+ return -EMSGSIZE;
	1746	+}
	1747	+EXPORT_SYMBOL_GPL(fib_add_nexthop);
	1748	+#endif
	1749	+
	1750	+#ifdef CONFIG_IP_ROUTE_MULTIPATH
	1751	+static int fib_add_multipath(struct sk_buff skb, struct fib_info fi)
	1752	+{
	1753	+ struct nlattr *mp;
	1754	+
	1755	+ mp = nla_nest_start_noflag(skb, RTA_MULTIPATH);
	1756	+ if (!mp)
	1757	+ goto nla_put_failure;
	1758	+
	1759	+ if (unlikely(fi->nh)) {
	1760	+ if (nexthop_mpath_fill_node(skb, fi->nh, AF_INET) < 0)
	1761	+ goto nla_put_failure;
	1762	+ goto mp_end;
	1763	+ }
	1764	+
	1765	+ for_nexthops(fi) {
	1766	+ u32 nh_tclassid = 0;
	1767	+#ifdef CONFIG_IP_ROUTE_CLASSID
	1768	+ nh_tclassid = nh->nh_tclassid;
	1769	+#endif
	1770	+ if (fib_add_nexthop(skb, &nh->nh_common, nh->fib_nh_weight,
	1771	+ AF_INET, nh_tclassid) < 0)
	1772	+ goto nla_put_failure;
	1773	+ } endfor_nexthops(fi);
	1774	+
	1775	+mp_end:
	1776	+ nla_nest_end(skb, mp);
	1777	+
	1778	+ return 0;
	1779	+
	1780	+nla_put_failure:
	1781	+ return -EMSGSIZE;
	1782	+}
	1783	+#else
	1784	+static int fib_add_multipath(struct sk_buff skb, struct fib_info fi)
	1785	+{
	1786	+ return 0;
	1787	+}
	1788	+#endif
	1789	+
	1790	+int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
	1791	+ struct fib_rt_info *fri, unsigned int flags)
	1792	+{
	1793	+ unsigned int nhs = fib_info_num_path(fri->fi);
	1794	+ struct fib_info *fi = fri->fi;
	1795	+ u32 tb_id = fri->tb_id;
1295	1796	struct nlmsghdr *nlh;
1296	1797	struct rtmsg *rtm;
1297	1798
..	..	@@ -1301,22 +1802,22 @@
1301	1802
1302	1803	rtm = nlmsg_data(nlh);
1303	1804	rtm->rtm_family = AF_INET;
1304		- rtm->rtm_dst_len = dst_len;
	1805	+ rtm->rtm_dst_len = fri->dst_len;
1305	1806	rtm->rtm_src_len = 0;
1306		- rtm->rtm_tos = tos;
	1807	+ rtm->rtm_tos = fri->tos;
1307	1808	if (tb_id < 256)
1308	1809	rtm->rtm_table = tb_id;
1309	1810	else
1310	1811	rtm->rtm_table = RT_TABLE_COMPAT;
1311	1812	if (nla_put_u32(skb, RTA_TABLE, tb_id))
1312	1813	goto nla_put_failure;
1313		- rtm->rtm_type = type;
	1814	+ rtm->rtm_type = fri->type;
1314	1815	rtm->rtm_flags = fi->fib_flags;
1315	1816	rtm->rtm_scope = fi->fib_scope;
1316	1817	rtm->rtm_protocol = fi->fib_protocol;
1317	1818
1318	1819	if (rtm->rtm_dst_len &&
1319		- nla_put_in_addr(skb, RTA_DST, dst))
	1820	+ nla_put_in_addr(skb, RTA_DST, fri->dst))
1320	1821	goto nla_put_failure;
1321	1822	if (fi->fib_priority &&
1322	1823	nla_put_u32(skb, RTA_PRIORITY, fi->fib_priority))
..	..	@@ -1327,81 +1828,45 @@
1327	1828	if (fi->fib_prefsrc &&
1328	1829	nla_put_in_addr(skb, RTA_PREFSRC, fi->fib_prefsrc))
1329	1830	goto nla_put_failure;
1330		- if (fi->fib_nhs == 1) {
1331		- if (fi->fib_nh->nh_gw &&
1332		- nla_put_in_addr(skb, RTA_GATEWAY, fi->fib_nh->nh_gw))
1333		- goto nla_put_failure;
1334		- if (fi->fib_nh->nh_oif &&
1335		- nla_put_u32(skb, RTA_OIF, fi->fib_nh->nh_oif))
1336		- goto nla_put_failure;
1337		- if (fi->fib_nh->nh_flags & RTNH_F_LINKDOWN) {
1338		- struct in_device *in_dev;
1339	1831
1340		- rcu_read_lock();
1341		- in_dev = __in_dev_get_rcu(fi->fib_nh->nh_dev);
1342		- if (in_dev &&
1343		- IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))
1344		- rtm->rtm_flags \|= RTNH_F_DEAD;
1345		- rcu_read_unlock();
1346		- }
1347		- if (fi->fib_nh->nh_flags & RTNH_F_OFFLOAD)
1348		- rtm->rtm_flags \|= RTNH_F_OFFLOAD;
1349		-#ifdef CONFIG_IP_ROUTE_CLASSID
1350		- if (fi->fib_nh[0].nh_tclassid &&
1351		- nla_put_u32(skb, RTA_FLOW, fi->fib_nh[0].nh_tclassid))
	1832	+ if (fi->nh) {
	1833	+ if (nla_put_u32(skb, RTA_NH_ID, fi->nh->id))
1352	1834	goto nla_put_failure;
1353		-#endif
1354		- if (fi->fib_nh->nh_lwtstate &&
1355		- lwtunnel_fill_encap(skb, fi->fib_nh->nh_lwtstate) < 0)
1356		- goto nla_put_failure;
	1835	+ if (nexthop_is_blackhole(fi->nh))
	1836	+ rtm->rtm_type = RTN_BLACKHOLE;
	1837	+ if (!READ_ONCE(fi->fib_net->ipv4.sysctl_nexthop_compat_mode))
	1838	+ goto offload;
1357	1839	}
1358		-#ifdef CONFIG_IP_ROUTE_MULTIPATH
1359		- if (fi->fib_nhs > 1) {
1360		- struct rtnexthop *rtnh;
1361		- struct nlattr *mp;
1362	1840
1363		- mp = nla_nest_start(skb, RTA_MULTIPATH);
1364		- if (!mp)
	1841	+ if (nhs == 1) {
	1842	+ const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
	1843	+ unsigned char flags = 0;
	1844	+
	1845	+ if (fib_nexthop_info(skb, nhc, AF_INET, &flags, false) < 0)
1365	1846	goto nla_put_failure;
1366	1847
1367		- for_nexthops(fi) {
1368		- rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
1369		- if (!rtnh)
1370		- goto nla_put_failure;
1371		-
1372		- rtnh->rtnh_flags = nh->nh_flags & 0xFF;
1373		- if (nh->nh_flags & RTNH_F_LINKDOWN) {
1374		- struct in_device *in_dev;
1375		-
1376		- rcu_read_lock();
1377		- in_dev = __in_dev_get_rcu(nh->nh_dev);
1378		- if (in_dev &&
1379		- IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))
1380		- rtnh->rtnh_flags \|= RTNH_F_DEAD;
1381		- rcu_read_unlock();
1382		- }
1383		- rtnh->rtnh_hops = nh->nh_weight - 1;
1384		- rtnh->rtnh_ifindex = nh->nh_oif;
1385		-
1386		- if (nh->nh_gw &&
1387		- nla_put_in_addr(skb, RTA_GATEWAY, nh->nh_gw))
1388		- goto nla_put_failure;
	1848	+ rtm->rtm_flags = flags;
1389	1849	#ifdef CONFIG_IP_ROUTE_CLASSID
	1850	+ if (nhc->nhc_family == AF_INET) {
	1851	+ struct fib_nh *nh;
	1852	+
	1853	+ nh = container_of(nhc, struct fib_nh, nh_common);
1390	1854	if (nh->nh_tclassid &&
1391	1855	nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid))
1392	1856	goto nla_put_failure;
	1857	+ }
1393	1858	#endif
1394		- if (nh->nh_lwtstate &&
1395		- lwtunnel_fill_encap(skb, nh->nh_lwtstate) < 0)
1396		- goto nla_put_failure;
1397		-
1398		- /* length of rtnetlink header + attributes */
1399		- rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *) rtnh;
1400		- } endfor_nexthops(fi);
1401		-
1402		- nla_nest_end(skb, mp);
	1859	+ } else {
	1860	+ if (fib_add_multipath(skb, fi) < 0)
	1861	+ goto nla_put_failure;
1403	1862	}
1404		-#endif
	1863	+
	1864	+offload:
	1865	+ if (fri->offload)
	1866	+ rtm->rtm_flags \|= RTM_F_OFFLOAD;
	1867	+ if (fri->trap)
	1868	+ rtm->rtm_flags \|= RTM_F_TRAP;
	1869	+
1405	1870	nlmsg_end(skb, nlh);
1406	1871	return 0;
1407	1872
..	..	@@ -1440,28 +1905,26 @@
1440	1905	return ret;
1441	1906	}
1442	1907
1443		-static int call_fib_nh_notifiers(struct fib_nh *fib_nh,
	1908	+static int call_fib_nh_notifiers(struct fib_nh *nh,
1444	1909	enum fib_event_type event_type)
1445	1910	{
1446		- struct in_device *in_dev = __in_dev_get_rtnl(fib_nh->nh_dev);
	1911	+ bool ignore_link_down = ip_ignore_linkdown(nh->fib_nh_dev);
1447	1912	struct fib_nh_notifier_info info = {
1448		- .fib_nh = fib_nh,
	1913	+ .fib_nh = nh,
1449	1914	};
1450	1915
1451	1916	switch (event_type) {
1452	1917	case FIB_EVENT_NH_ADD:
1453		- if (fib_nh->nh_flags & RTNH_F_DEAD)
	1918	+ if (nh->fib_nh_flags & RTNH_F_DEAD)
1454	1919	break;
1455		- if (IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
1456		- fib_nh->nh_flags & RTNH_F_LINKDOWN)
	1920	+ if (ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN)
1457	1921	break;
1458		- return call_fib4_notifiers(dev_net(fib_nh->nh_dev), event_type,
	1922	+ return call_fib4_notifiers(dev_net(nh->fib_nh_dev), event_type,
1459	1923	&info.info);
1460	1924	case FIB_EVENT_NH_DEL:
1461		- if ((in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
1462		- fib_nh->nh_flags & RTNH_F_LINKDOWN) \|\|
1463		- (fib_nh->nh_flags & RTNH_F_DEAD))
1464		- return call_fib4_notifiers(dev_net(fib_nh->nh_dev),
	1925	+ if ((ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) \|\|
	1926	+ (nh->fib_nh_flags & RTNH_F_DEAD))
	1927	+ return call_fib4_notifiers(dev_net(nh->fib_nh_dev),
1465	1928	event_type, &info.info);
1466	1929	default:
1467	1930	break;
..	..	@@ -1480,12 +1943,12 @@
1480	1943	* - if the new MTU is greater than the PMTU, don't make any change
1481	1944	* - otherwise, unlock and set PMTU
1482	1945	*/
1483		-static void nh_update_mtu(struct fib_nh *nh, u32 new, u32 orig)
	1946	+void fib_nhc_update_mtu(struct fib_nh_common *nhc, u32 new, u32 orig)
1484	1947	{
1485	1948	struct fnhe_hash_bucket *bucket;
1486	1949	int i;
1487	1950
1488		- bucket = rcu_dereference_protected(nh->nh_exceptions, 1);
	1951	+ bucket = rcu_dereference_protected(nhc->nhc_exceptions, 1);
1489	1952	if (!bucket)
1490	1953	return;
1491	1954
..	..	@@ -1510,13 +1973,12 @@
1510	1973
1511	1974	void fib_sync_mtu(struct net_device *dev, u32 orig_mtu)
1512	1975	{
1513		- unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1514		- struct hlist_head *head = &fib_info_devhash[hash];
	1976	+ struct hlist_head *head = fib_info_devhash_bucket(dev);
1515	1977	struct fib_nh *nh;
1516	1978
1517	1979	hlist_for_each_entry(nh, head, nh_hash) {
1518		- if (nh->nh_dev == dev)
1519		- nh_update_mtu(nh, dev->mtu, orig_mtu);
	1980	+ if (nh->fib_nh_dev == dev)
	1981	+ fib_nhc_update_mtu(&nh->nh_common, dev->mtu, orig_mtu);
1520	1982	}
1521	1983	}
1522	1984
..	..	@@ -1525,15 +1987,16 @@
1525	1987	* NETDEV_DOWN 0 LINKDOWN\|DEAD Link down, not for scope host
1526	1988	* NETDEV_DOWN 1 LINKDOWN\|DEAD Last address removed
1527	1989	* NETDEV_UNREGISTER 1 LINKDOWN\|DEAD Device removed
	1990	+ *
	1991	+ * only used when fib_nh is built into fib_info
1528	1992	*/
1529	1993	int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force)
1530	1994	{
1531		- int ret = 0;
1532		- int scope = RT_SCOPE_NOWHERE;
	1995	+ struct hlist_head *head = fib_info_devhash_bucket(dev);
1533	1996	struct fib_info *prev_fi = NULL;
1534		- unsigned int hash = fib_devindex_hashfn(dev->ifindex);
1535		- struct hlist_head *head = &fib_info_devhash[hash];
	1997	+ int scope = RT_SCOPE_NOWHERE;
1536	1998	struct fib_nh *nh;
	1999	+ int ret = 0;
1537	2000
1538	2001	if (force)
1539	2002	scope = -1;
..	..	@@ -1543,22 +2006,22 @@
1543	2006	int dead;
1544	2007
1545	2008	BUG_ON(!fi->fib_nhs);
1546		- if (nh->nh_dev != dev \|\| fi == prev_fi)
	2009	+ if (nh->fib_nh_dev != dev \|\| fi == prev_fi)
1547	2010	continue;
1548	2011	prev_fi = fi;
1549	2012	dead = 0;
1550	2013	change_nexthops(fi) {
1551		- if (nexthop_nh->nh_flags & RTNH_F_DEAD)
	2014	+ if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD)
1552	2015	dead++;
1553		- else if (nexthop_nh->nh_dev == dev &&
1554		- nexthop_nh->nh_scope != scope) {
	2016	+ else if (nexthop_nh->fib_nh_dev == dev &&
	2017	+ nexthop_nh->fib_nh_scope != scope) {
1555	2018	switch (event) {
1556	2019	case NETDEV_DOWN:
1557	2020	case NETDEV_UNREGISTER:
1558		- nexthop_nh->nh_flags \|= RTNH_F_DEAD;
1559		- /* fall through */
	2021	+ nexthop_nh->fib_nh_flags \|= RTNH_F_DEAD;
	2022	+ fallthrough;
1560	2023	case NETDEV_CHANGE:
1561		- nexthop_nh->nh_flags \|= RTNH_F_LINKDOWN;
	2024	+ nexthop_nh->fib_nh_flags \|= RTNH_F_LINKDOWN;
1562	2025	break;
1563	2026	}
1564	2027	call_fib_nh_notifiers(nexthop_nh,
..	..	@@ -1567,7 +2030,7 @@
1567	2030	}
1568	2031	#ifdef CONFIG_IP_ROUTE_MULTIPATH
1569	2032	if (event == NETDEV_UNREGISTER &&
1570		- nexthop_nh->nh_dev == dev) {
	2033	+ nexthop_nh->fib_nh_dev == dev) {
1571	2034	dead = fi->fib_nhs;
1572	2035	break;
1573	2036	}
..	..	@@ -1578,7 +2041,7 @@
1578	2041	case NETDEV_DOWN:
1579	2042	case NETDEV_UNREGISTER:
1580	2043	fi->fib_flags \|= RTNH_F_DEAD;
1581		- /* fall through */
	2044	+ fallthrough;
1582	2045	case NETDEV_CHANGE:
1583	2046	fi->fib_flags \|= RTNH_F_LINKDOWN;
1584	2047	break;
..	..	@@ -1606,6 +2069,7 @@
1606	2069
1607	2070	hlist_for_each_entry_rcu(fa, fa_head, fa_list) {
1608	2071	struct fib_info *next_fi = fa->fa_info;
	2072	+ struct fib_nh_common *nhc;
1609	2073
1610	2074	if (fa->fa_slen != slen)
1611	2075	continue;
..	..	@@ -1627,8 +2091,9 @@
1627	2091	if (next_fi->fib_scope != res->scope \|\|
1628	2092	fa->fa_type != RTN_UNICAST)
1629	2093	continue;
1630		- if (!next_fi->fib_nh[0].nh_gw \|\|
1631		- next_fi->fib_nh[0].nh_scope != RT_SCOPE_LINK)
	2094	+
	2095	+ nhc = fib_info_nhc(next_fi, 0);
	2096	+ if (!nhc->nhc_gw_family \|\| nhc->nhc_scope != RT_SCOPE_LINK)
1632	2097	continue;
1633	2098
1634	2099	fib_alias_accessed(fa);
..	..	@@ -1670,11 +2135,12 @@
1670	2135	/*
1671	2136	* Dead device goes up. We wake up dead nexthops.
1672	2137	* It takes sense only on multipath routes.
	2138	+ *
	2139	+ * only used when fib_nh is built into fib_info
1673	2140	*/
1674		-int fib_sync_up(struct net_device *dev, unsigned int nh_flags)
	2141	+int fib_sync_up(struct net_device *dev, unsigned char nh_flags)
1675	2142	{
1676	2143	struct fib_info *prev_fi;
1677		- unsigned int hash;
1678	2144	struct hlist_head *head;
1679	2145	struct fib_nh *nh;
1680	2146	int ret;
..	..	@@ -1690,8 +2156,7 @@
1690	2156	}
1691	2157
1692	2158	prev_fi = NULL;
1693		- hash = fib_devindex_hashfn(dev->ifindex);
1694		- head = &fib_info_devhash[hash];
	2159	+ head = fib_info_devhash_bucket(dev);
1695	2160	ret = 0;
1696	2161
1697	2162	hlist_for_each_entry(nh, head, nh_hash) {
..	..	@@ -1699,24 +2164,24 @@
1699	2164	int alive;
1700	2165
1701	2166	BUG_ON(!fi->fib_nhs);
1702		- if (nh->nh_dev != dev \|\| fi == prev_fi)
	2167	+ if (nh->fib_nh_dev != dev \|\| fi == prev_fi)
1703	2168	continue;
1704	2169
1705	2170	prev_fi = fi;
1706	2171	alive = 0;
1707	2172	change_nexthops(fi) {
1708		- if (!(nexthop_nh->nh_flags & nh_flags)) {
	2173	+ if (!(nexthop_nh->fib_nh_flags & nh_flags)) {
1709	2174	alive++;
1710	2175	continue;
1711	2176	}
1712		- if (!nexthop_nh->nh_dev \|\|
1713		- !(nexthop_nh->nh_dev->flags & IFF_UP))
	2177	+ if (!nexthop_nh->fib_nh_dev \|\|
	2178	+ !(nexthop_nh->fib_nh_dev->flags & IFF_UP))
1714	2179	continue;
1715		- if (nexthop_nh->nh_dev != dev \|\|
	2180	+ if (nexthop_nh->fib_nh_dev != dev \|\|
1716	2181	!__in_dev_get_rtnl(dev))
1717	2182	continue;
1718	2183	alive++;
1719		- nexthop_nh->nh_flags &= ~nh_flags;
	2184	+ nexthop_nh->fib_nh_flags &= ~nh_flags;
1720	2185	call_fib_nh_notifiers(nexthop_nh, FIB_EVENT_NH_ADD);
1721	2186	} endfor_nexthops(fi)
1722	2187
..	..	@@ -1736,13 +2201,19 @@
1736	2201	{
1737	2202	int state = NUD_REACHABLE;
1738	2203
1739		- if (nh->nh_scope == RT_SCOPE_LINK) {
	2204	+ if (nh->fib_nh_scope == RT_SCOPE_LINK) {
1740	2205	struct neighbour *n;
1741	2206
1742	2207	rcu_read_lock_bh();
1743	2208
1744		- n = __ipv4_neigh_lookup_noref(nh->nh_dev,
1745		- (__force u32)nh->nh_gw);
	2209	+ if (likely(nh->fib_nh_gw_family == AF_INET))
	2210	+ n = __ipv4_neigh_lookup_noref(nh->fib_nh_dev,
	2211	+ (__force u32)nh->fib_nh_gw4);
	2212	+ else if (nh->fib_nh_gw_family == AF_INET6)
	2213	+ n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev,
	2214	+ &nh->fib_nh_gw6);
	2215	+ else
	2216	+ n = NULL;
1746	2217	if (n)
1747	2218	state = n->nud_state;
1748	2219
..	..	@@ -1758,20 +2229,27 @@
1758	2229	struct net *net = fi->fib_net;
1759	2230	bool first = false;
1760	2231
1761		- for_nexthops(fi) {
1762		- if (net->ipv4.sysctl_fib_multipath_use_neigh) {
1763		- if (!fib_good_nh(nh))
	2232	+ if (unlikely(res->fi->nh)) {
	2233	+ nexthop_path_fib_result(res, hash);
	2234	+ return;
	2235	+ }
	2236	+
	2237	+ change_nexthops(fi) {
	2238	+ if (READ_ONCE(net->ipv4.sysctl_fib_multipath_use_neigh)) {
	2239	+ if (!fib_good_nh(nexthop_nh))
1764	2240	continue;
1765	2241	if (!first) {
1766	2242	res->nh_sel = nhsel;
	2243	+ res->nhc = &nexthop_nh->nh_common;
1767	2244	first = true;
1768	2245	}
1769	2246	}
1770	2247
1771		- if (hash > atomic_read(&nh->nh_upper_bound))
	2248	+ if (hash > atomic_read(&nexthop_nh->fib_nh_upper_bound))
1772	2249	continue;
1773	2250
1774	2251	res->nh_sel = nhsel;
	2252	+ res->nhc = &nexthop_nh->nh_common;
1775	2253	return;
1776	2254	} endfor_nexthops(fi);
1777	2255	}
..	..	@@ -1784,7 +2262,7 @@
1784	2262	goto check_saddr;
1785	2263
1786	2264	#ifdef CONFIG_IP_ROUTE_MULTIPATH
1787		- if (res->fi->fib_nhs > 1) {
	2265	+ if (fib_info_num_path(res->fi) > 1) {
1788	2266	int h = fib_multipath_hash(net, fl4, skb, NULL);
1789	2267
1790	2268	fib_select_multipath(res, h);
..	..	@@ -1798,5 +2276,5 @@
1798	2276
1799	2277	check_saddr:
1800	2278	if (!fl4->saddr)
1801		- fl4->saddr = FIB_RES_PREFSRC(net, *res);
	2279	+ fl4->saddr = fib_result_prefsrc(net, res);
1802	2280	}