projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mlxsw: spectrum_router: Move mlxsw_sp_netdev_ipip_type()
[linux-2.6-block.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum_router.c
CommitLineData
464dce18
IS		 1/*
2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
6ddb7426 3 * Copyright (c) 2016-2017 Mellanox Technologies. All rights reserved.
464dce18
IS		 4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 * Copyright (c) 2016 Ido Schimmel <idosch@mellanox.com>
c723c735 6 * Copyright (c) 2016 Yotam Gigi <yotamg@mellanox.com>
6ddb7426 7 * Copyright (c) 2017 Petr Machata <petrm@mellanox.com>
464dce18
IS		 8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the names of the copyright holders nor the names of its
18 * contributors may be used to endorse or promote products derived from
19 * this software without specific prior written permission.
20 *
21 * Alternatively, this software may be distributed under the terms of the
22 * GNU General Public License ("GPL") version 2 as published by the Free
23 * Software Foundation.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
29 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38#include <linux/kernel.h>
39#include <linux/types.h>
5e9c16cc
JP		 40#include <linux/rhashtable.h>
41#include <linux/bitops.h>
42#include <linux/in6.h>
c723c735 43#include <linux/notifier.h>
df6dd79b 44#include <linux/inetdevice.h>
9db032bb 45#include <linux/netdevice.h>
03ea01e9 46#include <linux/if_bridge.h>
b5f3e0d4 47#include <linux/socket.h>
428b851f 48#include <linux/route.h>
c723c735 49#include <net/netevent.h>
6cf3c971
JP		 50#include <net/neighbour.h>
51#include <net/arp.h>
b45f64d1 52#include <net/ip_fib.h>
583419fd 53#include <net/ip6_fib.h>
5d7bfd14 54#include <net/fib_rules.h>
6ddb7426 55#include <net/ip_tunnels.h>
57837885 56#include <net/l3mdev.h>
5ea1237f 57#include <net/addrconf.h>
d5eb89cf
AS		 58#include <net/ndisc.h>
59#include <net/ipv6.h>
04b1d4e5 60#include <net/fib_notifier.h>
464dce18
IS		 61
62#include "spectrum.h"
63#include "core.h"
64#include "reg.h"
e0c0afd8
AS		 65#include "spectrum_cnt.h"
66#include "spectrum_dpipe.h"
38ebc0f4 67#include "spectrum_ipip.h"
d42b0965
YG		 68#include "spectrum_mr.h"
69#include "spectrum_mr_tcam.h"
e0c0afd8 70#include "spectrum_router.h"
464dce18 71
9011b677
IS		 72struct mlxsw_sp_vr;
73struct mlxsw_sp_lpm_tree;
e4f3c1c1 74struct mlxsw_sp_rif_ops;
9011b677
IS		 75
76struct mlxsw_sp_router {
77 struct mlxsw_sp *mlxsw_sp;
5f9efffb 78 struct mlxsw_sp_rif **rifs;
9011b677
IS		 79 struct mlxsw_sp_vr *vrs;
80 struct rhashtable neigh_ht;
81 struct rhashtable nexthop_group_ht;
82 struct rhashtable nexthop_ht;
dbe4598c 83 struct list_head nexthop_list;
9011b677
IS		 84 struct {
85 struct mlxsw_sp_lpm_tree *trees;
86 unsigned int tree_count;
87 } lpm;
88 struct {
89 struct delayed_work dw;
90 unsigned long interval; /* ms */
91 } neighs_update;
92 struct delayed_work nexthop_probe_dw;
93#define MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL 5000 /* ms */
94 struct list_head nexthop_neighs_list;
1012b9ac 95 struct list_head ipip_list;
9011b677 96 bool aborted;
7e39d115 97 struct notifier_block fib_nb;
e4f3c1c1 98 const struct mlxsw_sp_rif_ops **rif_ops_arr;
38ebc0f4 99 const struct mlxsw_sp_ipip_ops **ipip_ops_arr;
9011b677
IS		 100};
101
4724ba56
IS		 102struct mlxsw_sp_rif {
103 struct list_head nexthop_list;
104 struct list_head neigh_list;
105 struct net_device *dev;
a1107487 106 struct mlxsw_sp_fid *fid;
4724ba56
IS		 107 unsigned char addr[ETH_ALEN];
108 int mtu;
bf95233e 109 u16 rif_index;
6913229e 110 u16 vr_id;
e4f3c1c1
IS		 111 const struct mlxsw_sp_rif_ops *ops;
112 struct mlxsw_sp *mlxsw_sp;
113
e0c0afd8
AS		 114 unsigned int counter_ingress;
115 bool counter_ingress_valid;
116 unsigned int counter_egress;
117 bool counter_egress_valid;
4724ba56
IS		 118};
119
e4f3c1c1
IS		 120struct mlxsw_sp_rif_params {
121 struct net_device *dev;
122 union {
123 u16 system_port;
124 u16 lag_id;
125 };
126 u16 vid;
127 bool lag;
128};
129
4d93ceeb
IS		 130struct mlxsw_sp_rif_subport {
131 struct mlxsw_sp_rif common;
132 union {
133 u16 system_port;
134 u16 lag_id;
135 };
136 u16 vid;
137 bool lag;
138};
139
6ddb7426
PM		 140struct mlxsw_sp_rif_ipip_lb {
141 struct mlxsw_sp_rif common;
142 struct mlxsw_sp_rif_ipip_lb_config lb_config;
143 u16 ul_vr_id; /* Reserved for Spectrum-2. */
144};
145
146struct mlxsw_sp_rif_params_ipip_lb {
147 struct mlxsw_sp_rif_params common;
148 struct mlxsw_sp_rif_ipip_lb_config lb_config;
149};
150
e4f3c1c1
IS		 151struct mlxsw_sp_rif_ops {
152 enum mlxsw_sp_rif_type type;
153 size_t rif_size;
154
155 void (*setup)(struct mlxsw_sp_rif *rif,
156 const struct mlxsw_sp_rif_params *params);
157 int (*configure)(struct mlxsw_sp_rif *rif);
158 void (*deconfigure)(struct mlxsw_sp_rif *rif);
159 struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif);
160};
161
e0c0afd8
AS		 162static unsigned int *
163mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif,
164 enum mlxsw_sp_rif_counter_dir dir)
165{
166 switch (dir) {
167 case MLXSW_SP_RIF_COUNTER_EGRESS:
168 return &rif->counter_egress;
169 case MLXSW_SP_RIF_COUNTER_INGRESS:
170 return &rif->counter_ingress;
171 }
172 return NULL;
173}
174
175static bool
176mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif,
177 enum mlxsw_sp_rif_counter_dir dir)
178{
179 switch (dir) {
180 case MLXSW_SP_RIF_COUNTER_EGRESS:
181 return rif->counter_egress_valid;
182 case MLXSW_SP_RIF_COUNTER_INGRESS:
183 return rif->counter_ingress_valid;
184 }
185 return false;
186}
187
188static void
189mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
190 enum mlxsw_sp_rif_counter_dir dir,
191 bool valid)
192{
193 switch (dir) {
194 case MLXSW_SP_RIF_COUNTER_EGRESS:
195 rif->counter_egress_valid = valid;
196 break;
197 case MLXSW_SP_RIF_COUNTER_INGRESS:
198 rif->counter_ingress_valid = valid;
199 break;
200 }
201}
202
203static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
204 unsigned int counter_index, bool enable,
205 enum mlxsw_sp_rif_counter_dir dir)
206{
207 char ritr_pl[MLXSW_REG_RITR_LEN];
208 bool is_egress = false;
209 int err;
210
211 if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
212 is_egress = true;
213 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
214 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
215 if (err)
216 return err;
217
218 mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
219 is_egress);
220 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
221}
222
223int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
224 struct mlxsw_sp_rif *rif,
225 enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
226{
227 char ricnt_pl[MLXSW_REG_RICNT_LEN];
228 unsigned int *p_counter_index;
229 bool valid;
230 int err;
231
232 valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
233 if (!valid)
234 return -EINVAL;
235
236 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
237 if (!p_counter_index)
238 return -EINVAL;
239 mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
240 MLXSW_REG_RICNT_OPCODE_NOP);
241 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
242 if (err)
243 return err;
244 *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
245 return 0;
246}
247
248static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
249 unsigned int counter_index)
250{
251 char ricnt_pl[MLXSW_REG_RICNT_LEN];
252
253 mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
254 MLXSW_REG_RICNT_OPCODE_CLEAR);
255 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
256}
257
258int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp *mlxsw_sp,
259 struct mlxsw_sp_rif *rif,
260 enum mlxsw_sp_rif_counter_dir dir)
261{
262 unsigned int *p_counter_index;
263 int err;
264
265 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
266 if (!p_counter_index)
267 return -EINVAL;
268 err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
269 p_counter_index);
270 if (err)
271 return err;
272
273 err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
274 if (err)
275 goto err_counter_clear;
276
277 err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
278 *p_counter_index, true, dir);
279 if (err)
280 goto err_counter_edit;
281 mlxsw_sp_rif_counter_valid_set(rif, dir, true);
282 return 0;
283
284err_counter_edit:
285err_counter_clear:
286 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
287 *p_counter_index);
288 return err;
289}
290
291void mlxsw_sp_rif_counter_free(struct mlxsw_sp *mlxsw_sp,
292 struct mlxsw_sp_rif *rif,
293 enum mlxsw_sp_rif_counter_dir dir)
294{
295 unsigned int *p_counter_index;
296
6b1206bb
AS		 297 if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
298 return;
299
e0c0afd8
AS		 300 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
301 if (WARN_ON(!p_counter_index))
302 return;
303 mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
304 *p_counter_index, false, dir);
305 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
306 *p_counter_index);
307 mlxsw_sp_rif_counter_valid_set(rif, dir, false);
308}
309
e4f3c1c1
IS		 310static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
311{
312 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
313 struct devlink *devlink;
314
315 devlink = priv_to_devlink(mlxsw_sp->core);
316 if (!devlink_dpipe_table_counter_enabled(devlink,
317 MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
318 return;
319 mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
320}
321
322static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
323{
324 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
325
326 mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
327}
328
4724ba56
IS		 329static struct mlxsw_sp_rif *
330mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
331 const struct net_device *dev);
332
7dcc18ad 333#define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
9011b677
IS		 334
335struct mlxsw_sp_prefix_usage {
336 DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
337};
338
53342023
JP		 339#define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
340 for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
341
342static bool
343mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
344 struct mlxsw_sp_prefix_usage *prefix_usage2)
345{
346 return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
347}
348
6b75c480
JP		 349static bool
350mlxsw_sp_prefix_usage_none(struct mlxsw_sp_prefix_usage *prefix_usage)
351{
352 struct mlxsw_sp_prefix_usage prefix_usage_none = {{ 0 } };
353
354 return mlxsw_sp_prefix_usage_eq(prefix_usage, &prefix_usage_none);
355}
356
357static void
358mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
359 struct mlxsw_sp_prefix_usage *prefix_usage2)
360{
361 memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
362}
363
5e9c16cc
JP		 364static void
365mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
366 unsigned char prefix_len)
367{
368 set_bit(prefix_len, prefix_usage->b);
369}
370
371static void
372mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
373 unsigned char prefix_len)
374{
375 clear_bit(prefix_len, prefix_usage->b);
376}
377
378struct mlxsw_sp_fib_key {
379 unsigned char addr[sizeof(struct in6_addr)];
380 unsigned char prefix_len;
381};
382
61c503f9
JP		 383enum mlxsw_sp_fib_entry_type {
384 MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
385 MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
386 MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
4607f6d2
PM		 387
388 /* This is a special case of local delivery, where a packet should be
389 * decapsulated on reception. Note that there is no corresponding ENCAP,
390 * because that's a type of next hop, not of FIB entry. (There can be
391 * several next hops in a REMOTE entry, and some of them may be
392 * encapsulating entries.)
393 */
394 MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP,
61c503f9
JP		 395};
396
a7ff87ac 397struct mlxsw_sp_nexthop_group;
9011b677 398struct mlxsw_sp_fib;
a7ff87ac 399
9aecce1c
IS		 400struct mlxsw_sp_fib_node {
401 struct list_head entry_list;
b45f64d1 402 struct list_head list;
9aecce1c 403 struct rhash_head ht_node;
76610ebb 404 struct mlxsw_sp_fib *fib;
5e9c16cc 405 struct mlxsw_sp_fib_key key;
9aecce1c
IS		 406};
407
4607f6d2
PM		 408struct mlxsw_sp_fib_entry_decap {
409 struct mlxsw_sp_ipip_entry *ipip_entry;
410 u32 tunnel_index;
411};
412
9aecce1c
IS		 413struct mlxsw_sp_fib_entry {
414 struct list_head list;
415 struct mlxsw_sp_fib_node *fib_node;
61c503f9 416 enum mlxsw_sp_fib_entry_type type;
a7ff87ac
JP		 417 struct list_head nexthop_group_node;
418 struct mlxsw_sp_nexthop_group *nh_group;
4607f6d2 419 struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */
5e9c16cc
JP		 420};
421
4f1c7f1f
IS		 422struct mlxsw_sp_fib4_entry {
423 struct mlxsw_sp_fib_entry common;
424 u32 tb_id;
425 u32 prio;
426 u8 tos;
427 u8 type;
428};
429
428b851f
IS		 430struct mlxsw_sp_fib6_entry {
431 struct mlxsw_sp_fib_entry common;
432 struct list_head rt6_list;
433 unsigned int nrt6;
434};
435
436struct mlxsw_sp_rt6 {
437 struct list_head list;
438 struct rt6_info *rt;
439};
440
9011b677
IS		 441struct mlxsw_sp_lpm_tree {
442 u8 id; /* tree ID */
443 unsigned int ref_count;
444 enum mlxsw_sp_l3proto proto;
445 struct mlxsw_sp_prefix_usage prefix_usage;
446};
447
5e9c16cc
JP		 448struct mlxsw_sp_fib {
449 struct rhashtable ht;
9aecce1c 450 struct list_head node_list;
76610ebb
IS		 451 struct mlxsw_sp_vr *vr;
452 struct mlxsw_sp_lpm_tree *lpm_tree;
5e9c16cc
JP		 453 unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
454 struct mlxsw_sp_prefix_usage prefix_usage;
76610ebb 455 enum mlxsw_sp_l3proto proto;
5e9c16cc
JP		 456};
457
9011b677
IS		 458struct mlxsw_sp_vr {
459 u16 id; /* virtual router ID */
460 u32 tb_id; /* kernel fib table id */
461 unsigned int rif_count;
462 struct mlxsw_sp_fib *fib4;
a3d9bc50 463 struct mlxsw_sp_fib *fib6;
d42b0965 464 struct mlxsw_sp_mr_table *mr4_table;
9011b677
IS		 465};
466
9aecce1c 467static const struct rhashtable_params mlxsw_sp_fib_ht_params;
5e9c16cc 468
76610ebb
IS		 469static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp_vr *vr,
470 enum mlxsw_sp_l3proto proto)
5e9c16cc
JP		 471{
472 struct mlxsw_sp_fib *fib;
473 int err;
474
475 fib = kzalloc(sizeof(*fib), GFP_KERNEL);
476 if (!fib)
477 return ERR_PTR(-ENOMEM);
478 err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
479 if (err)
480 goto err_rhashtable_init;
9aecce1c 481 INIT_LIST_HEAD(&fib->node_list);
76610ebb
IS		 482 fib->proto = proto;
483 fib->vr = vr;
5e9c16cc
JP		 484 return fib;
485
486err_rhashtable_init:
487 kfree(fib);
488 return ERR_PTR(err);
489}
490
491static void mlxsw_sp_fib_destroy(struct mlxsw_sp_fib *fib)
492{
9aecce1c 493 WARN_ON(!list_empty(&fib->node_list));
76610ebb 494 WARN_ON(fib->lpm_tree);
5e9c16cc
JP		 495 rhashtable_destroy(&fib->ht);
496 kfree(fib);
497}
498
53342023 499static struct mlxsw_sp_lpm_tree *
382dbb40 500mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
53342023
JP		 501{
502 static struct mlxsw_sp_lpm_tree *lpm_tree;
503 int i;
504
9011b677
IS		 505 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
506 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
382dbb40
IS		 507 if (lpm_tree->ref_count == 0)
508 return lpm_tree;
53342023
JP		 509 }
510 return NULL;
511}
512
513static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
514 struct mlxsw_sp_lpm_tree *lpm_tree)
515{
516 char ralta_pl[MLXSW_REG_RALTA_LEN];
517
1a9234e6
IS		 518 mlxsw_reg_ralta_pack(ralta_pl, true,
519 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
520 lpm_tree->id);
53342023
JP		 521 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
522}
523
cc702670
IS		 524static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
525 struct mlxsw_sp_lpm_tree *lpm_tree)
53342023
JP		 526{
527 char ralta_pl[MLXSW_REG_RALTA_LEN];
528
1a9234e6
IS		 529 mlxsw_reg_ralta_pack(ralta_pl, false,
530 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
531 lpm_tree->id);
cc702670 532 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
53342023
JP		 533}
534
535static int
536mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
537 struct mlxsw_sp_prefix_usage *prefix_usage,
538 struct mlxsw_sp_lpm_tree *lpm_tree)
539{
540 char ralst_pl[MLXSW_REG_RALST_LEN];
541 u8 root_bin = 0;
542 u8 prefix;
543 u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
544
545 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
546 root_bin = prefix;
547
548 mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
549 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
550 if (prefix == 0)
551 continue;
552 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
553 MLXSW_REG_RALST_BIN_NO_CHILD);
554 last_prefix = prefix;
555 }
556 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
557}
558
559static struct mlxsw_sp_lpm_tree *
560mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
561 struct mlxsw_sp_prefix_usage *prefix_usage,
382dbb40 562 enum mlxsw_sp_l3proto proto)
53342023
JP		 563{
564 struct mlxsw_sp_lpm_tree *lpm_tree;
565 int err;
566
382dbb40 567 lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
53342023
JP		 568 if (!lpm_tree)
569 return ERR_PTR(-EBUSY);
570 lpm_tree->proto = proto;
571 err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
572 if (err)
573 return ERR_PTR(err);
574
575 err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
576 lpm_tree);
577 if (err)
578 goto err_left_struct_set;
2083d367
JP		 579 memcpy(&lpm_tree->prefix_usage, prefix_usage,
580 sizeof(lpm_tree->prefix_usage));
53342023
JP		 581 return lpm_tree;
582
583err_left_struct_set:
584 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
585 return ERR_PTR(err);
586}
587
cc702670
IS		 588static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
589 struct mlxsw_sp_lpm_tree *lpm_tree)
53342023 590{
cc702670 591 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
53342023
JP		 592}
593
594static struct mlxsw_sp_lpm_tree *
595mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
596 struct mlxsw_sp_prefix_usage *prefix_usage,
382dbb40 597 enum mlxsw_sp_l3proto proto)
53342023
JP		 598{
599 struct mlxsw_sp_lpm_tree *lpm_tree;
600 int i;
601
9011b677
IS		 602 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
603 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
8b99becd
JP		 604 if (lpm_tree->ref_count != 0 &&
605 lpm_tree->proto == proto &&
53342023
JP		 606 mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
607 prefix_usage))
fc922bb0 608 return lpm_tree;
53342023 609 }
fc922bb0
IS		 610 return mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage, proto);
611}
53342023 612
fc922bb0
IS		 613static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree)
614{
53342023 615 lpm_tree->ref_count++;
53342023
JP		 616}
617
cc702670
IS		 618static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
619 struct mlxsw_sp_lpm_tree *lpm_tree)
53342023
JP		 620{
621 if (--lpm_tree->ref_count == 0)
cc702670 622 mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
53342023
JP		 623}
624
d7a60306 625#define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
8494ab06
IS		 626
627static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
53342023
JP		 628{
629 struct mlxsw_sp_lpm_tree *lpm_tree;
8494ab06 630 u64 max_trees;
53342023
JP		 631 int i;
632
8494ab06
IS		 633 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
634 return -EIO;
635
636 max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
9011b677
IS		 637 mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
638 mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
8494ab06
IS		 639 sizeof(struct mlxsw_sp_lpm_tree),
640 GFP_KERNEL);
9011b677 641 if (!mlxsw_sp->router->lpm.trees)
8494ab06
IS		 642 return -ENOMEM;
643
9011b677
IS		 644 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
645 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
53342023
JP		 646 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
647 }
8494ab06
IS		 648
649 return 0;
650}
651
652static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
653{
9011b677 654 kfree(mlxsw_sp->router->lpm.trees);
53342023
JP		 655}
656
76610ebb
IS		 657static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
658{
d42b0965 659 return !!vr->fib4 || !!vr->fib6 || !!vr->mr4_table;
76610ebb
IS		 660}
661
6b75c480
JP		 662static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
663{
664 struct mlxsw_sp_vr *vr;
665 int i;
666
c1a38311 667 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 668 vr = &mlxsw_sp->router->vrs[i];
76610ebb 669 if (!mlxsw_sp_vr_is_used(vr))
6b75c480
JP		 670 return vr;
671 }
672 return NULL;
673}
674
675static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
0adb214b 676 const struct mlxsw_sp_fib *fib, u8 tree_id)
6b75c480
JP		 677{
678 char raltb_pl[MLXSW_REG_RALTB_LEN];
679
76610ebb
IS		 680 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
681 (enum mlxsw_reg_ralxx_protocol) fib->proto,
0adb214b 682 tree_id);
6b75c480
JP		 683 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
684}
685
686static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
76610ebb 687 const struct mlxsw_sp_fib *fib)
6b75c480
JP		 688{
689 char raltb_pl[MLXSW_REG_RALTB_LEN];
690
691 /* Bind to tree 0 which is default */
76610ebb
IS		 692 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
693 (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
6b75c480
JP		 694 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
695}
696
697static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
698{
7e50d435
YG		 699 /* For our purpose, squash main, default and local tables into one */
700 if (tb_id == RT_TABLE_LOCAL || tb_id == RT_TABLE_DEFAULT)
6b75c480
JP		 701 tb_id = RT_TABLE_MAIN;
702 return tb_id;
703}
704
705static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
76610ebb 706 u32 tb_id)
6b75c480
JP		 707{
708 struct mlxsw_sp_vr *vr;
709 int i;
710
711 tb_id = mlxsw_sp_fix_tb_id(tb_id);
9497c042 712
c1a38311 713 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 714 vr = &mlxsw_sp->router->vrs[i];
76610ebb 715 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
6b75c480
JP		 716 return vr;
717 }
718 return NULL;
719}
720
76610ebb
IS		 721static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
722 enum mlxsw_sp_l3proto proto)
723{
724 switch (proto) {
725 case MLXSW_SP_L3_PROTO_IPV4:
726 return vr->fib4;
727 case MLXSW_SP_L3_PROTO_IPV6:
a3d9bc50 728 return vr->fib6;
76610ebb
IS		 729 }
730 return NULL;
731}
732
6b75c480 733static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
76610ebb 734 u32 tb_id)
6b75c480 735{
6b75c480 736 struct mlxsw_sp_vr *vr;
a3d9bc50 737 int err;
6b75c480
JP		 738
739 vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
740 if (!vr)
741 return ERR_PTR(-EBUSY);
76610ebb
IS		 742 vr->fib4 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV4);
743 if (IS_ERR(vr->fib4))
744 return ERR_CAST(vr->fib4);
a3d9bc50
IS		 745 vr->fib6 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV6);
746 if (IS_ERR(vr->fib6)) {
747 err = PTR_ERR(vr->fib6);
748 goto err_fib6_create;
749 }
d42b0965
YG		 750 vr->mr4_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
751 MLXSW_SP_L3_PROTO_IPV4);
752 if (IS_ERR(vr->mr4_table)) {
753 err = PTR_ERR(vr->mr4_table);
754 goto err_mr_table_create;
755 }
6b75c480 756 vr->tb_id = tb_id;
6b75c480 757 return vr;
a3d9bc50 758
d42b0965
YG		 759err_mr_table_create:
760 mlxsw_sp_fib_destroy(vr->fib6);
761 vr->fib6 = NULL;
a3d9bc50
IS		 762err_fib6_create:
763 mlxsw_sp_fib_destroy(vr->fib4);
764 vr->fib4 = NULL;
765 return ERR_PTR(err);
6b75c480
JP		 766}
767
76610ebb 768static void mlxsw_sp_vr_destroy(struct mlxsw_sp_vr *vr)
6b75c480 769{
d42b0965
YG		 770 mlxsw_sp_mr_table_destroy(vr->mr4_table);
771 vr->mr4_table = NULL;
a3d9bc50
IS		 772 mlxsw_sp_fib_destroy(vr->fib6);
773 vr->fib6 = NULL;
76610ebb
IS		 774 mlxsw_sp_fib_destroy(vr->fib4);
775 vr->fib4 = NULL;
6b75c480
JP		 776}
777
76610ebb 778static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id)
6b75c480
JP		 779{
780 struct mlxsw_sp_vr *vr;
6b75c480
JP		 781
782 tb_id = mlxsw_sp_fix_tb_id(tb_id);
76610ebb
IS		 783 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
784 if (!vr)
785 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id);
6b75c480
JP		 786 return vr;
787}
788
76610ebb 789static void mlxsw_sp_vr_put(struct mlxsw_sp_vr *vr)
6b75c480 790{
a3d9bc50 791 if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
d42b0965
YG		 792 list_empty(&vr->fib6->node_list) &&
793 mlxsw_sp_mr_table_empty(vr->mr4_table))
76610ebb 794 mlxsw_sp_vr_destroy(vr);
6b75c480
JP		 795}
796
fc922bb0
IS		 797static bool
798mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr,
799 enum mlxsw_sp_l3proto proto, u8 tree_id)
800{
801 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
802
803 if (!mlxsw_sp_vr_is_used(vr))
804 return false;
805 if (fib->lpm_tree && fib->lpm_tree->id == tree_id)
806 return true;
807 return false;
808}
809
810static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
811 struct mlxsw_sp_fib *fib,
812 struct mlxsw_sp_lpm_tree *new_tree)
813{
814 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
815 int err;
816
817 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
818 if (err)
819 return err;
820 fib->lpm_tree = new_tree;
821 mlxsw_sp_lpm_tree_hold(new_tree);
822 mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
823 return 0;
824}
825
826static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
827 struct mlxsw_sp_fib *fib,
828 struct mlxsw_sp_lpm_tree *new_tree)
829{
830 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
831 enum mlxsw_sp_l3proto proto = fib->proto;
832 u8 old_id, new_id = new_tree->id;
833 struct mlxsw_sp_vr *vr;
834 int i, err;
835
836 if (!old_tree)
837 goto no_replace;
838 old_id = old_tree->id;
839
840 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
841 vr = &mlxsw_sp->router->vrs[i];
842 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id))
843 continue;
844 err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
845 mlxsw_sp_vr_fib(vr, proto),
846 new_tree);
847 if (err)
848 goto err_tree_replace;
849 }
850
851 return 0;
852
853err_tree_replace:
854 for (i--; i >= 0; i--) {
855 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id))
856 continue;
857 mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
858 mlxsw_sp_vr_fib(vr, proto),
859 old_tree);
860 }
861 return err;
862
863no_replace:
864 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
865 if (err)
866 return err;
867 fib->lpm_tree = new_tree;
868 mlxsw_sp_lpm_tree_hold(new_tree);
869 return 0;
870}
871
872static void
873mlxsw_sp_vrs_prefixes(struct mlxsw_sp *mlxsw_sp,
874 enum mlxsw_sp_l3proto proto,
875 struct mlxsw_sp_prefix_usage *req_prefix_usage)
876{
877 int i;
878
879 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
880 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
881 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
882 unsigned char prefix;
883
884 if (!mlxsw_sp_vr_is_used(vr))
885 continue;
886 mlxsw_sp_prefix_usage_for_each(prefix, &fib->prefix_usage)
887 mlxsw_sp_prefix_usage_set(req_prefix_usage, prefix);
888 }
889}
890
9497c042 891static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
6b75c480
JP		 892{
893 struct mlxsw_sp_vr *vr;
c1a38311 894 u64 max_vrs;
6b75c480
JP		 895 int i;
896
c1a38311 897 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
9497c042
NF		 898 return -EIO;
899
c1a38311 900 max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
9011b677
IS		 901 mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
902 GFP_KERNEL);
903 if (!mlxsw_sp->router->vrs)
9497c042
NF		 904 return -ENOMEM;
905
c1a38311 906 for (i = 0; i < max_vrs; i++) {
9011b677 907 vr = &mlxsw_sp->router->vrs[i];
6b75c480
JP		 908 vr->id = i;
909 }
9497c042
NF		 910
911 return 0;
912}
913
ac571de9
IS		 914static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
915
9497c042
NF		 916static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
917{
3057224e
IS		 918 /* At this stage we're guaranteed not to have new incoming
919 * FIB notifications and the work queue is free from FIBs
920 * sitting on top of mlxsw netdevs. However, we can still
921 * have other FIBs queued. Flush the queue before flushing
922 * the device's tables. No need for locks, as we're the only
923 * writer.
924 */
925 mlxsw_core_flush_owq();
ac571de9 926 mlxsw_sp_router_fib_flush(mlxsw_sp);
9011b677 927 kfree(mlxsw_sp->router->vrs);
6b75c480
JP		 928}
929
6ddb7426
PM		 930static struct net_device *
931__mlxsw_sp_ipip_netdev_ul_dev_get(const struct net_device *ol_dev)
932{
933 struct ip_tunnel *tun = netdev_priv(ol_dev);
934 struct net *net = dev_net(ol_dev);
935
936 return __dev_get_by_index(net, tun->parms.link);
937}
938
939static u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev)
940{
941 struct net_device *d = __mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
942
943 if (d)
944 return l3mdev_fib_table(d) ? : RT_TABLE_MAIN;
945 else
946 return l3mdev_fib_table(ol_dev) ? : RT_TABLE_MAIN;
947}
948
1012b9ac
PM		 949static struct mlxsw_sp_rif *
950mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
951 const struct mlxsw_sp_rif_params *params);
952
953static struct mlxsw_sp_rif_ipip_lb *
954mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp,
955 enum mlxsw_sp_ipip_type ipipt,
956 struct net_device *ol_dev)
957{
958 struct mlxsw_sp_rif_params_ipip_lb lb_params;
959 const struct mlxsw_sp_ipip_ops *ipip_ops;
960 struct mlxsw_sp_rif *rif;
961
962 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
963 lb_params = (struct mlxsw_sp_rif_params_ipip_lb) {
964 .common.dev = ol_dev,
965 .common.lag = false,
966 .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev),
967 };
968
969 rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common);
970 if (IS_ERR(rif))
971 return ERR_CAST(rif);
972 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
973}
974
975static struct mlxsw_sp_ipip_entry *
976mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp,
977 enum mlxsw_sp_ipip_type ipipt,
978 struct net_device *ol_dev)
979{
980 struct mlxsw_sp_ipip_entry *ipip_entry;
981 struct mlxsw_sp_ipip_entry *ret = NULL;
982
983 ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL);
984 if (!ipip_entry)
985 return ERR_PTR(-ENOMEM);
986
987 ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt,
988 ol_dev);
989 if (IS_ERR(ipip_entry->ol_lb)) {
990 ret = ERR_CAST(ipip_entry->ol_lb);
991 goto err_ol_ipip_lb_create;
992 }
993
994 ipip_entry->ipipt = ipipt;
995 ipip_entry->ol_dev = ol_dev;
996
997 return ipip_entry;
998
999err_ol_ipip_lb_create:
1000 kfree(ipip_entry);
1001 return ret;
1002}
1003
1004static void
1005mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp_ipip_entry *ipip_entry)
1006{
1007 WARN_ON(ipip_entry->ref_count > 0);
1008 mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
1009 kfree(ipip_entry);
1010}
1011
1012static __be32
1013mlxsw_sp_ipip_netdev_saddr4(const struct net_device *ol_dev)
1014{
1015 struct ip_tunnel *tun = netdev_priv(ol_dev);
1016
1017 return tun->parms.iph.saddr;
1018}
1019
1020union mlxsw_sp_l3addr
1021mlxsw_sp_ipip_netdev_saddr(enum mlxsw_sp_l3proto proto,
1022 const struct net_device *ol_dev)
1023{
1024 switch (proto) {
1025 case MLXSW_SP_L3_PROTO_IPV4:
1026 return (union mlxsw_sp_l3addr) {
1027 .addr4 = mlxsw_sp_ipip_netdev_saddr4(ol_dev),
1028 };
1029 case MLXSW_SP_L3_PROTO_IPV6:
1030 break;
1031 };
1032
1033 WARN_ON(1);
1034 return (union mlxsw_sp_l3addr) {
1035 .addr4 = 0,
1036 };
1037}
1038
ee954d1a
PM		 1039__be32 mlxsw_sp_ipip_netdev_daddr4(const struct net_device *ol_dev)
1040{
1041 struct ip_tunnel *tun = netdev_priv(ol_dev);
1042
1043 return tun->parms.iph.daddr;
1044}
1045
1046union mlxsw_sp_l3addr
1047mlxsw_sp_ipip_netdev_daddr(enum mlxsw_sp_l3proto proto,
1048 const struct net_device *ol_dev)
1049{
1050 switch (proto) {
1051 case MLXSW_SP_L3_PROTO_IPV4:
1052 return (union mlxsw_sp_l3addr) {
1053 .addr4 = mlxsw_sp_ipip_netdev_daddr4(ol_dev),
1054 };
1055 case MLXSW_SP_L3_PROTO_IPV6:
1056 break;
1057 };
1058
1059 WARN_ON(1);
1060 return (union mlxsw_sp_l3addr) {
1061 .addr4 = 0,
1062 };
1063}
1064
1012b9ac
PM		 1065static bool mlxsw_sp_l3addr_eq(const union mlxsw_sp_l3addr *addr1,
1066 const union mlxsw_sp_l3addr *addr2)
1067{
1068 return !memcmp(addr1, addr2, sizeof(*addr1));
1069}
1070
1071static bool
1072mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp,
1073 const enum mlxsw_sp_l3proto ul_proto,
1074 union mlxsw_sp_l3addr saddr,
1075 u32 ul_tb_id,
1076 struct mlxsw_sp_ipip_entry *ipip_entry)
1077{
1078 u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1079 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1080 union mlxsw_sp_l3addr tun_saddr;
1081
1082 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1083 return false;
1084
1085 tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1086 return tun_ul_tb_id == ul_tb_id &&
1087 mlxsw_sp_l3addr_eq(&tun_saddr, &saddr);
1088}
1089
4607f6d2
PM		 1090static int
1091mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp,
1092 struct mlxsw_sp_fib_entry *fib_entry,
1093 struct mlxsw_sp_ipip_entry *ipip_entry)
1094{
1095 u32 tunnel_index;
1096 int err;
1097
1098 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, 1, &tunnel_index);
1099 if (err)
1100 return err;
1101
1102 ipip_entry->decap_fib_entry = fib_entry;
1103 fib_entry->decap.ipip_entry = ipip_entry;
1104 fib_entry->decap.tunnel_index = tunnel_index;
1105 return 0;
1106}
1107
1108static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp,
1109 struct mlxsw_sp_fib_entry *fib_entry)
1110{
1111 /* Unlink this node from the IPIP entry that it's the decap entry of. */
1112 fib_entry->decap.ipip_entry->decap_fib_entry = NULL;
1113 fib_entry->decap.ipip_entry = NULL;
1114 mlxsw_sp_kvdl_free(mlxsw_sp, fib_entry->decap.tunnel_index);
1115}
1116
1cc38fb1
PM		 1117static struct mlxsw_sp_fib_node *
1118mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
1119 size_t addr_len, unsigned char prefix_len);
4607f6d2
PM		 1120static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1121 struct mlxsw_sp_fib_entry *fib_entry);
1122
1123static void
1124mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp,
1125 struct mlxsw_sp_ipip_entry *ipip_entry)
1126{
1127 struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry;
1128
1129 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
1130 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1131
1132 mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1133}
1134
1cc38fb1
PM		 1135static void
1136mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp,
1137 struct mlxsw_sp_ipip_entry *ipip_entry,
1138 struct mlxsw_sp_fib_entry *decap_fib_entry)
1139{
1140 if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry,
1141 ipip_entry))
1142 return;
1143 decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
1144
1145 if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry))
1146 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1147}
1148
1149/* Given an IPIP entry, find the corresponding decap route. */
1150static struct mlxsw_sp_fib_entry *
1151mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp,
1152 struct mlxsw_sp_ipip_entry *ipip_entry)
1153{
1154 static struct mlxsw_sp_fib_node *fib_node;
1155 const struct mlxsw_sp_ipip_ops *ipip_ops;
1156 struct mlxsw_sp_fib_entry *fib_entry;
1157 unsigned char saddr_prefix_len;
1158 union mlxsw_sp_l3addr saddr;
1159 struct mlxsw_sp_fib *ul_fib;
1160 struct mlxsw_sp_vr *ul_vr;
1161 const void *saddrp;
1162 size_t saddr_len;
1163 u32 ul_tb_id;
1164 u32 saddr4;
1165
1166 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1167
1168 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1169 ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id);
1170 if (!ul_vr)
1171 return NULL;
1172
1173 ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto);
1174 saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto,
1175 ipip_entry->ol_dev);
1176
1177 switch (ipip_ops->ul_proto) {
1178 case MLXSW_SP_L3_PROTO_IPV4:
1179 saddr4 = be32_to_cpu(saddr.addr4);
1180 saddrp = &saddr4;
1181 saddr_len = 4;
1182 saddr_prefix_len = 32;
1183 break;
1184 case MLXSW_SP_L3_PROTO_IPV6:
1185 WARN_ON(1);
1186 return NULL;
1187 }
1188
1189 fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len,
1190 saddr_prefix_len);
1191 if (!fib_node || list_empty(&fib_node->entry_list))
1192 return NULL;
1193
1194 fib_entry = list_first_entry(&fib_node->entry_list,
1195 struct mlxsw_sp_fib_entry, list);
1196 if (fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP)
1197 return NULL;
1198
1199 return fib_entry;
1200}
1201
1012b9ac
PM		 1202static struct mlxsw_sp_ipip_entry *
1203mlxsw_sp_ipip_entry_get(struct mlxsw_sp *mlxsw_sp,
1204 enum mlxsw_sp_ipip_type ipipt,
1205 struct net_device *ol_dev)
1206{
1207 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev);
1208 struct mlxsw_sp_router *router = mlxsw_sp->router;
1cc38fb1 1209 struct mlxsw_sp_fib_entry *decap_fib_entry;
1012b9ac
PM		 1210 struct mlxsw_sp_ipip_entry *ipip_entry;
1211 enum mlxsw_sp_l3proto ul_proto;
1212 union mlxsw_sp_l3addr saddr;
1213
1214 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1215 ipip_list_node) {
1216 if (ipip_entry->ol_dev == ol_dev)
1217 goto inc_ref_count;
1218
1219 /* The configuration where several tunnels have the same local
1220 * address in the same underlay table needs special treatment in
1221 * the HW. That is currently not implemented in the driver.
1222 */
1223 ul_proto = router->ipip_ops_arr[ipip_entry->ipipt]->ul_proto;
1224 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev);
1225 if (mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr,
1226 ul_tb_id, ipip_entry))
1227 return ERR_PTR(-EEXIST);
1228 }
1229
1230 ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev);
1231 if (IS_ERR(ipip_entry))
1232 return ipip_entry;
1233
1cc38fb1
PM		 1234 decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry);
1235 if (decap_fib_entry)
1236 mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry,
1237 decap_fib_entry);
1238
1012b9ac
PM		 1239 list_add_tail(&ipip_entry->ipip_list_node,
1240 &mlxsw_sp->router->ipip_list);
1241
1242inc_ref_count:
1243 ++ipip_entry->ref_count;
1244 return ipip_entry;
1245}
1246
1247static void
1248mlxsw_sp_ipip_entry_put(struct mlxsw_sp *mlxsw_sp,
1249 struct mlxsw_sp_ipip_entry *ipip_entry)
1250{
1251 if (--ipip_entry->ref_count == 0) {
1252 list_del(&ipip_entry->ipip_list_node);
4607f6d2
PM		 1253 if (ipip_entry->decap_fib_entry)
1254 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1012b9ac
PM		 1255 mlxsw_sp_ipip_entry_destroy(ipip_entry);
1256 }
1257}
1258
4607f6d2
PM		 1259static bool
1260mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp,
1261 const struct net_device *ul_dev,
1262 enum mlxsw_sp_l3proto ul_proto,
1263 union mlxsw_sp_l3addr ul_dip,
1264 struct mlxsw_sp_ipip_entry *ipip_entry)
1265{
1266 u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1267 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1268 struct net_device *ipip_ul_dev;
1269
1270 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1271 return false;
1272
1273 ipip_ul_dev = __mlxsw_sp_ipip_netdev_ul_dev_get(ipip_entry->ol_dev);
1274 return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip,
1275 ul_tb_id, ipip_entry) &&
1276 (!ipip_ul_dev || ipip_ul_dev == ul_dev);
1277}
1278
1279/* Given decap parameters, find the corresponding IPIP entry. */
1280static struct mlxsw_sp_ipip_entry *
1281mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp,
1282 const struct net_device *ul_dev,
1283 enum mlxsw_sp_l3proto ul_proto,
1284 union mlxsw_sp_l3addr ul_dip)
1285{
1286 struct mlxsw_sp_ipip_entry *ipip_entry;
1287
1288 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1289 ipip_list_node)
1290 if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev,
1291 ul_proto, ul_dip,
1292 ipip_entry))
1293 return ipip_entry;
1294
1295 return NULL;
1296}
1297
6698c168
PM		 1298static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp,
1299 const struct net_device *dev,
1300 enum mlxsw_sp_ipip_type *p_type)
1301{
1302 struct mlxsw_sp_router *router = mlxsw_sp->router;
1303 const struct mlxsw_sp_ipip_ops *ipip_ops;
1304 enum mlxsw_sp_ipip_type ipipt;
1305
1306 for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) {
1307 ipip_ops = router->ipip_ops_arr[ipipt];
1308 if (dev->type == ipip_ops->dev_type) {
1309 if (p_type)
1310 *p_type = ipipt;
1311 return true;
1312 }
1313 }
1314 return false;
1315}
1316
6cf3c971 1317struct mlxsw_sp_neigh_key {
33b1341c 1318 struct neighbour *n;
6cf3c971
JP		 1319};
1320
1321struct mlxsw_sp_neigh_entry {
9665b745 1322 struct list_head rif_list_node;
6cf3c971
JP		 1323 struct rhash_head ht_node;
1324 struct mlxsw_sp_neigh_key key;
1325 u16 rif;
5c8802f1 1326 bool connected;
a6bf9e93 1327 unsigned char ha[ETH_ALEN];
a7ff87ac
JP		 1328 struct list_head nexthop_list; /* list of nexthops using
1329 * this neigh entry
1330 */
b2157149 1331 struct list_head nexthop_neighs_list_node;
7cfcbc75
AS		 1332 unsigned int counter_index;
1333 bool counter_valid;
6cf3c971
JP		 1334};
1335
1336static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
1337 .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
1338 .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
1339 .key_len = sizeof(struct mlxsw_sp_neigh_key),
1340};
1341
f17cc84d
AS		 1342struct mlxsw_sp_neigh_entry *
1343mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif,
1344 struct mlxsw_sp_neigh_entry *neigh_entry)
1345{
1346 if (!neigh_entry) {
1347 if (list_empty(&rif->neigh_list))
1348 return NULL;
1349 else
1350 return list_first_entry(&rif->neigh_list,
1351 typeof(*neigh_entry),
1352 rif_list_node);
1353 }
ec2437f4 1354 if (list_is_last(&neigh_entry->rif_list_node, &rif->neigh_list))
f17cc84d
AS		 1355 return NULL;
1356 return list_next_entry(neigh_entry, rif_list_node);
1357}
1358
1359int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry)
1360{
1361 return neigh_entry->key.n->tbl->family;
1362}
1363
1364unsigned char *
1365mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry)
1366{
1367 return neigh_entry->ha;
1368}
1369
1370u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1371{
1372 struct neighbour *n;
1373
1374 n = neigh_entry->key.n;
1375 return ntohl(*((__be32 *) n->primary_key));
1376}
1377
0250768c
AS		 1378struct in6_addr *
1379mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1380{
1381 struct neighbour *n;
1382
1383 n = neigh_entry->key.n;
1384 return (struct in6_addr *) &n->primary_key;
1385}
1386
7cfcbc75
AS		 1387int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp,
1388 struct mlxsw_sp_neigh_entry *neigh_entry,
1389 u64 *p_counter)
1390{
1391 if (!neigh_entry->counter_valid)
1392 return -EINVAL;
1393
1394 return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index,
1395 p_counter, NULL);
1396}
1397
6cf3c971 1398static struct mlxsw_sp_neigh_entry *
5c8802f1
IS		 1399mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
1400 u16 rif)
6cf3c971
JP		 1401{
1402 struct mlxsw_sp_neigh_entry *neigh_entry;
1403
5c8802f1 1404 neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
6cf3c971
JP		 1405 if (!neigh_entry)
1406 return NULL;
5c8802f1 1407
33b1341c 1408 neigh_entry->key.n = n;
6cf3c971 1409 neigh_entry->rif = rif;
a7ff87ac 1410 INIT_LIST_HEAD(&neigh_entry->nexthop_list);
5c8802f1 1411
6cf3c971
JP		 1412 return neigh_entry;
1413}
1414
5c8802f1 1415static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971
JP		 1416{
1417 kfree(neigh_entry);
1418}
1419
5c8802f1
IS		 1420static int
1421mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
1422 struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971 1423{
9011b677 1424 return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1
IS		 1425 &neigh_entry->ht_node,
1426 mlxsw_sp_neigh_ht_params);
1427}
6cf3c971 1428
5c8802f1
IS		 1429static void
1430mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
1431 struct mlxsw_sp_neigh_entry *neigh_entry)
1432{
9011b677 1433 rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1
IS		 1434 &neigh_entry->ht_node,
1435 mlxsw_sp_neigh_ht_params);
6cf3c971
JP		 1436}
1437
7cfcbc75 1438static bool
1ed5574c
AS		 1439mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp,
1440 struct mlxsw_sp_neigh_entry *neigh_entry)
7cfcbc75
AS		 1441{
1442 struct devlink *devlink;
1ed5574c
AS		 1443 const char *table_name;
1444
1445 switch (mlxsw_sp_neigh_entry_type(neigh_entry)) {
1446 case AF_INET:
1447 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4;
1448 break;
1449 case AF_INET6:
1450 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6;
1451 break;
1452 default:
1453 WARN_ON(1);
1454 return false;
1455 }
7cfcbc75
AS		 1456
1457 devlink = priv_to_devlink(mlxsw_sp->core);
1ed5574c 1458 return devlink_dpipe_table_counter_enabled(devlink, table_name);
7cfcbc75
AS		 1459}
1460
1461static void
1462mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp,
1463 struct mlxsw_sp_neigh_entry *neigh_entry)
1464{
1ed5574c 1465 if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry))
7cfcbc75
AS		 1466 return;
1467
1468 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index))
1469 return;
1470
1471 neigh_entry->counter_valid = true;
1472}
1473
1474static void
1475mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp,
1476 struct mlxsw_sp_neigh_entry *neigh_entry)
1477{
1478 if (!neigh_entry->counter_valid)
1479 return;
1480 mlxsw_sp_flow_counter_free(mlxsw_sp,
1481 neigh_entry->counter_index);
1482 neigh_entry->counter_valid = false;
1483}
1484
5c8802f1
IS		 1485static struct mlxsw_sp_neigh_entry *
1486mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
6cf3c971 1487{
6cf3c971 1488 struct mlxsw_sp_neigh_entry *neigh_entry;
bf95233e 1489 struct mlxsw_sp_rif *rif;
6cf3c971
JP		 1490 int err;
1491
bf95233e
AS		 1492 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
1493 if (!rif)
5c8802f1 1494 return ERR_PTR(-EINVAL);
6cf3c971 1495
bf95233e 1496 neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
6cf3c971 1497 if (!neigh_entry)
5c8802f1
IS		 1498 return ERR_PTR(-ENOMEM);
1499
6cf3c971
JP		 1500 err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
1501 if (err)
1502 goto err_neigh_entry_insert;
5c8802f1 1503
7cfcbc75 1504 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
bf95233e 1505 list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
9665b745 1506
5c8802f1 1507 return neigh_entry;
6cf3c971
JP		 1508
1509err_neigh_entry_insert:
5c8802f1
IS		 1510 mlxsw_sp_neigh_entry_free(neigh_entry);
1511 return ERR_PTR(err);
6cf3c971
JP		 1512}
1513
5c8802f1
IS		 1514static void
1515mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1516 struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971 1517{
9665b745 1518 list_del(&neigh_entry->rif_list_node);
7cfcbc75 1519 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
5c8802f1
IS		 1520 mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
1521 mlxsw_sp_neigh_entry_free(neigh_entry);
1522}
6cf3c971 1523
5c8802f1
IS		 1524static struct mlxsw_sp_neigh_entry *
1525mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
1526{
1527 struct mlxsw_sp_neigh_key key;
6cf3c971 1528
5c8802f1 1529 key.n = n;
9011b677 1530 return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1 1531 &key, mlxsw_sp_neigh_ht_params);
6cf3c971
JP		 1532}
1533
c723c735
YG		 1534static void
1535mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
1536{
a6c9b5d1 1537 unsigned long interval;
c723c735 1538
b5f3e0d4 1539#if IS_ENABLED(CONFIG_IPV6)
a6c9b5d1
AS		 1540 interval = min_t(unsigned long,
1541 NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
1542 NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
b5f3e0d4
IS		 1543#else
1544 interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
1545#endif
9011b677 1546 mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
c723c735
YG		 1547}
1548
1549static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1550 char *rauhtd_pl,
1551 int ent_index)
1552{
1553 struct net_device *dev;
1554 struct neighbour *n;
1555 __be32 dipn;
1556 u32 dip;
1557 u16 rif;
1558
1559 mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
1560
5f9efffb 1561 if (!mlxsw_sp->router->rifs[rif]) {
c723c735
YG		 1562 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1563 return;
1564 }
1565
1566 dipn = htonl(dip);
5f9efffb 1567 dev = mlxsw_sp->router->rifs[rif]->dev;
c723c735
YG		 1568 n = neigh_lookup(&arp_tbl, &dipn, dev);
1569 if (!n) {
1570 netdev_err(dev, "Failed to find matching neighbour for IP=%pI4h\n",
1571 &dip);
1572 return;
1573 }
1574
1575 netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
1576 neigh_event_send(n, NULL);
1577 neigh_release(n);
1578}
1579
df9a21f1 1580#if IS_ENABLED(CONFIG_IPV6)
60f040ca
AS		 1581static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1582 char *rauhtd_pl,
1583 int rec_index)
1584{
1585 struct net_device *dev;
1586 struct neighbour *n;
1587 struct in6_addr dip;
1588 u16 rif;
1589
1590 mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
1591 (char *) &dip);
1592
1593 if (!mlxsw_sp->router->rifs[rif]) {
1594 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1595 return;
1596 }
1597
1598 dev = mlxsw_sp->router->rifs[rif]->dev;
1599 n = neigh_lookup(&nd_tbl, &dip, dev);
1600 if (!n) {
1601 netdev_err(dev, "Failed to find matching neighbour for IP=%pI6c\n",
1602 &dip);
1603 return;
1604 }
1605
1606 netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
1607 neigh_event_send(n, NULL);
1608 neigh_release(n);
1609}
b5f3e0d4
IS		 1610#else
1611static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1612 char *rauhtd_pl,
1613 int rec_index)
1614{
1615}
1616#endif
60f040ca 1617
c723c735
YG		 1618static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1619 char *rauhtd_pl,
1620 int rec_index)
1621{
1622 u8 num_entries;
1623 int i;
1624
1625 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1626 rec_index);
1627 /* Hardware starts counting at 0, so add 1. */
1628 num_entries++;
1629
1630 /* Each record consists of several neighbour entries. */
1631 for (i = 0; i < num_entries; i++) {
1632 int ent_index;
1633
1634 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
1635 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
1636 ent_index);
1637 }
1638
1639}
1640
60f040ca
AS		 1641static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1642 char *rauhtd_pl,
1643 int rec_index)
1644{
1645 /* One record contains one entry. */
1646 mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
1647 rec_index);
1648}
1649
c723c735
YG		 1650static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
1651 char *rauhtd_pl, int rec_index)
1652{
1653 switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
1654 case MLXSW_REG_RAUHTD_TYPE_IPV4:
1655 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
1656 rec_index);
1657 break;
1658 case MLXSW_REG_RAUHTD_TYPE_IPV6:
60f040ca
AS		 1659 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
1660 rec_index);
c723c735
YG		 1661 break;
1662 }
1663}
1664
42cdb338
AS		 1665static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
1666{
1667 u8 num_rec, last_rec_index, num_entries;
1668
1669 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1670 last_rec_index = num_rec - 1;
1671
1672 if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
1673 return false;
1674 if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
1675 MLXSW_REG_RAUHTD_TYPE_IPV6)
1676 return true;
1677
1678 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1679 last_rec_index);
1680 if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
1681 return true;
1682 return false;
1683}
1684
60f040ca
AS		 1685static int
1686__mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
1687 char *rauhtd_pl,
1688 enum mlxsw_reg_rauhtd_type type)
c723c735 1689{
60f040ca
AS		 1690 int i, num_rec;
1691 int err;
c723c735
YG		 1692
1693 /* Make sure the neighbour's netdev isn't removed in the
1694 * process.
1695 */
1696 rtnl_lock();
1697 do {
60f040ca 1698 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
c723c735
YG		 1699 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
1700 rauhtd_pl);
1701 if (err) {
7ff176f8 1702 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour table\n");
c723c735
YG		 1703 break;
1704 }
1705 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1706 for (i = 0; i < num_rec; i++)
1707 mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
1708 i);
42cdb338 1709 } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
c723c735
YG		 1710 rtnl_unlock();
1711
60f040ca
AS		 1712 return err;
1713}
1714
1715static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
1716{
1717 enum mlxsw_reg_rauhtd_type type;
1718 char *rauhtd_pl;
1719 int err;
1720
1721 rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
1722 if (!rauhtd_pl)
1723 return -ENOMEM;
1724
1725 type = MLXSW_REG_RAUHTD_TYPE_IPV4;
1726 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1727 if (err)
1728 goto out;
1729
1730 type = MLXSW_REG_RAUHTD_TYPE_IPV6;
1731 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1732out:
c723c735 1733 kfree(rauhtd_pl);
b2157149
YG		 1734 return err;
1735}
1736
1737static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
1738{
1739 struct mlxsw_sp_neigh_entry *neigh_entry;
1740
1741 /* Take RTNL mutex here to prevent lists from changes */
1742 rtnl_lock();
9011b677 1743 list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
8a0b7275 1744 nexthop_neighs_list_node)
b2157149
YG		 1745 /* If this neigh have nexthops, make the kernel think this neigh
1746 * is active regardless of the traffic.
1747 */
8a0b7275 1748 neigh_event_send(neigh_entry->key.n, NULL);
b2157149
YG		 1749 rtnl_unlock();
1750}
1751
1752static void
1753mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
1754{
9011b677 1755 unsigned long interval = mlxsw_sp->router->neighs_update.interval;
b2157149 1756
9011b677 1757 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
b2157149
YG		 1758 msecs_to_jiffies(interval));
1759}
1760
1761static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
1762{
9011b677 1763 struct mlxsw_sp_router *router;
b2157149
YG		 1764 int err;
1765
9011b677
IS		 1766 router = container_of(work, struct mlxsw_sp_router,
1767 neighs_update.dw.work);
1768 err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
b2157149 1769 if (err)
9011b677 1770 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
b2157149 1771
9011b677 1772 mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
b2157149 1773
9011b677 1774 mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
c723c735
YG		 1775}
1776
0b2361d9
YG		 1777static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
1778{
1779 struct mlxsw_sp_neigh_entry *neigh_entry;
9011b677 1780 struct mlxsw_sp_router *router;
0b2361d9 1781
9011b677
IS		 1782 router = container_of(work, struct mlxsw_sp_router,
1783 nexthop_probe_dw.work);
0b2361d9
YG		 1784 /* Iterate over nexthop neighbours, find those who are unresolved and
1785 * send arp on them. This solves the chicken-egg problem when
1786 * the nexthop wouldn't get offloaded until the neighbor is resolved
1787 * but it wouldn't get resolved ever in case traffic is flowing in HW
1788 * using different nexthop.
1789 *
1790 * Take RTNL mutex here to prevent lists from changes.
1791 */
1792 rtnl_lock();
9011b677 1793 list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
8a0b7275 1794 nexthop_neighs_list_node)
01b1aa35 1795 if (!neigh_entry->connected)
33b1341c 1796 neigh_event_send(neigh_entry->key.n, NULL);
0b2361d9
YG		 1797 rtnl_unlock();
1798
9011b677 1799 mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
0b2361d9
YG		 1800 MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
1801}
1802
a7ff87ac
JP		 1803static void
1804mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
1805 struct mlxsw_sp_neigh_entry *neigh_entry,
1806 bool removing);
1807
5c8802f1
IS		 1808static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
1809{
1810 return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
1811 MLXSW_REG_RAUHT_OP_WRITE_DELETE;
1812}
1813
1814static void
1815mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
1816 struct mlxsw_sp_neigh_entry *neigh_entry,
1817 enum mlxsw_reg_rauht_op op)
a6bf9e93 1818{
33b1341c 1819 struct neighbour *n = neigh_entry->key.n;
5c8802f1 1820 u32 dip = ntohl(*((__be32 *) n->primary_key));
a6bf9e93 1821 char rauht_pl[MLXSW_REG_RAUHT_LEN];
5c8802f1
IS		 1822
1823 mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1824 dip);
7cfcbc75
AS		 1825 if (neigh_entry->counter_valid)
1826 mlxsw_reg_rauht_pack_counter(rauht_pl,
1827 neigh_entry->counter_index);
5c8802f1
IS		 1828 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1829}
1830
d5eb89cf
AS		 1831static void
1832mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
1833 struct mlxsw_sp_neigh_entry *neigh_entry,
1834 enum mlxsw_reg_rauht_op op)
1835{
1836 struct neighbour *n = neigh_entry->key.n;
1837 char rauht_pl[MLXSW_REG_RAUHT_LEN];
1838 const char *dip = n->primary_key;
1839
1840 mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1841 dip);
7cfcbc75
AS		 1842 if (neigh_entry->counter_valid)
1843 mlxsw_reg_rauht_pack_counter(rauht_pl,
1844 neigh_entry->counter_index);
d5eb89cf
AS		 1845 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1846}
1847
1d1056d8 1848bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry)
d5eb89cf 1849{
1d1056d8
AS		 1850 struct neighbour *n = neigh_entry->key.n;
1851
d5eb89cf
AS		 1852 /* Packets with a link-local destination address are trapped
1853 * after LPM lookup and never reach the neighbour table, so
1854 * there is no need to program such neighbours to the device.
1855 */
1856 if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
1857 IPV6_ADDR_LINKLOCAL)
1858 return true;
1859 return false;
1860}
1861
5c8802f1
IS		 1862static void
1863mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
1864 struct mlxsw_sp_neigh_entry *neigh_entry,
1865 bool adding)
1866{
1867 if (!adding && !neigh_entry->connected)
1868 return;
1869 neigh_entry->connected = adding;
b5f3e0d4 1870 if (neigh_entry->key.n->tbl->family == AF_INET) {
5c8802f1
IS		 1871 mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
1872 mlxsw_sp_rauht_op(adding));
b5f3e0d4 1873 } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
1d1056d8 1874 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry))
d5eb89cf
AS		 1875 return;
1876 mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
1877 mlxsw_sp_rauht_op(adding));
1878 } else {
5c8802f1 1879 WARN_ON_ONCE(1);
d5eb89cf 1880 }
5c8802f1
IS		 1881}
1882
a481d713
AS		 1883void
1884mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp,
1885 struct mlxsw_sp_neigh_entry *neigh_entry,
1886 bool adding)
1887{
1888 if (adding)
1889 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
1890 else
1891 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
1892 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true);
1893}
1894
5c8802f1
IS		 1895struct mlxsw_sp_neigh_event_work {
1896 struct work_struct work;
1897 struct mlxsw_sp *mlxsw_sp;
1898 struct neighbour *n;
1899};
1900
1901static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
1902{
1903 struct mlxsw_sp_neigh_event_work *neigh_work =
1904 container_of(work, struct mlxsw_sp_neigh_event_work, work);
1905 struct mlxsw_sp *mlxsw_sp = neigh_work->mlxsw_sp;
1906 struct mlxsw_sp_neigh_entry *neigh_entry;
1907 struct neighbour *n = neigh_work->n;
1908 unsigned char ha[ETH_ALEN];
a6bf9e93 1909 bool entry_connected;
93a87e5e 1910 u8 nud_state, dead;
a6bf9e93 1911
5c8802f1
IS		 1912 /* If these parameters are changed after we release the lock,
1913 * then we are guaranteed to receive another event letting us
1914 * know about it.
1915 */
a6bf9e93 1916 read_lock_bh(&n->lock);
5c8802f1 1917 memcpy(ha, n->ha, ETH_ALEN);
a6bf9e93 1918 nud_state = n->nud_state;
93a87e5e 1919 dead = n->dead;
a6bf9e93
YG		 1920 read_unlock_bh(&n->lock);
1921
5c8802f1 1922 rtnl_lock();
93a87e5e 1923 entry_connected = nud_state & NUD_VALID && !dead;
5c8802f1
IS		 1924 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
1925 if (!entry_connected && !neigh_entry)
1926 goto out;
1927 if (!neigh_entry) {
1928 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
1929 if (IS_ERR(neigh_entry))
1930 goto out;
a6bf9e93
YG		 1931 }
1932
5c8802f1
IS		 1933 memcpy(neigh_entry->ha, ha, ETH_ALEN);
1934 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
1935 mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected);
1936
1937 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
1938 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
1939
1940out:
1941 rtnl_unlock();
a6bf9e93 1942 neigh_release(n);
5c8802f1 1943 kfree(neigh_work);
a6bf9e93
YG		 1944}
1945
e7322638
JP		 1946int mlxsw_sp_router_netevent_event(struct notifier_block *unused,
1947 unsigned long event, void *ptr)
c723c735 1948{
5c8802f1 1949 struct mlxsw_sp_neigh_event_work *neigh_work;
c723c735
YG		 1950 struct mlxsw_sp_port *mlxsw_sp_port;
1951 struct mlxsw_sp *mlxsw_sp;
1952 unsigned long interval;
1953 struct neigh_parms *p;
a6bf9e93 1954 struct neighbour *n;
c723c735
YG		 1955
1956 switch (event) {
1957 case NETEVENT_DELAY_PROBE_TIME_UPDATE:
1958 p = ptr;
1959
1960 /* We don't care about changes in the default table. */
b5f3e0d4
IS		 1961 if (!p->dev || (p->tbl->family != AF_INET &&
1962 p->tbl->family != AF_INET6))
c723c735
YG		 1963 return NOTIFY_DONE;
1964
1965 /* We are in atomic context and can't take RTNL mutex,
1966 * so use RCU variant to walk the device chain.
1967 */
1968 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(p->dev);
1969 if (!mlxsw_sp_port)
1970 return NOTIFY_DONE;
1971
1972 mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1973 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
9011b677 1974 mlxsw_sp->router->neighs_update.interval = interval;
c723c735
YG		 1975
1976 mlxsw_sp_port_dev_put(mlxsw_sp_port);
1977 break;
a6bf9e93
YG		 1978 case NETEVENT_NEIGH_UPDATE:
1979 n = ptr;
a6bf9e93 1980
b5f3e0d4 1981 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
a6bf9e93
YG		 1982 return NOTIFY_DONE;
1983
5c8802f1 1984 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(n->dev);
a6bf9e93
YG		 1985 if (!mlxsw_sp_port)
1986 return NOTIFY_DONE;
1987
5c8802f1
IS		 1988 neigh_work = kzalloc(sizeof(*neigh_work), GFP_ATOMIC);
1989 if (!neigh_work) {
a6bf9e93 1990 mlxsw_sp_port_dev_put(mlxsw_sp_port);
5c8802f1 1991 return NOTIFY_BAD;
a6bf9e93 1992 }
5c8802f1
IS		 1993
1994 INIT_WORK(&neigh_work->work, mlxsw_sp_router_neigh_event_work);
1995 neigh_work->mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1996 neigh_work->n = n;
a6bf9e93
YG		 1997
1998 /* Take a reference to ensure the neighbour won't be
1999 * destructed until we drop the reference in delayed
2000 * work.
2001 */
2002 neigh_clone(n);
5c8802f1
IS		 2003 mlxsw_core_schedule_work(&neigh_work->work);
2004 mlxsw_sp_port_dev_put(mlxsw_sp_port);
a6bf9e93 2005 break;
c723c735
YG		 2006 }
2007
2008 return NOTIFY_DONE;
2009}
2010
6cf3c971
JP		 2011static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
2012{
c723c735
YG		 2013 int err;
2014
9011b677 2015 err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
c723c735
YG		 2016 &mlxsw_sp_neigh_ht_params);
2017 if (err)
2018 return err;
2019
2020 /* Initialize the polling interval according to the default
2021 * table.
2022 */
2023 mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
2024
0b2361d9 2025 /* Create the delayed works for the activity_update */
9011b677 2026 INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
c723c735 2027 mlxsw_sp_router_neighs_update_work);
9011b677 2028 INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
0b2361d9 2029 mlxsw_sp_router_probe_unresolved_nexthops);
9011b677
IS		 2030 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
2031 mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
c723c735 2032 return 0;
6cf3c971
JP		 2033}
2034
2035static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
2036{
9011b677
IS		 2037 cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
2038 cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
2039 rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
6cf3c971
JP		 2040}
2041
9665b745 2042static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 2043 struct mlxsw_sp_rif *rif)
9665b745
IS		 2044{
2045 struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
2046
bf95233e 2047 list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
4a3c67a6
IS		 2048 rif_list_node) {
2049 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
9665b745 2050 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
4a3c67a6 2051 }
9665b745
IS		 2052}
2053
35225e47
PM		 2054enum mlxsw_sp_nexthop_type {
2055 MLXSW_SP_NEXTHOP_TYPE_ETH,
1012b9ac 2056 MLXSW_SP_NEXTHOP_TYPE_IPIP,
35225e47
PM		 2057};
2058
c53b8e1b
IS		 2059struct mlxsw_sp_nexthop_key {
2060 struct fib_nh *fib_nh;
2061};
2062
a7ff87ac
JP		 2063struct mlxsw_sp_nexthop {
2064 struct list_head neigh_list_node; /* member of neigh entry list */
9665b745 2065 struct list_head rif_list_node;
dbe4598c 2066 struct list_head router_list_node;
a7ff87ac
JP		 2067 struct mlxsw_sp_nexthop_group *nh_grp; /* pointer back to the group
2068 * this belongs to
2069 */
c53b8e1b
IS		 2070 struct rhash_head ht_node;
2071 struct mlxsw_sp_nexthop_key key;
58adf2c4 2072 unsigned char gw_addr[sizeof(struct in6_addr)];
e6f3b379 2073 int ifindex;
bf95233e 2074 struct mlxsw_sp_rif *rif;
a7ff87ac
JP		 2075 u8 should_offload:1, /* set indicates this neigh is connected and
2076 * should be put to KVD linear area of this group.
2077 */
2078 offloaded:1, /* set in case the neigh is actually put into
2079 * KVD linear area of this group.
2080 */
2081 update:1; /* set indicates that MAC of this neigh should be
2082 * updated in HW
2083 */
35225e47
PM		 2084 enum mlxsw_sp_nexthop_type type;
2085 union {
2086 struct mlxsw_sp_neigh_entry *neigh_entry;
1012b9ac 2087 struct mlxsw_sp_ipip_entry *ipip_entry;
35225e47 2088 };
a5390278
AS		 2089 unsigned int counter_index;
2090 bool counter_valid;
a7ff87ac
JP		 2091};
2092
2093struct mlxsw_sp_nexthop_group {
ba31d366 2094 void *priv;
e9ad5e7d 2095 struct rhash_head ht_node;
a7ff87ac 2096 struct list_head fib_list; /* list of fib entries that use this group */
58adf2c4 2097 struct neigh_table *neigh_tbl;
b3e8d1eb
IS		 2098 u8 adj_index_valid:1,
2099 gateway:1; /* routes using the group use a gateway */
a7ff87ac
JP		 2100 u32 adj_index;
2101 u16 ecmp_size;
2102 u16 count;
2103 struct mlxsw_sp_nexthop nexthops[0];
bf95233e 2104#define nh_rif nexthops[0].rif
a7ff87ac
JP		 2105};
2106
427e652a
AS		 2107void mlxsw_sp_nexthop_counter_alloc(struct mlxsw_sp *mlxsw_sp,
2108 struct mlxsw_sp_nexthop *nh)
a5390278
AS		 2109{
2110 struct devlink *devlink;
2111
2112 devlink = priv_to_devlink(mlxsw_sp->core);
2113 if (!devlink_dpipe_table_counter_enabled(devlink,
2114 MLXSW_SP_DPIPE_TABLE_NAME_ADJ))
2115 return;
2116
2117 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &nh->counter_index))
2118 return;
2119
2120 nh->counter_valid = true;
2121}
2122
427e652a
AS		 2123void mlxsw_sp_nexthop_counter_free(struct mlxsw_sp *mlxsw_sp,
2124 struct mlxsw_sp_nexthop *nh)
a5390278
AS		 2125{
2126 if (!nh->counter_valid)
2127 return;
2128 mlxsw_sp_flow_counter_free(mlxsw_sp, nh->counter_index);
2129 nh->counter_valid = false;
2130}
2131
2132int mlxsw_sp_nexthop_counter_get(struct mlxsw_sp *mlxsw_sp,
2133 struct mlxsw_sp_nexthop *nh, u64 *p_counter)
2134{
2135 if (!nh->counter_valid)
2136 return -EINVAL;
2137
2138 return mlxsw_sp_flow_counter_get(mlxsw_sp, nh->counter_index,
2139 p_counter, NULL);
2140}
2141
c556cd28
AS		 2142struct mlxsw_sp_nexthop *mlxsw_sp_nexthop_next(struct mlxsw_sp_router *router,
2143 struct mlxsw_sp_nexthop *nh)
2144{
2145 if (!nh) {
2146 if (list_empty(&router->nexthop_list))
2147 return NULL;
2148 else
2149 return list_first_entry(&router->nexthop_list,
2150 typeof(*nh), router_list_node);
2151 }
2152 if (list_is_last(&nh->router_list_node, &router->nexthop_list))
2153 return NULL;
2154 return list_next_entry(nh, router_list_node);
2155}
2156
2157bool mlxsw_sp_nexthop_offload(struct mlxsw_sp_nexthop *nh)
2158{
2159 return nh->offloaded;
2160}
2161
2162unsigned char *mlxsw_sp_nexthop_ha(struct mlxsw_sp_nexthop *nh)
2163{
2164 if (!nh->offloaded)
2165 return NULL;
2166 return nh->neigh_entry->ha;
2167}
2168
2169int mlxsw_sp_nexthop_indexes(struct mlxsw_sp_nexthop *nh, u32 *p_adj_index,
2170 u32 *p_adj_hash_index)
2171{
2172 struct mlxsw_sp_nexthop_group *nh_grp = nh->nh_grp;
2173 u32 adj_hash_index = 0;
2174 int i;
2175
2176 if (!nh->offloaded || !nh_grp->adj_index_valid)
2177 return -EINVAL;
2178
2179 *p_adj_index = nh_grp->adj_index;
2180
2181 for (i = 0; i < nh_grp->count; i++) {
2182 struct mlxsw_sp_nexthop *nh_iter = &nh_grp->nexthops[i];
2183
2184 if (nh_iter == nh)
2185 break;
2186 if (nh_iter->offloaded)
2187 adj_hash_index++;
2188 }
2189
2190 *p_adj_hash_index = adj_hash_index;
2191 return 0;
2192}
2193
2194struct mlxsw_sp_rif *mlxsw_sp_nexthop_rif(struct mlxsw_sp_nexthop *nh)
2195{
2196 return nh->rif;
2197}
2198
2199bool mlxsw_sp_nexthop_group_has_ipip(struct mlxsw_sp_nexthop *nh)
2200{
2201 struct mlxsw_sp_nexthop_group *nh_grp = nh->nh_grp;
2202 int i;
2203
2204 for (i = 0; i < nh_grp->count; i++) {
2205 struct mlxsw_sp_nexthop *nh_iter = &nh_grp->nexthops[i];
2206
2207 if (nh_iter->type == MLXSW_SP_NEXTHOP_TYPE_IPIP)
2208 return true;
2209 }
2210 return false;
2211}
2212
ba31d366
AS		 2213static struct fib_info *
2214mlxsw_sp_nexthop4_group_fi(const struct mlxsw_sp_nexthop_group *nh_grp)
2215{
2216 return nh_grp->priv;
2217}
2218
2219struct mlxsw_sp_nexthop_group_cmp_arg {
e6f3b379
AS		 2220 enum mlxsw_sp_l3proto proto;
2221 union {
2222 struct fib_info *fi;
2223 struct mlxsw_sp_fib6_entry *fib6_entry;
2224 };
ba31d366
AS		 2225};
2226
e6f3b379
AS		 2227static bool
2228mlxsw_sp_nexthop6_group_has_nexthop(const struct mlxsw_sp_nexthop_group *nh_grp,
2229 const struct in6_addr *gw, int ifindex)
2230{
2231 int i;
2232
2233 for (i = 0; i < nh_grp->count; i++) {
2234 const struct mlxsw_sp_nexthop *nh;
2235
2236 nh = &nh_grp->nexthops[i];
2237 if (nh->ifindex == ifindex &&
2238 ipv6_addr_equal(gw, (struct in6_addr *) nh->gw_addr))
2239 return true;
2240 }
2241
2242 return false;
2243}
2244
2245static bool
2246mlxsw_sp_nexthop6_group_cmp(const struct mlxsw_sp_nexthop_group *nh_grp,
2247 const struct mlxsw_sp_fib6_entry *fib6_entry)
2248{
2249 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2250
2251 if (nh_grp->count != fib6_entry->nrt6)
2252 return false;
2253
2254 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2255 struct in6_addr *gw;
2256 int ifindex;
2257
2258 ifindex = mlxsw_sp_rt6->rt->dst.dev->ifindex;
2259 gw = &mlxsw_sp_rt6->rt->rt6i_gateway;
2260 if (!mlxsw_sp_nexthop6_group_has_nexthop(nh_grp, gw, ifindex))
2261 return false;
2262 }
2263
2264 return true;
2265}
2266
ba31d366
AS		 2267static int
2268mlxsw_sp_nexthop_group_cmp(struct rhashtable_compare_arg *arg, const void *ptr)
2269{
2270 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = arg->key;
2271 const struct mlxsw_sp_nexthop_group *nh_grp = ptr;
2272
e6f3b379
AS		 2273 switch (cmp_arg->proto) {
2274 case MLXSW_SP_L3_PROTO_IPV4:
2275 return cmp_arg->fi != mlxsw_sp_nexthop4_group_fi(nh_grp);
2276 case MLXSW_SP_L3_PROTO_IPV6:
2277 return !mlxsw_sp_nexthop6_group_cmp(nh_grp,
2278 cmp_arg->fib6_entry);
2279 default:
2280 WARN_ON(1);
2281 return 1;
2282 }
2283}
2284
2285static int
2286mlxsw_sp_nexthop_group_type(const struct mlxsw_sp_nexthop_group *nh_grp)
2287{
2288 return nh_grp->neigh_tbl->family;
ba31d366
AS		 2289}
2290
2291static u32 mlxsw_sp_nexthop_group_hash_obj(const void *data, u32 len, u32 seed)
2292{
2293 const struct mlxsw_sp_nexthop_group *nh_grp = data;
e6f3b379
AS		 2294 const struct mlxsw_sp_nexthop *nh;
2295 struct fib_info *fi;
2296 unsigned int val;
2297 int i;
ba31d366 2298
e6f3b379
AS		 2299 switch (mlxsw_sp_nexthop_group_type(nh_grp)) {
2300 case AF_INET:
2301 fi = mlxsw_sp_nexthop4_group_fi(nh_grp);
2302 return jhash(&fi, sizeof(fi), seed);
2303 case AF_INET6:
2304 val = nh_grp->count;
2305 for (i = 0; i < nh_grp->count; i++) {
2306 nh = &nh_grp->nexthops[i];
2307 val ^= nh->ifindex;
2308 }
2309 return jhash(&val, sizeof(val), seed);
2310 default:
2311 WARN_ON(1);
2312 return 0;
2313 }
2314}
2315
2316static u32
2317mlxsw_sp_nexthop6_group_hash(struct mlxsw_sp_fib6_entry *fib6_entry, u32 seed)
2318{
2319 unsigned int val = fib6_entry->nrt6;
2320 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2321 struct net_device *dev;
2322
2323 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2324 dev = mlxsw_sp_rt6->rt->dst.dev;
2325 val ^= dev->ifindex;
2326 }
2327
2328 return jhash(&val, sizeof(val), seed);
ba31d366
AS		 2329}
2330
2331static u32
2332mlxsw_sp_nexthop_group_hash(const void *data, u32 len, u32 seed)
2333{
2334 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = data;
2335
e6f3b379
AS		 2336 switch (cmp_arg->proto) {
2337 case MLXSW_SP_L3_PROTO_IPV4:
2338 return jhash(&cmp_arg->fi, sizeof(cmp_arg->fi), seed);
2339 case MLXSW_SP_L3_PROTO_IPV6:
2340 return mlxsw_sp_nexthop6_group_hash(cmp_arg->fib6_entry, seed);
2341 default:
2342 WARN_ON(1);
2343 return 0;
2344 }
ba31d366
AS		 2345}
2346
e9ad5e7d 2347static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
e9ad5e7d 2348 .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
ba31d366
AS		 2349 .hashfn = mlxsw_sp_nexthop_group_hash,
2350 .obj_hashfn = mlxsw_sp_nexthop_group_hash_obj,
2351 .obj_cmpfn = mlxsw_sp_nexthop_group_cmp,
e9ad5e7d
IS		 2352};
2353
2354static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
2355 struct mlxsw_sp_nexthop_group *nh_grp)
2356{
e6f3b379
AS		 2357 if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2358 !nh_grp->gateway)
2359 return 0;
2360
9011b677 2361 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 2362 &nh_grp->ht_node,
2363 mlxsw_sp_nexthop_group_ht_params);
2364}
2365
2366static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
2367 struct mlxsw_sp_nexthop_group *nh_grp)
2368{
e6f3b379
AS		 2369 if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2370 !nh_grp->gateway)
2371 return;
2372
9011b677 2373 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 2374 &nh_grp->ht_node,
2375 mlxsw_sp_nexthop_group_ht_params);
2376}
2377
2378static struct mlxsw_sp_nexthop_group *
ba31d366
AS		 2379mlxsw_sp_nexthop4_group_lookup(struct mlxsw_sp *mlxsw_sp,
2380 struct fib_info *fi)
e9ad5e7d 2381{
ba31d366
AS		 2382 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
2383
e6f3b379 2384 cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV4;
ba31d366
AS		 2385 cmp_arg.fi = fi;
2386 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
2387 &cmp_arg,
e9ad5e7d
IS		 2388 mlxsw_sp_nexthop_group_ht_params);
2389}
2390
e6f3b379
AS		 2391static struct mlxsw_sp_nexthop_group *
2392mlxsw_sp_nexthop6_group_lookup(struct mlxsw_sp *mlxsw_sp,
2393 struct mlxsw_sp_fib6_entry *fib6_entry)
2394{
2395 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
2396
2397 cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV6;
2398 cmp_arg.fib6_entry = fib6_entry;
2399 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
2400 &cmp_arg,
2401 mlxsw_sp_nexthop_group_ht_params);
2402}
2403
c53b8e1b
IS		 2404static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
2405 .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
2406 .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
2407 .key_len = sizeof(struct mlxsw_sp_nexthop_key),
2408};
2409
2410static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
2411 struct mlxsw_sp_nexthop *nh)
2412{
9011b677 2413 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
c53b8e1b
IS		 2414 &nh->ht_node, mlxsw_sp_nexthop_ht_params);
2415}
2416
2417static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
2418 struct mlxsw_sp_nexthop *nh)
2419{
9011b677 2420 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
c53b8e1b
IS		 2421 mlxsw_sp_nexthop_ht_params);
2422}
2423
ad178c8e
IS		 2424static struct mlxsw_sp_nexthop *
2425mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
2426 struct mlxsw_sp_nexthop_key key)
2427{
9011b677 2428 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
ad178c8e
IS		 2429 mlxsw_sp_nexthop_ht_params);
2430}
2431
a7ff87ac 2432static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
76610ebb 2433 const struct mlxsw_sp_fib *fib,
a7ff87ac
JP		 2434 u32 adj_index, u16 ecmp_size,
2435 u32 new_adj_index,
2436 u16 new_ecmp_size)
2437{
2438 char raleu_pl[MLXSW_REG_RALEU_LEN];
2439
1a9234e6 2440 mlxsw_reg_raleu_pack(raleu_pl,
76610ebb
IS		 2441 (enum mlxsw_reg_ralxx_protocol) fib->proto,
2442 fib->vr->id, adj_index, ecmp_size, new_adj_index,
1a9234e6 2443 new_ecmp_size);
a7ff87ac
JP		 2444 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
2445}
2446
2447static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
2448 struct mlxsw_sp_nexthop_group *nh_grp,
2449 u32 old_adj_index, u16 old_ecmp_size)
2450{
2451 struct mlxsw_sp_fib_entry *fib_entry;
76610ebb 2452 struct mlxsw_sp_fib *fib = NULL;
a7ff87ac
JP		 2453 int err;
2454
2455 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
76610ebb 2456 if (fib == fib_entry->fib_node->fib)
a7ff87ac 2457 continue;
76610ebb
IS		 2458 fib = fib_entry->fib_node->fib;
2459 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, fib,
a7ff87ac
JP		 2460 old_adj_index,
2461 old_ecmp_size,
2462 nh_grp->adj_index,
2463 nh_grp->ecmp_size);
2464 if (err)
2465 return err;
2466 }
2467 return 0;
2468}
2469
427e652a
AS		 2470int mlxsw_sp_nexthop_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
2471 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 2472{
2473 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
2474 char ratr_pl[MLXSW_REG_RATR_LEN];
2475
2476 mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY,
89e41982
PM		 2477 true, MLXSW_REG_RATR_TYPE_ETHERNET,
2478 adj_index, neigh_entry->rif);
a7ff87ac 2479 mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
a5390278
AS		 2480 if (nh->counter_valid)
2481 mlxsw_reg_ratr_counter_pack(ratr_pl, nh->counter_index, true);
2482 else
2483 mlxsw_reg_ratr_counter_pack(ratr_pl, 0, false);
2484
a7ff87ac
JP		 2485 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
2486}
2487
1012b9ac
PM		 2488static int mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
2489 u32 adj_index,
2490 struct mlxsw_sp_nexthop *nh)
2491{
2492 const struct mlxsw_sp_ipip_ops *ipip_ops;
2493
2494 ipip_ops = mlxsw_sp->router->ipip_ops_arr[nh->ipip_entry->ipipt];
2495 return ipip_ops->nexthop_update(mlxsw_sp, adj_index, nh->ipip_entry);
2496}
2497
a7ff87ac 2498static int
35225e47
PM		 2499mlxsw_sp_nexthop_group_update(struct mlxsw_sp *mlxsw_sp,
2500 struct mlxsw_sp_nexthop_group *nh_grp,
2501 bool reallocate)
a7ff87ac
JP		 2502{
2503 u32 adj_index = nh_grp->adj_index; /* base */
2504 struct mlxsw_sp_nexthop *nh;
2505 int i;
2506 int err;
2507
2508 for (i = 0; i < nh_grp->count; i++) {
2509 nh = &nh_grp->nexthops[i];
2510
2511 if (!nh->should_offload) {
2512 nh->offloaded = 0;
2513 continue;
2514 }
2515
a59b7e02 2516 if (nh->update || reallocate) {
35225e47
PM		 2517 switch (nh->type) {
2518 case MLXSW_SP_NEXTHOP_TYPE_ETH:
a5390278 2519 err = mlxsw_sp_nexthop_update
35225e47
PM		 2520 (mlxsw_sp, adj_index, nh);
2521 break;
1012b9ac
PM		 2522 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
2523 err = mlxsw_sp_nexthop_ipip_update
2524 (mlxsw_sp, adj_index, nh);
2525 break;
35225e47 2526 }
a7ff87ac
JP		 2527 if (err)
2528 return err;
2529 nh->update = 0;
2530 nh->offloaded = 1;
2531 }
2532 adj_index++;
2533 }
2534 return 0;
2535}
2536
1819ae3d
IS		 2537static bool
2538mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
2539 const struct mlxsw_sp_fib_entry *fib_entry);
2540
a7ff87ac
JP		 2541static int
2542mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
2543 struct mlxsw_sp_nexthop_group *nh_grp)
2544{
2545 struct mlxsw_sp_fib_entry *fib_entry;
2546 int err;
2547
2548 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
1819ae3d
IS		 2549 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
2550 fib_entry))
2551 continue;
a7ff87ac
JP		 2552 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2553 if (err)
2554 return err;
2555 }
2556 return 0;
2557}
2558
77d964e6
IS		 2559static void
2560mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
2561 enum mlxsw_reg_ralue_op op, int err);
2562
2563static void
2564mlxsw_sp_nexthop_fib_entries_refresh(struct mlxsw_sp_nexthop_group *nh_grp)
2565{
2566 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_WRITE;
2567 struct mlxsw_sp_fib_entry *fib_entry;
2568
2569 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
2570 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
2571 fib_entry))
2572 continue;
2573 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
2574 }
2575}
2576
a7ff87ac
JP		 2577static void
2578mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
2579 struct mlxsw_sp_nexthop_group *nh_grp)
2580{
2581 struct mlxsw_sp_nexthop *nh;
2582 bool offload_change = false;
2583 u32 adj_index;
2584 u16 ecmp_size = 0;
2585 bool old_adj_index_valid;
2586 u32 old_adj_index;
2587 u16 old_ecmp_size;
a7ff87ac
JP		 2588 int i;
2589 int err;
2590
b3e8d1eb
IS		 2591 if (!nh_grp->gateway) {
2592 mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2593 return;
2594 }
2595
a7ff87ac
JP		 2596 for (i = 0; i < nh_grp->count; i++) {
2597 nh = &nh_grp->nexthops[i];
2598
56b8a9ed 2599 if (nh->should_offload != nh->offloaded) {
a7ff87ac
JP		 2600 offload_change = true;
2601 if (nh->should_offload)
2602 nh->update = 1;
2603 }
2604 if (nh->should_offload)
2605 ecmp_size++;
2606 }
2607 if (!offload_change) {
2608 /* Nothing was added or removed, so no need to reallocate. Just
2609 * update MAC on existing adjacency indexes.
2610 */
35225e47 2611 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, false);
a7ff87ac
JP		 2612 if (err) {
2613 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
2614 goto set_trap;
2615 }
2616 return;
2617 }
2618 if (!ecmp_size)
2619 /* No neigh of this group is connected so we just set
2620 * the trap and let everthing flow through kernel.
2621 */
2622 goto set_trap;
2623
13124443
AS		 2624 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, ecmp_size, &adj_index);
2625 if (err) {
a7ff87ac
JP		 2626 /* We ran out of KVD linear space, just set the
2627 * trap and let everything flow through kernel.
2628 */
2629 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
2630 goto set_trap;
2631 }
a7ff87ac
JP		 2632 old_adj_index_valid = nh_grp->adj_index_valid;
2633 old_adj_index = nh_grp->adj_index;
2634 old_ecmp_size = nh_grp->ecmp_size;
2635 nh_grp->adj_index_valid = 1;
2636 nh_grp->adj_index = adj_index;
2637 nh_grp->ecmp_size = ecmp_size;
35225e47 2638 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, true);
a7ff87ac
JP		 2639 if (err) {
2640 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
2641 goto set_trap;
2642 }
2643
2644 if (!old_adj_index_valid) {
2645 /* The trap was set for fib entries, so we have to call
2646 * fib entry update to unset it and use adjacency index.
2647 */
2648 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2649 if (err) {
2650 dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
2651 goto set_trap;
2652 }
2653 return;
2654 }
2655
2656 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
2657 old_adj_index, old_ecmp_size);
2658 mlxsw_sp_kvdl_free(mlxsw_sp, old_adj_index);
2659 if (err) {
2660 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
2661 goto set_trap;
2662 }
77d964e6
IS		 2663
2664 /* Offload state within the group changed, so update the flags. */
2665 mlxsw_sp_nexthop_fib_entries_refresh(nh_grp);
2666
a7ff87ac
JP		 2667 return;
2668
2669set_trap:
2670 old_adj_index_valid = nh_grp->adj_index_valid;
2671 nh_grp->adj_index_valid = 0;
2672 for (i = 0; i < nh_grp->count; i++) {
2673 nh = &nh_grp->nexthops[i];
2674 nh->offloaded = 0;
2675 }
2676 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2677 if (err)
2678 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
2679 if (old_adj_index_valid)
2680 mlxsw_sp_kvdl_free(mlxsw_sp, nh_grp->adj_index);
2681}
2682
2683static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
2684 bool removing)
2685{
213666a3 2686 if (!removing)
a7ff87ac 2687 nh->should_offload = 1;
213666a3 2688 else if (nh->offloaded)
a7ff87ac
JP		 2689 nh->should_offload = 0;
2690 nh->update = 1;
2691}
2692
2693static void
2694mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
2695 struct mlxsw_sp_neigh_entry *neigh_entry,
2696 bool removing)
2697{
2698 struct mlxsw_sp_nexthop *nh;
2699
a7ff87ac
JP		 2700 list_for_each_entry(nh, &neigh_entry->nexthop_list,
2701 neigh_list_node) {
2702 __mlxsw_sp_nexthop_neigh_update(nh, removing);
2703 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2704 }
a7ff87ac
JP		 2705}
2706
9665b745 2707static void mlxsw_sp_nexthop_rif_init(struct mlxsw_sp_nexthop *nh,
bf95233e 2708 struct mlxsw_sp_rif *rif)
9665b745 2709{
bf95233e 2710 if (nh->rif)
9665b745
IS		 2711 return;
2712
bf95233e
AS		 2713 nh->rif = rif;
2714 list_add(&nh->rif_list_node, &rif->nexthop_list);
9665b745
IS		 2715}
2716
2717static void mlxsw_sp_nexthop_rif_fini(struct mlxsw_sp_nexthop *nh)
2718{
bf95233e 2719 if (!nh->rif)
9665b745
IS		 2720 return;
2721
2722 list_del(&nh->rif_list_node);
bf95233e 2723 nh->rif = NULL;
9665b745
IS		 2724}
2725
a8c97014
IS		 2726static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
2727 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 2728{
2729 struct mlxsw_sp_neigh_entry *neigh_entry;
a7ff87ac 2730 struct neighbour *n;
93a87e5e 2731 u8 nud_state, dead;
c53b8e1b
IS		 2732 int err;
2733
ad178c8e 2734 if (!nh->nh_grp->gateway || nh->neigh_entry)
b8399a1e
IS		 2735 return 0;
2736
33b1341c 2737 /* Take a reference of neigh here ensuring that neigh would
8de3c178 2738 * not be destructed before the nexthop entry is finished.
33b1341c 2739 * The reference is taken either in neigh_lookup() or
fd76d910 2740 * in neigh_create() in case n is not found.
33b1341c 2741 */
58adf2c4 2742 n = neigh_lookup(nh->nh_grp->neigh_tbl, &nh->gw_addr, nh->rif->dev);
33b1341c 2743 if (!n) {
58adf2c4
IS		 2744 n = neigh_create(nh->nh_grp->neigh_tbl, &nh->gw_addr,
2745 nh->rif->dev);
a8c97014
IS		 2746 if (IS_ERR(n))
2747 return PTR_ERR(n);
a7ff87ac 2748 neigh_event_send(n, NULL);
33b1341c
JP		 2749 }
2750 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
2751 if (!neigh_entry) {
5c8802f1
IS		 2752 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
2753 if (IS_ERR(neigh_entry)) {
c53b8e1b
IS		 2754 err = -EINVAL;
2755 goto err_neigh_entry_create;
5c8802f1 2756 }
a7ff87ac 2757 }
b2157149
YG		 2758
2759 /* If that is the first nexthop connected to that neigh, add to
2760 * nexthop_neighs_list
2761 */
2762 if (list_empty(&neigh_entry->nexthop_list))
2763 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
9011b677 2764 &mlxsw_sp->router->nexthop_neighs_list);
b2157149 2765
a7ff87ac
JP		 2766 nh->neigh_entry = neigh_entry;
2767 list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
2768 read_lock_bh(&n->lock);
2769 nud_state = n->nud_state;
93a87e5e 2770 dead = n->dead;
a7ff87ac 2771 read_unlock_bh(&n->lock);
93a87e5e 2772 __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
a7ff87ac
JP		 2773
2774 return 0;
c53b8e1b
IS		 2775
2776err_neigh_entry_create:
2777 neigh_release(n);
c53b8e1b 2778 return err;
a7ff87ac
JP		 2779}
2780
a8c97014
IS		 2781static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
2782 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 2783{
2784 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
a8c97014 2785 struct neighbour *n;
a7ff87ac 2786
b8399a1e 2787 if (!neigh_entry)
a8c97014
IS		 2788 return;
2789 n = neigh_entry->key.n;
b8399a1e 2790
58312125 2791 __mlxsw_sp_nexthop_neigh_update(nh, true);
a7ff87ac 2792 list_del(&nh->neigh_list_node);
e58be79e 2793 nh->neigh_entry = NULL;
b2157149
YG		 2794
2795 /* If that is the last nexthop connected to that neigh, remove from
2796 * nexthop_neighs_list
2797 */
e58be79e
IS		 2798 if (list_empty(&neigh_entry->nexthop_list))
2799 list_del(&neigh_entry->nexthop_neighs_list_node);
b2157149 2800
5c8802f1
IS		 2801 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
2802 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2803
2804 neigh_release(n);
a8c97014 2805}
c53b8e1b 2806
1012b9ac
PM		 2807static int mlxsw_sp_nexthop_ipip_init(struct mlxsw_sp *mlxsw_sp,
2808 enum mlxsw_sp_ipip_type ipipt,
2809 struct mlxsw_sp_nexthop *nh,
2810 struct net_device *ol_dev)
2811{
2812 if (!nh->nh_grp->gateway || nh->ipip_entry)
2813 return 0;
2814
2815 nh->ipip_entry = mlxsw_sp_ipip_entry_get(mlxsw_sp, ipipt, ol_dev);
2816 if (IS_ERR(nh->ipip_entry))
2817 return PTR_ERR(nh->ipip_entry);
2818
2819 __mlxsw_sp_nexthop_neigh_update(nh, false);
2820 return 0;
2821}
2822
2823static void mlxsw_sp_nexthop_ipip_fini(struct mlxsw_sp *mlxsw_sp,
2824 struct mlxsw_sp_nexthop *nh)
2825{
2826 struct mlxsw_sp_ipip_entry *ipip_entry = nh->ipip_entry;
2827
2828 if (!ipip_entry)
2829 return;
2830
2831 __mlxsw_sp_nexthop_neigh_update(nh, true);
2832 mlxsw_sp_ipip_entry_put(mlxsw_sp, ipip_entry);
2833 nh->ipip_entry = NULL;
2834}
2835
2836static bool mlxsw_sp_nexthop4_ipip_type(const struct mlxsw_sp *mlxsw_sp,
2837 const struct fib_nh *fib_nh,
2838 enum mlxsw_sp_ipip_type *p_ipipt)
2839{
2840 struct net_device *dev = fib_nh->nh_dev;
2841
2842 return dev &&
2843 fib_nh->nh_parent->fib_type == RTN_UNICAST &&
2844 mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, p_ipipt);
2845}
2846
35225e47
PM		 2847static void mlxsw_sp_nexthop_type_fini(struct mlxsw_sp *mlxsw_sp,
2848 struct mlxsw_sp_nexthop *nh)
2849{
2850 switch (nh->type) {
2851 case MLXSW_SP_NEXTHOP_TYPE_ETH:
2852 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
2853 mlxsw_sp_nexthop_rif_fini(nh);
2854 break;
1012b9ac 2855 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
de0f43c0 2856 mlxsw_sp_nexthop_rif_fini(nh);
1012b9ac
PM		 2857 mlxsw_sp_nexthop_ipip_fini(mlxsw_sp, nh);
2858 break;
35225e47
PM		 2859 }
2860}
2861
2862static int mlxsw_sp_nexthop4_type_init(struct mlxsw_sp *mlxsw_sp,
2863 struct mlxsw_sp_nexthop *nh,
2864 struct fib_nh *fib_nh)
2865{
1012b9ac 2866 struct mlxsw_sp_router *router = mlxsw_sp->router;
35225e47 2867 struct net_device *dev = fib_nh->nh_dev;
1012b9ac 2868 enum mlxsw_sp_ipip_type ipipt;
35225e47
PM		 2869 struct mlxsw_sp_rif *rif;
2870 int err;
2871
1012b9ac
PM		 2872 if (mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, fib_nh, &ipipt) &&
2873 router->ipip_ops_arr[ipipt]->can_offload(mlxsw_sp, dev,
2874 MLXSW_SP_L3_PROTO_IPV4)) {
2875 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
de0f43c0
PM		 2876 err = mlxsw_sp_nexthop_ipip_init(mlxsw_sp, ipipt, nh, dev);
2877 if (err)
2878 return err;
2879 mlxsw_sp_nexthop_rif_init(nh, &nh->ipip_entry->ol_lb->common);
2880 return 0;
1012b9ac
PM		 2881 }
2882
35225e47
PM		 2883 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
2884 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
2885 if (!rif)
2886 return 0;
2887
2888 mlxsw_sp_nexthop_rif_init(nh, rif);
2889 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
2890 if (err)
2891 goto err_neigh_init;
2892
2893 return 0;
2894
2895err_neigh_init:
2896 mlxsw_sp_nexthop_rif_fini(nh);
2897 return err;
2898}
2899
2900static void mlxsw_sp_nexthop4_type_fini(struct mlxsw_sp *mlxsw_sp,
2901 struct mlxsw_sp_nexthop *nh)
2902{
2903 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
2904}
2905
0e6ea2a4
IS		 2906static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
2907 struct mlxsw_sp_nexthop_group *nh_grp,
2908 struct mlxsw_sp_nexthop *nh,
2909 struct fib_nh *fib_nh)
a8c97014
IS		 2910{
2911 struct net_device *dev = fib_nh->nh_dev;
df6dd79b 2912 struct in_device *in_dev;
a8c97014
IS		 2913 int err;
2914
2915 nh->nh_grp = nh_grp;
2916 nh->key.fib_nh = fib_nh;
58adf2c4 2917 memcpy(&nh->gw_addr, &fib_nh->nh_gw, sizeof(fib_nh->nh_gw));
a8c97014
IS		 2918 err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
2919 if (err)
2920 return err;
2921
a5390278 2922 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
dbe4598c
AS		 2923 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
2924
97989ee0
IS		 2925 if (!dev)
2926 return 0;
2927
df6dd79b
IS		 2928 in_dev = __in_dev_get_rtnl(dev);
2929 if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
2930 fib_nh->nh_flags & RTNH_F_LINKDOWN)
2931 return 0;
2932
35225e47 2933 err = mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
a8c97014
IS		 2934 if (err)
2935 goto err_nexthop_neigh_init;
2936
2937 return 0;
2938
2939err_nexthop_neigh_init:
2940 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
2941 return err;
2942}
2943
0e6ea2a4
IS		 2944static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
2945 struct mlxsw_sp_nexthop *nh)
a8c97014 2946{
35225e47 2947 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
dbe4598c 2948 list_del(&nh->router_list_node);
a5390278 2949 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
c53b8e1b 2950 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
a7ff87ac
JP		 2951}
2952
0e6ea2a4
IS		 2953static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
2954 unsigned long event, struct fib_nh *fib_nh)
ad178c8e
IS		 2955{
2956 struct mlxsw_sp_nexthop_key key;
2957 struct mlxsw_sp_nexthop *nh;
ad178c8e 2958
9011b677 2959 if (mlxsw_sp->router->aborted)
ad178c8e
IS		 2960 return;
2961
2962 key.fib_nh = fib_nh;
2963 nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
2964 if (WARN_ON_ONCE(!nh))
2965 return;
2966
ad178c8e
IS		 2967 switch (event) {
2968 case FIB_EVENT_NH_ADD:
35225e47 2969 mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
ad178c8e
IS		 2970 break;
2971 case FIB_EVENT_NH_DEL:
35225e47 2972 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
ad178c8e
IS		 2973 break;
2974 }
2975
2976 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2977}
2978
9665b745 2979static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 2980 struct mlxsw_sp_rif *rif)
9665b745
IS		 2981{
2982 struct mlxsw_sp_nexthop *nh, *tmp;
2983
bf95233e 2984 list_for_each_entry_safe(nh, tmp, &rif->nexthop_list, rif_list_node) {
35225e47 2985 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
9665b745
IS		 2986 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2987 }
2988}
2989
9b01451a
PM		 2990static bool mlxsw_sp_fi_is_gateway(const struct mlxsw_sp *mlxsw_sp,
2991 const struct fib_info *fi)
2992{
1012b9ac
PM		 2993 return fi->fib_nh->nh_scope == RT_SCOPE_LINK ||
2994 mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, fi->fib_nh, NULL);
9b01451a
PM		 2995}
2996
a7ff87ac 2997static struct mlxsw_sp_nexthop_group *
0e6ea2a4 2998mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
a7ff87ac
JP		 2999{
3000 struct mlxsw_sp_nexthop_group *nh_grp;
3001 struct mlxsw_sp_nexthop *nh;
3002 struct fib_nh *fib_nh;
3003 size_t alloc_size;
3004 int i;
3005 int err;
3006
3007 alloc_size = sizeof(*nh_grp) +
3008 fi->fib_nhs * sizeof(struct mlxsw_sp_nexthop);
3009 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
3010 if (!nh_grp)
3011 return ERR_PTR(-ENOMEM);
ba31d366 3012 nh_grp->priv = fi;
a7ff87ac 3013 INIT_LIST_HEAD(&nh_grp->fib_list);
58adf2c4
IS		 3014 nh_grp->neigh_tbl = &arp_tbl;
3015
9b01451a 3016 nh_grp->gateway = mlxsw_sp_fi_is_gateway(mlxsw_sp, fi);
a7ff87ac 3017 nh_grp->count = fi->fib_nhs;
7387dbbc 3018 fib_info_hold(fi);
a7ff87ac
JP		 3019 for (i = 0; i < nh_grp->count; i++) {
3020 nh = &nh_grp->nexthops[i];
3021 fib_nh = &fi->fib_nh[i];
0e6ea2a4 3022 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
a7ff87ac 3023 if (err)
0e6ea2a4 3024 goto err_nexthop4_init;
a7ff87ac 3025 }
e9ad5e7d
IS		 3026 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
3027 if (err)
3028 goto err_nexthop_group_insert;
a7ff87ac
JP		 3029 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
3030 return nh_grp;
3031
e9ad5e7d 3032err_nexthop_group_insert:
0e6ea2a4 3033err_nexthop4_init:
df6dd79b
IS		 3034 for (i--; i >= 0; i--) {
3035 nh = &nh_grp->nexthops[i];
0e6ea2a4 3036 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
df6dd79b 3037 }
ba31d366 3038 fib_info_put(fi);
a7ff87ac
JP		 3039 kfree(nh_grp);
3040 return ERR_PTR(err);
3041}
3042
3043static void
0e6ea2a4
IS		 3044mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
3045 struct mlxsw_sp_nexthop_group *nh_grp)
a7ff87ac
JP		 3046{
3047 struct mlxsw_sp_nexthop *nh;
3048 int i;
3049
e9ad5e7d 3050 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
a7ff87ac
JP		 3051 for (i = 0; i < nh_grp->count; i++) {
3052 nh = &nh_grp->nexthops[i];
0e6ea2a4 3053 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
a7ff87ac 3054 }
58312125
IS		 3055 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
3056 WARN_ON_ONCE(nh_grp->adj_index_valid);
ba31d366 3057 fib_info_put(mlxsw_sp_nexthop4_group_fi(nh_grp));
a7ff87ac
JP		 3058 kfree(nh_grp);
3059}
3060
0e6ea2a4
IS		 3061static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
3062 struct mlxsw_sp_fib_entry *fib_entry,
3063 struct fib_info *fi)
a7ff87ac
JP		 3064{
3065 struct mlxsw_sp_nexthop_group *nh_grp;
3066
ba31d366 3067 nh_grp = mlxsw_sp_nexthop4_group_lookup(mlxsw_sp, fi);
a7ff87ac 3068 if (!nh_grp) {
0e6ea2a4 3069 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
a7ff87ac
JP		 3070 if (IS_ERR(nh_grp))
3071 return PTR_ERR(nh_grp);
3072 }
3073 list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
3074 fib_entry->nh_group = nh_grp;
3075 return 0;
3076}
3077
0e6ea2a4
IS		 3078static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
3079 struct mlxsw_sp_fib_entry *fib_entry)
a7ff87ac
JP		 3080{
3081 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3082
3083 list_del(&fib_entry->nexthop_group_node);
3084 if (!list_empty(&nh_grp->fib_list))
3085 return;
0e6ea2a4 3086 mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
a7ff87ac
JP		 3087}
3088
4f1c7f1f
IS		 3089static bool
3090mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
3091{
3092 struct mlxsw_sp_fib4_entry *fib4_entry;
3093
3094 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
3095 common);
3096 return !fib4_entry->tos;
3097}
3098
013b20f9
IS		 3099static bool
3100mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
3101{
3102 struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
3103
4f1c7f1f
IS		 3104 switch (fib_entry->fib_node->fib->proto) {
3105 case MLXSW_SP_L3_PROTO_IPV4:
3106 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
3107 return false;
3108 break;
3109 case MLXSW_SP_L3_PROTO_IPV6:
3110 break;
3111 }
9aecce1c 3112
013b20f9
IS		 3113 switch (fib_entry->type) {
3114 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
3115 return !!nh_group->adj_index_valid;
3116 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
70ad3506 3117 return !!nh_group->nh_rif;
4607f6d2
PM		 3118 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
3119 return true;
013b20f9
IS		 3120 default:
3121 return false;
3122 }
3123}
3124
428b851f
IS		 3125static struct mlxsw_sp_nexthop *
3126mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
3127 const struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
3128{
3129 int i;
3130
3131 for (i = 0; i < nh_grp->count; i++) {
3132 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3133 struct rt6_info *rt = mlxsw_sp_rt6->rt;
3134
3135 if (nh->rif && nh->rif->dev == rt->dst.dev &&
3136 ipv6_addr_equal((const struct in6_addr *) &nh->gw_addr,
3137 &rt->rt6i_gateway))
3138 return nh;
3139 continue;
3140 }
3141
3142 return NULL;
3143}
3144
3984d1a8
IS		 3145static void
3146mlxsw_sp_fib4_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3147{
3148 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3149 int i;
3150
4607f6d2
PM		 3151 if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ||
3152 fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP) {
3984d1a8
IS		 3153 nh_grp->nexthops->key.fib_nh->nh_flags |= RTNH_F_OFFLOAD;
3154 return;
3155 }
3156
3157 for (i = 0; i < nh_grp->count; i++) {
3158 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3159
3160 if (nh->offloaded)
3161 nh->key.fib_nh->nh_flags |= RTNH_F_OFFLOAD;
3162 else
3163 nh->key.fib_nh->nh_flags &= ~RTNH_F_OFFLOAD;
3164 }
3165}
3166
3167static void
3168mlxsw_sp_fib4_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3169{
3170 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3171 int i;
3172
3173 for (i = 0; i < nh_grp->count; i++) {
3174 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3175
3176 nh->key.fib_nh->nh_flags &= ~RTNH_F_OFFLOAD;
3177 }
3178}
3179
428b851f
IS		 3180static void
3181mlxsw_sp_fib6_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3182{
3183 struct mlxsw_sp_fib6_entry *fib6_entry;
3184 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3185
3186 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
3187 common);
3188
3189 if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL) {
3190 list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
fe400799 3191 list)->rt->rt6i_nh_flags |= RTNH_F_OFFLOAD;
428b851f
IS		 3192 return;
3193 }
3194
3195 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3196 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3197 struct mlxsw_sp_nexthop *nh;
3198
3199 nh = mlxsw_sp_rt6_nexthop(nh_grp, mlxsw_sp_rt6);
3200 if (nh && nh->offloaded)
fe400799 3201 mlxsw_sp_rt6->rt->rt6i_nh_flags |= RTNH_F_OFFLOAD;
428b851f 3202 else
fe400799 3203 mlxsw_sp_rt6->rt->rt6i_nh_flags &= ~RTNH_F_OFFLOAD;
428b851f
IS		 3204 }
3205}
3206
3207static void
3208mlxsw_sp_fib6_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3209{
3210 struct mlxsw_sp_fib6_entry *fib6_entry;
3211 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3212
3213 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
3214 common);
3215 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3216 struct rt6_info *rt = mlxsw_sp_rt6->rt;
3217
fe400799 3218 rt->rt6i_nh_flags &= ~RTNH_F_OFFLOAD;
428b851f
IS		 3219 }
3220}
3221
013b20f9
IS		 3222static void mlxsw_sp_fib_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3223{
76610ebb 3224 switch (fib_entry->fib_node->fib->proto) {
013b20f9 3225 case MLXSW_SP_L3_PROTO_IPV4:
3984d1a8 3226 mlxsw_sp_fib4_entry_offload_set(fib_entry);
013b20f9
IS		 3227 break;
3228 case MLXSW_SP_L3_PROTO_IPV6:
428b851f
IS		 3229 mlxsw_sp_fib6_entry_offload_set(fib_entry);
3230 break;
013b20f9
IS		 3231 }
3232}
3233
3234static void
3235mlxsw_sp_fib_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3236{
76610ebb 3237 switch (fib_entry->fib_node->fib->proto) {
013b20f9 3238 case MLXSW_SP_L3_PROTO_IPV4:
3984d1a8 3239 mlxsw_sp_fib4_entry_offload_unset(fib_entry);
013b20f9
IS		 3240 break;
3241 case MLXSW_SP_L3_PROTO_IPV6:
428b851f
IS		 3242 mlxsw_sp_fib6_entry_offload_unset(fib_entry);
3243 break;
013b20f9 3244 }
013b20f9
IS		 3245}
3246
3247static void
3248mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
3249 enum mlxsw_reg_ralue_op op, int err)
3250{
3251 switch (op) {
3252 case MLXSW_REG_RALUE_OP_WRITE_DELETE:
013b20f9
IS		 3253 return mlxsw_sp_fib_entry_offload_unset(fib_entry);
3254 case MLXSW_REG_RALUE_OP_WRITE_WRITE:
3255 if (err)
3256 return;
1353ee70 3257 if (mlxsw_sp_fib_entry_should_offload(fib_entry))
013b20f9 3258 mlxsw_sp_fib_entry_offload_set(fib_entry);
85f44a15 3259 else
013b20f9
IS		 3260 mlxsw_sp_fib_entry_offload_unset(fib_entry);
3261 return;
3262 default:
3263 return;
3264 }
3265}
3266
9dbf4d76
IS		 3267static void
3268mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
3269 const struct mlxsw_sp_fib_entry *fib_entry,
3270 enum mlxsw_reg_ralue_op op)
a7ff87ac 3271{
76610ebb 3272 struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
9dbf4d76
IS		 3273 enum mlxsw_reg_ralxx_protocol proto;
3274 u32 *p_dip;
3275
3276 proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
3277
3278 switch (fib->proto) {
3279 case MLXSW_SP_L3_PROTO_IPV4:
3280 p_dip = (u32 *) fib_entry->fib_node->key.addr;
3281 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
3282 fib_entry->fib_node->key.prefix_len,
3283 *p_dip);
3284 break;
3285 case MLXSW_SP_L3_PROTO_IPV6:
3286 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
3287 fib_entry->fib_node->key.prefix_len,
3288 fib_entry->fib_node->key.addr);
3289 break;
3290 }
3291}
3292
3293static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
3294 struct mlxsw_sp_fib_entry *fib_entry,
3295 enum mlxsw_reg_ralue_op op)
3296{
3297 char ralue_pl[MLXSW_REG_RALUE_LEN];
a7ff87ac
JP		 3298 enum mlxsw_reg_ralue_trap_action trap_action;
3299 u16 trap_id = 0;
3300 u32 adjacency_index = 0;
3301 u16 ecmp_size = 0;
3302
3303 /* In case the nexthop group adjacency index is valid, use it
3304 * with provided ECMP size. Otherwise, setup trap and pass
3305 * traffic to kernel.
3306 */
4b411477 3307 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
a7ff87ac
JP		 3308 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
3309 adjacency_index = fib_entry->nh_group->adj_index;
3310 ecmp_size = fib_entry->nh_group->ecmp_size;
3311 } else {
3312 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
3313 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
3314 }
3315
9dbf4d76 3316 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
a7ff87ac
JP		 3317 mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
3318 adjacency_index, ecmp_size);
3319 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3320}
3321
9dbf4d76
IS		 3322static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
3323 struct mlxsw_sp_fib_entry *fib_entry,
3324 enum mlxsw_reg_ralue_op op)
61c503f9 3325{
bf95233e 3326 struct mlxsw_sp_rif *rif = fib_entry->nh_group->nh_rif;
70ad3506 3327 enum mlxsw_reg_ralue_trap_action trap_action;
61c503f9 3328 char ralue_pl[MLXSW_REG_RALUE_LEN];
70ad3506 3329 u16 trap_id = 0;
bf95233e 3330 u16 rif_index = 0;
70ad3506
IS		 3331
3332 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
3333 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
bf95233e 3334 rif_index = rif->rif_index;
70ad3506
IS		 3335 } else {
3336 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
3337 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
3338 }
61c503f9 3339
9dbf4d76 3340 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
bf95233e
AS		 3341 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
3342 rif_index);
61c503f9
JP		 3343 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3344}
3345
9dbf4d76
IS		 3346static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
3347 struct mlxsw_sp_fib_entry *fib_entry,
3348 enum mlxsw_reg_ralue_op op)
61c503f9
JP		 3349{
3350 char ralue_pl[MLXSW_REG_RALUE_LEN];
61c503f9 3351
9dbf4d76 3352 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
61c503f9
JP		 3353 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
3354 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3355}
3356
4607f6d2
PM		 3357static int
3358mlxsw_sp_fib_entry_op_ipip_decap(struct mlxsw_sp *mlxsw_sp,
3359 struct mlxsw_sp_fib_entry *fib_entry,
3360 enum mlxsw_reg_ralue_op op)
3361{
3362 struct mlxsw_sp_ipip_entry *ipip_entry = fib_entry->decap.ipip_entry;
3363 const struct mlxsw_sp_ipip_ops *ipip_ops;
3364
3365 if (WARN_ON(!ipip_entry))
3366 return -EINVAL;
3367
3368 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
3369 return ipip_ops->fib_entry_op(mlxsw_sp, ipip_entry, op,
3370 fib_entry->decap.tunnel_index);
3371}
3372
9dbf4d76
IS		 3373static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
3374 struct mlxsw_sp_fib_entry *fib_entry,
3375 enum mlxsw_reg_ralue_op op)
61c503f9
JP		 3376{
3377 switch (fib_entry->type) {
3378 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
9dbf4d76 3379 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
61c503f9 3380 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
9dbf4d76 3381 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
61c503f9 3382 case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
9dbf4d76 3383 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
4607f6d2
PM		 3384 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
3385 return mlxsw_sp_fib_entry_op_ipip_decap(mlxsw_sp,
3386 fib_entry, op);
61c503f9
JP		 3387 }
3388 return -EINVAL;
3389}
3390
3391static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
3392 struct mlxsw_sp_fib_entry *fib_entry,
3393 enum mlxsw_reg_ralue_op op)
3394{
9dbf4d76 3395 int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
013b20f9 3396
013b20f9 3397 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, err);
9dbf4d76 3398
013b20f9 3399 return err;
61c503f9
JP		 3400}
3401
3402static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
3403 struct mlxsw_sp_fib_entry *fib_entry)
3404{
7146da31
JP		 3405 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
3406 MLXSW_REG_RALUE_OP_WRITE_WRITE);
61c503f9
JP		 3407}
3408
3409static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
3410 struct mlxsw_sp_fib_entry *fib_entry)
3411{
3412 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
3413 MLXSW_REG_RALUE_OP_WRITE_DELETE);
3414}
3415
61c503f9 3416static int
013b20f9
IS		 3417mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
3418 const struct fib_entry_notifier_info *fen_info,
3419 struct mlxsw_sp_fib_entry *fib_entry)
61c503f9 3420{
4607f6d2
PM		 3421 union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };
3422 struct net_device *dev = fen_info->fi->fib_dev;
3423 struct mlxsw_sp_ipip_entry *ipip_entry;
b45f64d1 3424 struct fib_info *fi = fen_info->fi;
61c503f9 3425
97989ee0 3426 switch (fen_info->type) {
97989ee0 3427 case RTN_LOCAL:
4607f6d2
PM		 3428 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, dev,
3429 MLXSW_SP_L3_PROTO_IPV4, dip);
3430 if (ipip_entry) {
3431 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
3432 return mlxsw_sp_fib_entry_decap_init(mlxsw_sp,
3433 fib_entry,
3434 ipip_entry);
3435 }
3436 /* fall through */
3437 case RTN_BROADCAST:
61c503f9
JP		 3438 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
3439 return 0;
97989ee0
IS		 3440 case RTN_UNREACHABLE: /* fall through */
3441 case RTN_BLACKHOLE: /* fall through */
3442 case RTN_PROHIBIT:
3443 /* Packets hitting these routes need to be trapped, but
3444 * can do so with a lower priority than packets directed
3445 * at the host, so use action type local instead of trap.
3446 */
61c503f9 3447 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
97989ee0
IS		 3448 return 0;
3449 case RTN_UNICAST:
9b01451a 3450 if (mlxsw_sp_fi_is_gateway(mlxsw_sp, fi))
97989ee0 3451 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
9b01451a
PM		 3452 else
3453 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
97989ee0
IS		 3454 return 0;
3455 default:
3456 return -EINVAL;
3457 }
a7ff87ac
JP		 3458}
3459
4f1c7f1f 3460static struct mlxsw_sp_fib4_entry *
9aecce1c
IS		 3461mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
3462 struct mlxsw_sp_fib_node *fib_node,
3463 const struct fib_entry_notifier_info *fen_info)
61c503f9 3464{
4f1c7f1f 3465 struct mlxsw_sp_fib4_entry *fib4_entry;
61c503f9 3466 struct mlxsw_sp_fib_entry *fib_entry;
61c503f9
JP		 3467 int err;
3468
4f1c7f1f
IS		 3469 fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
3470 if (!fib4_entry)
3471 return ERR_PTR(-ENOMEM);
3472 fib_entry = &fib4_entry->common;
61c503f9 3473
013b20f9 3474 err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
61c503f9 3475 if (err)
013b20f9 3476 goto err_fib4_entry_type_set;
61c503f9 3477
0e6ea2a4 3478 err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
b8399a1e 3479 if (err)
0e6ea2a4 3480 goto err_nexthop4_group_get;
b8399a1e 3481
4f1c7f1f
IS		 3482 fib4_entry->prio = fen_info->fi->fib_priority;
3483 fib4_entry->tb_id = fen_info->tb_id;
3484 fib4_entry->type = fen_info->type;
3485 fib4_entry->tos = fen_info->tos;
9aecce1c
IS		 3486
3487 fib_entry->fib_node = fib_node;
3488
4f1c7f1f 3489 return fib4_entry;
5b004412 3490
0e6ea2a4 3491err_nexthop4_group_get:
013b20f9 3492err_fib4_entry_type_set:
4f1c7f1f 3493 kfree(fib4_entry);
5b004412
JP		 3494 return ERR_PTR(err);
3495}
3496
9aecce1c 3497static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3498 struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 3499{
0e6ea2a4 3500 mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
4f1c7f1f 3501 kfree(fib4_entry);
9aecce1c
IS		 3502}
3503
4f1c7f1f 3504static struct mlxsw_sp_fib4_entry *
9aecce1c
IS		 3505mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
3506 const struct fib_entry_notifier_info *fen_info)
5b004412 3507{
4f1c7f1f 3508 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3509 struct mlxsw_sp_fib_node *fib_node;
160e22aa
IS		 3510 struct mlxsw_sp_fib *fib;
3511 struct mlxsw_sp_vr *vr;
3512
3513 vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
3514 if (!vr)
3515 return NULL;
3516 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
5b004412 3517
160e22aa
IS		 3518 fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
3519 sizeof(fen_info->dst),
3520 fen_info->dst_len);
3521 if (!fib_node)
9aecce1c
IS		 3522 return NULL;
3523
4f1c7f1f
IS		 3524 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
3525 if (fib4_entry->tb_id == fen_info->tb_id &&
3526 fib4_entry->tos == fen_info->tos &&
3527 fib4_entry->type == fen_info->type &&
ba31d366
AS		 3528 mlxsw_sp_nexthop4_group_fi(fib4_entry->common.nh_group) ==
3529 fen_info->fi) {
4f1c7f1f 3530 return fib4_entry;
9aecce1c
IS		 3531 }
3532 }
3533
3534 return NULL;
3535}
3536
3537static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
3538 .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
3539 .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
3540 .key_len = sizeof(struct mlxsw_sp_fib_key),
3541 .automatic_shrinking = true,
3542};
3543
3544static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
3545 struct mlxsw_sp_fib_node *fib_node)
3546{
3547 return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
3548 mlxsw_sp_fib_ht_params);
3549}
3550
3551static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
3552 struct mlxsw_sp_fib_node *fib_node)
3553{
3554 rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
3555 mlxsw_sp_fib_ht_params);
3556}
3557
3558static struct mlxsw_sp_fib_node *
3559mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
3560 size_t addr_len, unsigned char prefix_len)
3561{
3562 struct mlxsw_sp_fib_key key;
3563
3564 memset(&key, 0, sizeof(key));
3565 memcpy(key.addr, addr, addr_len);
3566 key.prefix_len = prefix_len;
3567 return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
3568}
3569
3570static struct mlxsw_sp_fib_node *
76610ebb 3571mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
9aecce1c
IS		 3572 size_t addr_len, unsigned char prefix_len)
3573{
3574 struct mlxsw_sp_fib_node *fib_node;
3575
3576 fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
3577 if (!fib_node)
5b004412
JP		 3578 return NULL;
3579
9aecce1c 3580 INIT_LIST_HEAD(&fib_node->entry_list);
76610ebb 3581 list_add(&fib_node->list, &fib->node_list);
9aecce1c
IS		 3582 memcpy(fib_node->key.addr, addr, addr_len);
3583 fib_node->key.prefix_len = prefix_len;
9aecce1c
IS		 3584
3585 return fib_node;
3586}
3587
3588static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
3589{
9aecce1c
IS		 3590 list_del(&fib_node->list);
3591 WARN_ON(!list_empty(&fib_node->entry_list));
3592 kfree(fib_node);
3593}
3594
3595static bool
3596mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
3597 const struct mlxsw_sp_fib_entry *fib_entry)
3598{
3599 return list_first_entry(&fib_node->entry_list,
3600 struct mlxsw_sp_fib_entry, list) == fib_entry;
3601}
3602
fc922bb0
IS		 3603static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp,
3604 struct mlxsw_sp_fib *fib,
3605 struct mlxsw_sp_fib_node *fib_node)
3606{
3607 struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
3608 struct mlxsw_sp_lpm_tree *lpm_tree;
3609 int err;
3610
3611 /* Since the tree is shared between all virtual routers we must
3612 * make sure it contains all the required prefix lengths. This
3613 * can be computed by either adding the new prefix length to the
3614 * existing prefix usage of a bound tree, or by aggregating the
3615 * prefix lengths across all virtual routers and adding the new
3616 * one as well.
3617 */
3618 if (fib->lpm_tree)
3619 mlxsw_sp_prefix_usage_cpy(&req_prefix_usage,
3620 &fib->lpm_tree->prefix_usage);
3621 else
3622 mlxsw_sp_vrs_prefixes(mlxsw_sp, fib->proto, &req_prefix_usage);
3623 mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
3624
3625 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
3626 fib->proto);
3627 if (IS_ERR(lpm_tree))
3628 return PTR_ERR(lpm_tree);
3629
3630 if (fib->lpm_tree && fib->lpm_tree->id == lpm_tree->id)
3631 return 0;
3632
3633 err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
3634 if (err)
3635 return err;
3636
3637 return 0;
3638}
3639
3640static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
3641 struct mlxsw_sp_fib *fib)
3642{
fc922bb0
IS		 3643 if (!mlxsw_sp_prefix_usage_none(&fib->prefix_usage))
3644 return;
3645 mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
3646 mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree);
3647 fib->lpm_tree = NULL;
3648}
3649
9aecce1c
IS		 3650static void mlxsw_sp_fib_node_prefix_inc(struct mlxsw_sp_fib_node *fib_node)
3651{
3652 unsigned char prefix_len = fib_node->key.prefix_len;
76610ebb 3653 struct mlxsw_sp_fib *fib = fib_node->fib;
9aecce1c
IS		 3654
3655 if (fib->prefix_ref_count[prefix_len]++ == 0)
3656 mlxsw_sp_prefix_usage_set(&fib->prefix_usage, prefix_len);
3657}
3658
3659static void mlxsw_sp_fib_node_prefix_dec(struct mlxsw_sp_fib_node *fib_node)
3660{
3661 unsigned char prefix_len = fib_node->key.prefix_len;
76610ebb 3662 struct mlxsw_sp_fib *fib = fib_node->fib;
9aecce1c
IS		 3663
3664 if (--fib->prefix_ref_count[prefix_len] == 0)
3665 mlxsw_sp_prefix_usage_clear(&fib->prefix_usage, prefix_len);
5b004412
JP		 3666}
3667
76610ebb
IS		 3668static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
3669 struct mlxsw_sp_fib_node *fib_node,
3670 struct mlxsw_sp_fib *fib)
3671{
76610ebb
IS		 3672 int err;
3673
3674 err = mlxsw_sp_fib_node_insert(fib, fib_node);
3675 if (err)
3676 return err;
3677 fib_node->fib = fib;
3678
fc922bb0
IS		 3679 err = mlxsw_sp_fib_lpm_tree_link(mlxsw_sp, fib, fib_node);
3680 if (err)
3681 goto err_fib_lpm_tree_link;
76610ebb
IS		 3682
3683 mlxsw_sp_fib_node_prefix_inc(fib_node);
3684
3685 return 0;
3686
fc922bb0 3687err_fib_lpm_tree_link:
76610ebb
IS		 3688 fib_node->fib = NULL;
3689 mlxsw_sp_fib_node_remove(fib, fib_node);
3690 return err;
3691}
3692
3693static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
3694 struct mlxsw_sp_fib_node *fib_node)
3695{
76610ebb
IS		 3696 struct mlxsw_sp_fib *fib = fib_node->fib;
3697
3698 mlxsw_sp_fib_node_prefix_dec(fib_node);
fc922bb0 3699 mlxsw_sp_fib_lpm_tree_unlink(mlxsw_sp, fib);
76610ebb
IS		 3700 fib_node->fib = NULL;
3701 mlxsw_sp_fib_node_remove(fib, fib_node);
3702}
3703
9aecce1c 3704static struct mlxsw_sp_fib_node *
731ea1ca
IS		 3705mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
3706 size_t addr_len, unsigned char prefix_len,
3707 enum mlxsw_sp_l3proto proto)
5b004412 3708{
9aecce1c 3709 struct mlxsw_sp_fib_node *fib_node;
76610ebb 3710 struct mlxsw_sp_fib *fib;
9aecce1c
IS		 3711 struct mlxsw_sp_vr *vr;
3712 int err;
3713
731ea1ca 3714 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id);
9aecce1c
IS		 3715 if (IS_ERR(vr))
3716 return ERR_CAST(vr);
731ea1ca 3717 fib = mlxsw_sp_vr_fib(vr, proto);
9aecce1c 3718
731ea1ca 3719 fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
9aecce1c
IS		 3720 if (fib_node)
3721 return fib_node;
5b004412 3722
731ea1ca 3723 fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
9aecce1c
IS		 3724 if (!fib_node) {
3725 err = -ENOMEM;
3726 goto err_fib_node_create;
5b004412 3727 }
9aecce1c 3728
76610ebb
IS		 3729 err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
3730 if (err)
3731 goto err_fib_node_init;
3732
9aecce1c
IS		 3733 return fib_node;
3734
76610ebb
IS		 3735err_fib_node_init:
3736 mlxsw_sp_fib_node_destroy(fib_node);
9aecce1c 3737err_fib_node_create:
76610ebb 3738 mlxsw_sp_vr_put(vr);
9aecce1c 3739 return ERR_PTR(err);
5b004412
JP		 3740}
3741
731ea1ca
IS		 3742static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
3743 struct mlxsw_sp_fib_node *fib_node)
5b004412 3744{
76610ebb 3745 struct mlxsw_sp_vr *vr = fib_node->fib->vr;
5b004412 3746
9aecce1c
IS		 3747 if (!list_empty(&fib_node->entry_list))
3748 return;
76610ebb 3749 mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
9aecce1c 3750 mlxsw_sp_fib_node_destroy(fib_node);
76610ebb 3751 mlxsw_sp_vr_put(vr);
61c503f9
JP		 3752}
3753
4f1c7f1f 3754static struct mlxsw_sp_fib4_entry *
9aecce1c 3755mlxsw_sp_fib4_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
4f1c7f1f 3756 const struct mlxsw_sp_fib4_entry *new4_entry)
61c503f9 3757{
4f1c7f1f 3758 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3759
4f1c7f1f
IS		 3760 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
3761 if (fib4_entry->tb_id > new4_entry->tb_id)
9aecce1c 3762 continue;
4f1c7f1f 3763 if (fib4_entry->tb_id != new4_entry->tb_id)
9aecce1c 3764 break;
4f1c7f1f 3765 if (fib4_entry->tos > new4_entry->tos)
9aecce1c 3766 continue;
4f1c7f1f
IS		 3767 if (fib4_entry->prio >= new4_entry->prio ||
3768 fib4_entry->tos < new4_entry->tos)
3769 return fib4_entry;
9aecce1c
IS		 3770 }
3771
3772 return NULL;
3773}
3774
4f1c7f1f
IS		 3775static int
3776mlxsw_sp_fib4_node_list_append(struct mlxsw_sp_fib4_entry *fib4_entry,
3777 struct mlxsw_sp_fib4_entry *new4_entry)
4283bce5
IS		 3778{
3779 struct mlxsw_sp_fib_node *fib_node;
3780
4f1c7f1f 3781 if (WARN_ON(!fib4_entry))
4283bce5
IS		 3782 return -EINVAL;
3783
4f1c7f1f
IS		 3784 fib_node = fib4_entry->common.fib_node;
3785 list_for_each_entry_from(fib4_entry, &fib_node->entry_list,
3786 common.list) {
3787 if (fib4_entry->tb_id != new4_entry->tb_id ||
3788 fib4_entry->tos != new4_entry->tos ||
3789 fib4_entry->prio != new4_entry->prio)
4283bce5
IS		 3790 break;
3791 }
3792
4f1c7f1f 3793 list_add_tail(&new4_entry->common.list, &fib4_entry->common.list);
4283bce5
IS		 3794 return 0;
3795}
3796
9aecce1c 3797static int
9efbee6f 3798mlxsw_sp_fib4_node_list_insert(struct mlxsw_sp_fib4_entry *new4_entry,
599cf8f9 3799 bool replace, bool append)
9aecce1c 3800{
9efbee6f 3801 struct mlxsw_sp_fib_node *fib_node = new4_entry->common.fib_node;
4f1c7f1f 3802 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3803
4f1c7f1f 3804 fib4_entry = mlxsw_sp_fib4_node_entry_find(fib_node, new4_entry);
9aecce1c 3805
4283bce5 3806 if (append)
4f1c7f1f
IS		 3807 return mlxsw_sp_fib4_node_list_append(fib4_entry, new4_entry);
3808 if (replace && WARN_ON(!fib4_entry))
599cf8f9 3809 return -EINVAL;
4283bce5 3810
599cf8f9
IS		 3811 /* Insert new entry before replaced one, so that we can later
3812 * remove the second.
3813 */
4f1c7f1f
IS		 3814 if (fib4_entry) {
3815 list_add_tail(&new4_entry->common.list,
3816 &fib4_entry->common.list);
9aecce1c 3817 } else {
4f1c7f1f 3818 struct mlxsw_sp_fib4_entry *last;
9aecce1c 3819
4f1c7f1f
IS		 3820 list_for_each_entry(last, &fib_node->entry_list, common.list) {
3821 if (new4_entry->tb_id > last->tb_id)
9aecce1c 3822 break;
4f1c7f1f 3823 fib4_entry = last;
9aecce1c
IS		 3824 }
3825
4f1c7f1f
IS		 3826 if (fib4_entry)
3827 list_add(&new4_entry->common.list,
3828 &fib4_entry->common.list);
9aecce1c 3829 else
4f1c7f1f
IS		 3830 list_add(&new4_entry->common.list,
3831 &fib_node->entry_list);
9aecce1c
IS		 3832 }
3833
3834 return 0;
3835}
3836
3837static void
4f1c7f1f 3838mlxsw_sp_fib4_node_list_remove(struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 3839{
4f1c7f1f 3840 list_del(&fib4_entry->common.list);
9aecce1c
IS		 3841}
3842
80c238f9
IS		 3843static int mlxsw_sp_fib_node_entry_add(struct mlxsw_sp *mlxsw_sp,
3844 struct mlxsw_sp_fib_entry *fib_entry)
9aecce1c 3845{
9efbee6f
IS		 3846 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
3847
9aecce1c
IS		 3848 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
3849 return 0;
3850
3851 /* To prevent packet loss, overwrite the previously offloaded
3852 * entry.
3853 */
3854 if (!list_is_singular(&fib_node->entry_list)) {
3855 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
3856 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
3857
3858 mlxsw_sp_fib_entry_offload_refresh(n, op, 0);
3859 }
3860
3861 return mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
3862}
3863
80c238f9
IS		 3864static void mlxsw_sp_fib_node_entry_del(struct mlxsw_sp *mlxsw_sp,
3865 struct mlxsw_sp_fib_entry *fib_entry)
9aecce1c 3866{
9efbee6f
IS		 3867 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
3868
9aecce1c
IS		 3869 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
3870 return;
3871
3872 /* Promote the next entry by overwriting the deleted entry */
3873 if (!list_is_singular(&fib_node->entry_list)) {
3874 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
3875 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
3876
3877 mlxsw_sp_fib_entry_update(mlxsw_sp, n);
3878 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
3879 return;
3880 }
3881
3882 mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
3883}
3884
3885static int mlxsw_sp_fib4_node_entry_link(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3886 struct mlxsw_sp_fib4_entry *fib4_entry,
599cf8f9 3887 bool replace, bool append)
9aecce1c 3888{
9aecce1c
IS		 3889 int err;
3890
9efbee6f 3891 err = mlxsw_sp_fib4_node_list_insert(fib4_entry, replace, append);
9aecce1c
IS		 3892 if (err)
3893 return err;
3894
80c238f9 3895 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib4_entry->common);
9aecce1c 3896 if (err)
80c238f9 3897 goto err_fib_node_entry_add;
9aecce1c 3898
9aecce1c
IS		 3899 return 0;
3900
80c238f9 3901err_fib_node_entry_add:
4f1c7f1f 3902 mlxsw_sp_fib4_node_list_remove(fib4_entry);
9aecce1c
IS		 3903 return err;
3904}
3905
3906static void
3907mlxsw_sp_fib4_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3908 struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 3909{
80c238f9 3910 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib4_entry->common);
4f1c7f1f 3911 mlxsw_sp_fib4_node_list_remove(fib4_entry);
4607f6d2
PM		 3912
3913 if (fib4_entry->common.type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP)
3914 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, &fib4_entry->common);
9aecce1c
IS		 3915}
3916
599cf8f9 3917static void mlxsw_sp_fib4_entry_replace(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3918 struct mlxsw_sp_fib4_entry *fib4_entry,
599cf8f9
IS		 3919 bool replace)
3920{
4f1c7f1f
IS		 3921 struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
3922 struct mlxsw_sp_fib4_entry *replaced;
599cf8f9
IS		 3923
3924 if (!replace)
3925 return;
3926
3927 /* We inserted the new entry before replaced one */
4f1c7f1f 3928 replaced = list_next_entry(fib4_entry, common.list);
599cf8f9
IS		 3929
3930 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, replaced);
3931 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, replaced);
731ea1ca 3932 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
599cf8f9
IS		 3933}
3934
9aecce1c
IS		 3935static int
3936mlxsw_sp_router_fib4_add(struct mlxsw_sp *mlxsw_sp,
4283bce5 3937 const struct fib_entry_notifier_info *fen_info,
599cf8f9 3938 bool replace, bool append)
9aecce1c 3939{
4f1c7f1f 3940 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3941 struct mlxsw_sp_fib_node *fib_node;
61c503f9
JP		 3942 int err;
3943
9011b677 3944 if (mlxsw_sp->router->aborted)
b45f64d1
JP		 3945 return 0;
3946
731ea1ca
IS		 3947 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
3948 &fen_info->dst, sizeof(fen_info->dst),
3949 fen_info->dst_len,
3950 MLXSW_SP_L3_PROTO_IPV4);
9aecce1c
IS		 3951 if (IS_ERR(fib_node)) {
3952 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
3953 return PTR_ERR(fib_node);
b45f64d1 3954 }
61c503f9 3955
4f1c7f1f
IS		 3956 fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
3957 if (IS_ERR(fib4_entry)) {
9aecce1c 3958 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
4f1c7f1f 3959 err = PTR_ERR(fib4_entry);
9aecce1c
IS		 3960 goto err_fib4_entry_create;
3961 }
5b004412 3962
4f1c7f1f 3963 err = mlxsw_sp_fib4_node_entry_link(mlxsw_sp, fib4_entry, replace,
599cf8f9 3964 append);
b45f64d1 3965 if (err) {
9aecce1c
IS		 3966 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
3967 goto err_fib4_node_entry_link;
b45f64d1 3968 }
9aecce1c 3969
4f1c7f1f 3970 mlxsw_sp_fib4_entry_replace(mlxsw_sp, fib4_entry, replace);
599cf8f9 3971
61c503f9
JP		 3972 return 0;
3973
9aecce1c 3974err_fib4_node_entry_link:
4f1c7f1f 3975 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
9aecce1c 3976err_fib4_entry_create:
731ea1ca 3977 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
61c503f9
JP		 3978 return err;
3979}
3980
37956d78
JP		 3981static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
3982 struct fib_entry_notifier_info *fen_info)
61c503f9 3983{
4f1c7f1f 3984 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3985 struct mlxsw_sp_fib_node *fib_node;
61c503f9 3986
9011b677 3987 if (mlxsw_sp->router->aborted)
37956d78 3988 return;
b45f64d1 3989
4f1c7f1f
IS		 3990 fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
3991 if (WARN_ON(!fib4_entry))
37956d78 3992 return;
4f1c7f1f 3993 fib_node = fib4_entry->common.fib_node;
5b004412 3994
4f1c7f1f
IS		 3995 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
3996 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
731ea1ca 3997 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
61c503f9 3998}
b45f64d1 3999
428b851f
IS		 4000static bool mlxsw_sp_fib6_rt_should_ignore(const struct rt6_info *rt)
4001{
4002 /* Packets with link-local destination IP arriving to the router
4003 * are trapped to the CPU, so no need to program specific routes
4004 * for them.
4005 */
4006 if (ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_LINKLOCAL)
4007 return true;
4008
4009 /* Multicast routes aren't supported, so ignore them. Neighbour
4010 * Discovery packets are specifically trapped.
4011 */
4012 if (ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_MULTICAST)
4013 return true;
4014
4015 /* Cloned routes are irrelevant in the forwarding path. */
4016 if (rt->rt6i_flags & RTF_CACHE)
4017 return true;
4018
4019 return false;
4020}
4021
4022static struct mlxsw_sp_rt6 *mlxsw_sp_rt6_create(struct rt6_info *rt)
4023{
4024 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4025
4026 mlxsw_sp_rt6 = kzalloc(sizeof(*mlxsw_sp_rt6), GFP_KERNEL);
4027 if (!mlxsw_sp_rt6)
4028 return ERR_PTR(-ENOMEM);
4029
4030 /* In case of route replace, replaced route is deleted with
4031 * no notification. Take reference to prevent accessing freed
4032 * memory.
4033 */
4034 mlxsw_sp_rt6->rt = rt;
4035 rt6_hold(rt);
4036
4037 return mlxsw_sp_rt6;
4038}
4039
4040#if IS_ENABLED(CONFIG_IPV6)
4041static void mlxsw_sp_rt6_release(struct rt6_info *rt)
4042{
4043 rt6_release(rt);
4044}
4045#else
4046static void mlxsw_sp_rt6_release(struct rt6_info *rt)
4047{
4048}
4049#endif
4050
4051static void mlxsw_sp_rt6_destroy(struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
4052{
4053 mlxsw_sp_rt6_release(mlxsw_sp_rt6->rt);
4054 kfree(mlxsw_sp_rt6);
4055}
4056
4057static bool mlxsw_sp_fib6_rt_can_mp(const struct rt6_info *rt)
4058{
4059 /* RTF_CACHE routes are ignored */
4060 return (rt->rt6i_flags & (RTF_GATEWAY | RTF_ADDRCONF)) == RTF_GATEWAY;
4061}
4062
4063static struct rt6_info *
4064mlxsw_sp_fib6_entry_rt(const struct mlxsw_sp_fib6_entry *fib6_entry)
4065{
4066 return list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
4067 list)->rt;
4068}
4069
4070static struct mlxsw_sp_fib6_entry *
4071mlxsw_sp_fib6_node_mp_entry_find(const struct mlxsw_sp_fib_node *fib_node,
0a7fd1ac 4072 const struct rt6_info *nrt, bool replace)
428b851f
IS		 4073{
4074 struct mlxsw_sp_fib6_entry *fib6_entry;
4075
0a7fd1ac 4076 if (!mlxsw_sp_fib6_rt_can_mp(nrt) || replace)
428b851f
IS		 4077 return NULL;
4078
4079 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4080 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4081
4082 /* RT6_TABLE_LOCAL and RT6_TABLE_MAIN share the same
4083 * virtual router.
4084 */
4085 if (rt->rt6i_table->tb6_id > nrt->rt6i_table->tb6_id)
4086 continue;
4087 if (rt->rt6i_table->tb6_id != nrt->rt6i_table->tb6_id)
4088 break;
4089 if (rt->rt6i_metric < nrt->rt6i_metric)
4090 continue;
4091 if (rt->rt6i_metric == nrt->rt6i_metric &&
4092 mlxsw_sp_fib6_rt_can_mp(rt))
4093 return fib6_entry;
4094 if (rt->rt6i_metric > nrt->rt6i_metric)
4095 break;
4096 }
4097
4098 return NULL;
4099}
4100
4101static struct mlxsw_sp_rt6 *
4102mlxsw_sp_fib6_entry_rt_find(const struct mlxsw_sp_fib6_entry *fib6_entry,
4103 const struct rt6_info *rt)
4104{
4105 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4106
4107 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
4108 if (mlxsw_sp_rt6->rt == rt)
4109 return mlxsw_sp_rt6;
4110 }
4111
4112 return NULL;
4113}
4114
8f28a309
PM		 4115static bool mlxsw_sp_nexthop6_ipip_type(const struct mlxsw_sp *mlxsw_sp,
4116 const struct rt6_info *rt,
4117 enum mlxsw_sp_ipip_type *ret)
4118{
4119 return rt->dst.dev &&
4120 mlxsw_sp_netdev_ipip_type(mlxsw_sp, rt->dst.dev, ret);
4121}
4122
35225e47
PM		 4123static int mlxsw_sp_nexthop6_type_init(struct mlxsw_sp *mlxsw_sp,
4124 struct mlxsw_sp_nexthop_group *nh_grp,
4125 struct mlxsw_sp_nexthop *nh,
4126 const struct rt6_info *rt)
428b851f 4127{
8f28a309 4128 struct mlxsw_sp_router *router = mlxsw_sp->router;
428b851f 4129 struct net_device *dev = rt->dst.dev;
8f28a309 4130 enum mlxsw_sp_ipip_type ipipt;
428b851f
IS		 4131 struct mlxsw_sp_rif *rif;
4132 int err;
4133
8f28a309
PM		 4134 if (mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, &ipipt) &&
4135 router->ipip_ops_arr[ipipt]->can_offload(mlxsw_sp, dev,
4136 MLXSW_SP_L3_PROTO_IPV6)) {
4137 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
de0f43c0
PM		 4138 err = mlxsw_sp_nexthop_ipip_init(mlxsw_sp, ipipt, nh, dev);
4139 if (err)
4140 return err;
4141 mlxsw_sp_nexthop_rif_init(nh, &nh->ipip_entry->ol_lb->common);
4142 return 0;
8f28a309
PM		 4143 }
4144
35225e47 4145 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
428b851f
IS		 4146 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
4147 if (!rif)
4148 return 0;
4149 mlxsw_sp_nexthop_rif_init(nh, rif);
4150
4151 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
4152 if (err)
4153 goto err_nexthop_neigh_init;
4154
4155 return 0;
4156
4157err_nexthop_neigh_init:
4158 mlxsw_sp_nexthop_rif_fini(nh);
4159 return err;
4160}
4161
35225e47
PM		 4162static void mlxsw_sp_nexthop6_type_fini(struct mlxsw_sp *mlxsw_sp,
4163 struct mlxsw_sp_nexthop *nh)
4164{
4165 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4166}
4167
4168static int mlxsw_sp_nexthop6_init(struct mlxsw_sp *mlxsw_sp,
4169 struct mlxsw_sp_nexthop_group *nh_grp,
4170 struct mlxsw_sp_nexthop *nh,
4171 const struct rt6_info *rt)
4172{
4173 struct net_device *dev = rt->dst.dev;
4174
4175 nh->nh_grp = nh_grp;
4176 memcpy(&nh->gw_addr, &rt->rt6i_gateway, sizeof(nh->gw_addr));
a5390278 4177 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
35225e47 4178
dbe4598c
AS		 4179 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
4180
35225e47
PM		 4181 if (!dev)
4182 return 0;
4183 nh->ifindex = dev->ifindex;
4184
4185 return mlxsw_sp_nexthop6_type_init(mlxsw_sp, nh_grp, nh, rt);
4186}
4187
428b851f
IS		 4188static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,
4189 struct mlxsw_sp_nexthop *nh)
4190{
35225e47 4191 mlxsw_sp_nexthop6_type_fini(mlxsw_sp, nh);
dbe4598c 4192 list_del(&nh->router_list_node);
a5390278 4193 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
428b851f
IS		 4194}
4195
f6050ee6
PM		 4196static bool mlxsw_sp_rt6_is_gateway(const struct mlxsw_sp *mlxsw_sp,
4197 const struct rt6_info *rt)
4198{
8f28a309
PM		 4199 return rt->rt6i_flags & RTF_GATEWAY ||
4200 mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, NULL);
f6050ee6
PM		 4201}
4202
428b851f
IS		 4203static struct mlxsw_sp_nexthop_group *
4204mlxsw_sp_nexthop6_group_create(struct mlxsw_sp *mlxsw_sp,
4205 struct mlxsw_sp_fib6_entry *fib6_entry)
4206{
4207 struct mlxsw_sp_nexthop_group *nh_grp;
4208 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4209 struct mlxsw_sp_nexthop *nh;
4210 size_t alloc_size;
4211 int i = 0;
4212 int err;
4213
4214 alloc_size = sizeof(*nh_grp) +
4215 fib6_entry->nrt6 * sizeof(struct mlxsw_sp_nexthop);
4216 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
4217 if (!nh_grp)
4218 return ERR_PTR(-ENOMEM);
4219 INIT_LIST_HEAD(&nh_grp->fib_list);
4220#if IS_ENABLED(CONFIG_IPV6)
4221 nh_grp->neigh_tbl = &nd_tbl;
4222#endif
4223 mlxsw_sp_rt6 = list_first_entry(&fib6_entry->rt6_list,
4224 struct mlxsw_sp_rt6, list);
f6050ee6 4225 nh_grp->gateway = mlxsw_sp_rt6_is_gateway(mlxsw_sp, mlxsw_sp_rt6->rt);
428b851f
IS		 4226 nh_grp->count = fib6_entry->nrt6;
4227 for (i = 0; i < nh_grp->count; i++) {
4228 struct rt6_info *rt = mlxsw_sp_rt6->rt;
4229
4230 nh = &nh_grp->nexthops[i];
4231 err = mlxsw_sp_nexthop6_init(mlxsw_sp, nh_grp, nh, rt);
4232 if (err)
4233 goto err_nexthop6_init;
4234 mlxsw_sp_rt6 = list_next_entry(mlxsw_sp_rt6, list);
4235 }
e6f3b379
AS		 4236
4237 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
4238 if (err)
4239 goto err_nexthop_group_insert;
4240
428b851f
IS		 4241 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
4242 return nh_grp;
4243
e6f3b379 4244err_nexthop_group_insert:
428b851f
IS		 4245err_nexthop6_init:
4246 for (i--; i >= 0; i--) {
4247 nh = &nh_grp->nexthops[i];
4248 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
4249 }
4250 kfree(nh_grp);
4251 return ERR_PTR(err);
4252}
4253
4254static void
4255mlxsw_sp_nexthop6_group_destroy(struct mlxsw_sp *mlxsw_sp,
4256 struct mlxsw_sp_nexthop_group *nh_grp)
4257{
4258 struct mlxsw_sp_nexthop *nh;
4259 int i = nh_grp->count;
4260
e6f3b379 4261 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
428b851f
IS		 4262 for (i--; i >= 0; i--) {
4263 nh = &nh_grp->nexthops[i];
4264 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
4265 }
4266 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
4267 WARN_ON(nh_grp->adj_index_valid);
4268 kfree(nh_grp);
4269}
4270
4271static int mlxsw_sp_nexthop6_group_get(struct mlxsw_sp *mlxsw_sp,
4272 struct mlxsw_sp_fib6_entry *fib6_entry)
4273{
4274 struct mlxsw_sp_nexthop_group *nh_grp;
4275
e6f3b379
AS		 4276 nh_grp = mlxsw_sp_nexthop6_group_lookup(mlxsw_sp, fib6_entry);
4277 if (!nh_grp) {
4278 nh_grp = mlxsw_sp_nexthop6_group_create(mlxsw_sp, fib6_entry);
4279 if (IS_ERR(nh_grp))
4280 return PTR_ERR(nh_grp);
4281 }
428b851f
IS		 4282
4283 list_add_tail(&fib6_entry->common.nexthop_group_node,
4284 &nh_grp->fib_list);
4285 fib6_entry->common.nh_group = nh_grp;
4286
4287 return 0;
4288}
4289
4290static void mlxsw_sp_nexthop6_group_put(struct mlxsw_sp *mlxsw_sp,
4291 struct mlxsw_sp_fib_entry *fib_entry)
4292{
4293 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
4294
4295 list_del(&fib_entry->nexthop_group_node);
4296 if (!list_empty(&nh_grp->fib_list))
4297 return;
4298 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, nh_grp);
4299}
4300
4301static int
4302mlxsw_sp_nexthop6_group_update(struct mlxsw_sp *mlxsw_sp,
4303 struct mlxsw_sp_fib6_entry *fib6_entry)
4304{
4305 struct mlxsw_sp_nexthop_group *old_nh_grp = fib6_entry->common.nh_group;
4306 int err;
4307
4308 fib6_entry->common.nh_group = NULL;
4309 list_del(&fib6_entry->common.nexthop_group_node);
4310
4311 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
4312 if (err)
4313 goto err_nexthop6_group_get;
4314
4315 /* In case this entry is offloaded, then the adjacency index
4316 * currently associated with it in the device's table is that
4317 * of the old group. Start using the new one instead.
4318 */
4319 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
4320 if (err)
4321 goto err_fib_node_entry_add;
4322
4323 if (list_empty(&old_nh_grp->fib_list))
4324 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, old_nh_grp);
4325
4326 return 0;
4327
4328err_fib_node_entry_add:
4329 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
4330err_nexthop6_group_get:
4331 list_add_tail(&fib6_entry->common.nexthop_group_node,
4332 &old_nh_grp->fib_list);
4333 fib6_entry->common.nh_group = old_nh_grp;
4334 return err;
4335}
4336
4337static int
4338mlxsw_sp_fib6_entry_nexthop_add(struct mlxsw_sp *mlxsw_sp,
4339 struct mlxsw_sp_fib6_entry *fib6_entry,
4340 struct rt6_info *rt)
4341{
4342 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4343 int err;
4344
4345 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt);
4346 if (IS_ERR(mlxsw_sp_rt6))
4347 return PTR_ERR(mlxsw_sp_rt6);
4348
4349 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
4350 fib6_entry->nrt6++;
4351
4352 err = mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
4353 if (err)
4354 goto err_nexthop6_group_update;
4355
4356 return 0;
4357
4358err_nexthop6_group_update:
4359 fib6_entry->nrt6--;
4360 list_del(&mlxsw_sp_rt6->list);
4361 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4362 return err;
4363}
4364
4365static void
4366mlxsw_sp_fib6_entry_nexthop_del(struct mlxsw_sp *mlxsw_sp,
4367 struct mlxsw_sp_fib6_entry *fib6_entry,
4368 struct rt6_info *rt)
4369{
4370 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4371
4372 mlxsw_sp_rt6 = mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt);
4373 if (WARN_ON(!mlxsw_sp_rt6))
4374 return;
4375
4376 fib6_entry->nrt6--;
4377 list_del(&mlxsw_sp_rt6->list);
4378 mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
4379 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4380}
4381
f6050ee6
PM		 4382static void mlxsw_sp_fib6_entry_type_set(struct mlxsw_sp *mlxsw_sp,
4383 struct mlxsw_sp_fib_entry *fib_entry,
428b851f
IS		 4384 const struct rt6_info *rt)
4385{
4386 /* Packets hitting RTF_REJECT routes need to be discarded by the
4387 * stack. We can rely on their destination device not having a
4388 * RIF (it's the loopback device) and can thus use action type
4389 * local, which will cause them to be trapped with a lower
4390 * priority than packets that need to be locally received.
4391 */
d3b6d377 4392 if (rt->rt6i_flags & (RTF_LOCAL | RTF_ANYCAST))
428b851f
IS		 4393 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
4394 else if (rt->rt6i_flags & RTF_REJECT)
4395 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
f6050ee6 4396 else if (mlxsw_sp_rt6_is_gateway(mlxsw_sp, rt))
428b851f
IS		 4397 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
4398 else
4399 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
4400}
4401
4402static void
4403mlxsw_sp_fib6_entry_rt_destroy_all(struct mlxsw_sp_fib6_entry *fib6_entry)
4404{
4405 struct mlxsw_sp_rt6 *mlxsw_sp_rt6, *tmp;
4406
4407 list_for_each_entry_safe(mlxsw_sp_rt6, tmp, &fib6_entry->rt6_list,
4408 list) {
4409 fib6_entry->nrt6--;
4410 list_del(&mlxsw_sp_rt6->list);
4411 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4412 }
4413}
4414
4415static struct mlxsw_sp_fib6_entry *
4416mlxsw_sp_fib6_entry_create(struct mlxsw_sp *mlxsw_sp,
4417 struct mlxsw_sp_fib_node *fib_node,
4418 struct rt6_info *rt)
4419{
4420 struct mlxsw_sp_fib6_entry *fib6_entry;
4421 struct mlxsw_sp_fib_entry *fib_entry;
4422 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4423 int err;
4424
4425 fib6_entry = kzalloc(sizeof(*fib6_entry), GFP_KERNEL);
4426 if (!fib6_entry)
4427 return ERR_PTR(-ENOMEM);
4428 fib_entry = &fib6_entry->common;
4429
4430 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt);
4431 if (IS_ERR(mlxsw_sp_rt6)) {
4432 err = PTR_ERR(mlxsw_sp_rt6);
4433 goto err_rt6_create;
4434 }
4435
f6050ee6 4436 mlxsw_sp_fib6_entry_type_set(mlxsw_sp, fib_entry, mlxsw_sp_rt6->rt);
428b851f
IS		 4437
4438 INIT_LIST_HEAD(&fib6_entry->rt6_list);
4439 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
4440 fib6_entry->nrt6 = 1;
4441 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
4442 if (err)
4443 goto err_nexthop6_group_get;
4444
4445 fib_entry->fib_node = fib_node;
4446
4447 return fib6_entry;
4448
4449err_nexthop6_group_get:
4450 list_del(&mlxsw_sp_rt6->list);
4451 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4452err_rt6_create:
4453 kfree(fib6_entry);
4454 return ERR_PTR(err);
4455}
4456
4457static void mlxsw_sp_fib6_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4458 struct mlxsw_sp_fib6_entry *fib6_entry)
4459{
4460 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
4461 mlxsw_sp_fib6_entry_rt_destroy_all(fib6_entry);
4462 WARN_ON(fib6_entry->nrt6);
4463 kfree(fib6_entry);
4464}
4465
4466static struct mlxsw_sp_fib6_entry *
4467mlxsw_sp_fib6_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
0a7fd1ac 4468 const struct rt6_info *nrt, bool replace)
428b851f 4469{
0a7fd1ac 4470 struct mlxsw_sp_fib6_entry *fib6_entry, *fallback = NULL;
428b851f
IS		 4471
4472 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4473 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4474
4475 if (rt->rt6i_table->tb6_id > nrt->rt6i_table->tb6_id)
4476 continue;
4477 if (rt->rt6i_table->tb6_id != nrt->rt6i_table->tb6_id)
4478 break;
0a7fd1ac
IS		 4479 if (replace && rt->rt6i_metric == nrt->rt6i_metric) {
4480 if (mlxsw_sp_fib6_rt_can_mp(rt) ==
4481 mlxsw_sp_fib6_rt_can_mp(nrt))
4482 return fib6_entry;
4483 if (mlxsw_sp_fib6_rt_can_mp(nrt))
4484 fallback = fallback ?: fib6_entry;
4485 }
428b851f 4486 if (rt->rt6i_metric > nrt->rt6i_metric)
0a7fd1ac 4487 return fallback ?: fib6_entry;
428b851f
IS		 4488 }
4489
0a7fd1ac 4490 return fallback;
428b851f
IS		 4491}
4492
4493static int
0a7fd1ac
IS		 4494mlxsw_sp_fib6_node_list_insert(struct mlxsw_sp_fib6_entry *new6_entry,
4495 bool replace)
428b851f
IS		 4496{
4497 struct mlxsw_sp_fib_node *fib_node = new6_entry->common.fib_node;
4498 struct rt6_info *nrt = mlxsw_sp_fib6_entry_rt(new6_entry);
4499 struct mlxsw_sp_fib6_entry *fib6_entry;
4500
0a7fd1ac
IS		 4501 fib6_entry = mlxsw_sp_fib6_node_entry_find(fib_node, nrt, replace);
4502
4503 if (replace && WARN_ON(!fib6_entry))
4504 return -EINVAL;
428b851f
IS		 4505
4506 if (fib6_entry) {
4507 list_add_tail(&new6_entry->common.list,
4508 &fib6_entry->common.list);
4509 } else {
4510 struct mlxsw_sp_fib6_entry *last;
4511
4512 list_for_each_entry(last, &fib_node->entry_list, common.list) {
4513 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(last);
4514
4515 if (nrt->rt6i_table->tb6_id > rt->rt6i_table->tb6_id)
4516 break;
4517 fib6_entry = last;
4518 }
4519
4520 if (fib6_entry)
4521 list_add(&new6_entry->common.list,
4522 &fib6_entry->common.list);
4523 else
4524 list_add(&new6_entry->common.list,
4525 &fib_node->entry_list);
4526 }
4527
4528 return 0;
4529}
4530
4531static void
4532mlxsw_sp_fib6_node_list_remove(struct mlxsw_sp_fib6_entry *fib6_entry)
4533{
4534 list_del(&fib6_entry->common.list);
4535}
4536
4537static int mlxsw_sp_fib6_node_entry_link(struct mlxsw_sp *mlxsw_sp,
0a7fd1ac
IS		 4538 struct mlxsw_sp_fib6_entry *fib6_entry,
4539 bool replace)
428b851f
IS		 4540{
4541 int err;
4542
0a7fd1ac 4543 err = mlxsw_sp_fib6_node_list_insert(fib6_entry, replace);
428b851f
IS		 4544 if (err)
4545 return err;
4546
4547 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
4548 if (err)
4549 goto err_fib_node_entry_add;
4550
4551 return 0;
4552
4553err_fib_node_entry_add:
4554 mlxsw_sp_fib6_node_list_remove(fib6_entry);
4555 return err;
4556}
4557
4558static void
4559mlxsw_sp_fib6_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4560 struct mlxsw_sp_fib6_entry *fib6_entry)
4561{
4562 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib6_entry->common);
4563 mlxsw_sp_fib6_node_list_remove(fib6_entry);
4564}
4565
4566static struct mlxsw_sp_fib6_entry *
4567mlxsw_sp_fib6_entry_lookup(struct mlxsw_sp *mlxsw_sp,
4568 const struct rt6_info *rt)
4569{
4570 struct mlxsw_sp_fib6_entry *fib6_entry;
4571 struct mlxsw_sp_fib_node *fib_node;
4572 struct mlxsw_sp_fib *fib;
4573 struct mlxsw_sp_vr *vr;
4574
4575 vr = mlxsw_sp_vr_find(mlxsw_sp, rt->rt6i_table->tb6_id);
4576 if (!vr)
4577 return NULL;
4578 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV6);
4579
4580 fib_node = mlxsw_sp_fib_node_lookup(fib, &rt->rt6i_dst.addr,
4581 sizeof(rt->rt6i_dst.addr),
4582 rt->rt6i_dst.plen);
4583 if (!fib_node)
4584 return NULL;
4585
4586 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4587 struct rt6_info *iter_rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4588
4589 if (rt->rt6i_table->tb6_id == iter_rt->rt6i_table->tb6_id &&
4590 rt->rt6i_metric == iter_rt->rt6i_metric &&
4591 mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt))
4592 return fib6_entry;
4593 }
4594
4595 return NULL;
4596}
4597
0a7fd1ac
IS		 4598static void mlxsw_sp_fib6_entry_replace(struct mlxsw_sp *mlxsw_sp,
4599 struct mlxsw_sp_fib6_entry *fib6_entry,
4600 bool replace)
4601{
4602 struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
4603 struct mlxsw_sp_fib6_entry *replaced;
4604
4605 if (!replace)
4606 return;
4607
4608 replaced = list_next_entry(fib6_entry, common.list);
4609
4610 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, replaced);
4611 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, replaced);
4612 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4613}
4614
428b851f 4615static int mlxsw_sp_router_fib6_add(struct mlxsw_sp *mlxsw_sp,
0a7fd1ac 4616 struct rt6_info *rt, bool replace)
428b851f
IS		 4617{
4618 struct mlxsw_sp_fib6_entry *fib6_entry;
4619 struct mlxsw_sp_fib_node *fib_node;
4620 int err;
4621
4622 if (mlxsw_sp->router->aborted)
4623 return 0;
4624
f36f5ac6
IS		 4625 if (rt->rt6i_src.plen)
4626 return -EINVAL;
4627
428b851f
IS		 4628 if (mlxsw_sp_fib6_rt_should_ignore(rt))
4629 return 0;
4630
4631 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->rt6i_table->tb6_id,
4632 &rt->rt6i_dst.addr,
4633 sizeof(rt->rt6i_dst.addr),
4634 rt->rt6i_dst.plen,
4635 MLXSW_SP_L3_PROTO_IPV6);
4636 if (IS_ERR(fib_node))
4637 return PTR_ERR(fib_node);
4638
4639 /* Before creating a new entry, try to append route to an existing
4640 * multipath entry.
4641 */
0a7fd1ac 4642 fib6_entry = mlxsw_sp_fib6_node_mp_entry_find(fib_node, rt, replace);
428b851f
IS		 4643 if (fib6_entry) {
4644 err = mlxsw_sp_fib6_entry_nexthop_add(mlxsw_sp, fib6_entry, rt);
4645 if (err)
4646 goto err_fib6_entry_nexthop_add;
4647 return 0;
4648 }
4649
4650 fib6_entry = mlxsw_sp_fib6_entry_create(mlxsw_sp, fib_node, rt);
4651 if (IS_ERR(fib6_entry)) {
4652 err = PTR_ERR(fib6_entry);
4653 goto err_fib6_entry_create;
4654 }
4655
0a7fd1ac 4656 err = mlxsw_sp_fib6_node_entry_link(mlxsw_sp, fib6_entry, replace);
428b851f
IS		 4657 if (err)
4658 goto err_fib6_node_entry_link;
4659
0a7fd1ac
IS		 4660 mlxsw_sp_fib6_entry_replace(mlxsw_sp, fib6_entry, replace);
4661
428b851f
IS		 4662 return 0;
4663
4664err_fib6_node_entry_link:
4665 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4666err_fib6_entry_create:
4667err_fib6_entry_nexthop_add:
4668 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4669 return err;
4670}
4671
4672static void mlxsw_sp_router_fib6_del(struct mlxsw_sp *mlxsw_sp,
4673 struct rt6_info *rt)
4674{
4675 struct mlxsw_sp_fib6_entry *fib6_entry;
4676 struct mlxsw_sp_fib_node *fib_node;
4677
4678 if (mlxsw_sp->router->aborted)
4679 return;
4680
4681 if (mlxsw_sp_fib6_rt_should_ignore(rt))
4682 return;
4683
4684 fib6_entry = mlxsw_sp_fib6_entry_lookup(mlxsw_sp, rt);
4685 if (WARN_ON(!fib6_entry))
4686 return;
4687
4688 /* If route is part of a multipath entry, but not the last one
4689 * removed, then only reduce its nexthop group.
4690 */
4691 if (!list_is_singular(&fib6_entry->rt6_list)) {
4692 mlxsw_sp_fib6_entry_nexthop_del(mlxsw_sp, fib6_entry, rt);
4693 return;
4694 }
4695
4696 fib_node = fib6_entry->common.fib_node;
4697
4698 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
4699 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4700 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4701}
4702
bc65a8a4
IS		 4703static int __mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp,
4704 enum mlxsw_reg_ralxx_protocol proto,
4705 u8 tree_id)
b45f64d1
JP		 4706{
4707 char ralta_pl[MLXSW_REG_RALTA_LEN];
4708 char ralst_pl[MLXSW_REG_RALST_LEN];
b5d90e6d 4709 int i, err;
b45f64d1 4710
bc65a8a4 4711 mlxsw_reg_ralta_pack(ralta_pl, true, proto, tree_id);
b45f64d1
JP		 4712 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
4713 if (err)
4714 return err;
4715
bc65a8a4 4716 mlxsw_reg_ralst_pack(ralst_pl, 0xff, tree_id);
b45f64d1
JP		 4717 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
4718 if (err)
4719 return err;
4720
b5d90e6d 4721 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 4722 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
b5d90e6d
IS		 4723 char raltb_pl[MLXSW_REG_RALTB_LEN];
4724 char ralue_pl[MLXSW_REG_RALUE_LEN];
b45f64d1 4725
bc65a8a4 4726 mlxsw_reg_raltb_pack(raltb_pl, vr->id, proto, tree_id);
b5d90e6d
IS		 4727 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb),
4728 raltb_pl);
4729 if (err)
4730 return err;
4731
bc65a8a4
IS		 4732 mlxsw_reg_ralue_pack(ralue_pl, proto,
4733 MLXSW_REG_RALUE_OP_WRITE_WRITE, vr->id, 0);
b5d90e6d
IS		 4734 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
4735 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue),
4736 ralue_pl);
4737 if (err)
4738 return err;
4739 }
4740
4741 return 0;
b45f64d1
JP		 4742}
4743
d42b0965
YG		 4744static int mlxsw_sp_router_fibmr_add(struct mlxsw_sp *mlxsw_sp,
4745 struct mfc_entry_notifier_info *men_info,
4746 bool replace)
4747{
4748 struct mlxsw_sp_vr *vr;
4749
4750 if (mlxsw_sp->router->aborted)
4751 return 0;
4752
4753 vr = mlxsw_sp_vr_get(mlxsw_sp, men_info->tb_id);
4754 if (IS_ERR(vr))
4755 return PTR_ERR(vr);
4756
4757 return mlxsw_sp_mr_route4_add(vr->mr4_table, men_info->mfc, replace);
4758}
4759
4760static void mlxsw_sp_router_fibmr_del(struct mlxsw_sp *mlxsw_sp,
4761 struct mfc_entry_notifier_info *men_info)
4762{
4763 struct mlxsw_sp_vr *vr;
4764
4765 if (mlxsw_sp->router->aborted)
4766 return;
4767
4768 vr = mlxsw_sp_vr_find(mlxsw_sp, men_info->tb_id);
4769 if (WARN_ON(!vr))
4770 return;
4771
4772 mlxsw_sp_mr_route4_del(vr->mr4_table, men_info->mfc);
4773 mlxsw_sp_vr_put(vr);
4774}
4775
4776static int
4777mlxsw_sp_router_fibmr_vif_add(struct mlxsw_sp *mlxsw_sp,
4778 struct vif_entry_notifier_info *ven_info)
4779{
4780 struct mlxsw_sp_rif *rif;
4781 struct mlxsw_sp_vr *vr;
4782
4783 if (mlxsw_sp->router->aborted)
4784 return 0;
4785
4786 vr = mlxsw_sp_vr_get(mlxsw_sp, ven_info->tb_id);
4787 if (IS_ERR(vr))
4788 return PTR_ERR(vr);
4789
4790 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, ven_info->dev);
4791 return mlxsw_sp_mr_vif_add(vr->mr4_table, ven_info->dev,
4792 ven_info->vif_index,
4793 ven_info->vif_flags, rif);
4794}
4795
4796static void
4797mlxsw_sp_router_fibmr_vif_del(struct mlxsw_sp *mlxsw_sp,
4798 struct vif_entry_notifier_info *ven_info)
4799{
4800 struct mlxsw_sp_vr *vr;
4801
4802 if (mlxsw_sp->router->aborted)
4803 return;
4804
4805 vr = mlxsw_sp_vr_find(mlxsw_sp, ven_info->tb_id);
4806 if (WARN_ON(!vr))
4807 return;
4808
4809 mlxsw_sp_mr_vif_del(vr->mr4_table, ven_info->vif_index);
4810 mlxsw_sp_vr_put(vr);
4811}
4812
bc65a8a4
IS		 4813static int mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp)
4814{
4815 enum mlxsw_reg_ralxx_protocol proto = MLXSW_REG_RALXX_PROTOCOL_IPV4;
4816 int err;
4817
4818 err = __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
4819 MLXSW_SP_LPM_TREE_MIN);
4820 if (err)
4821 return err;
4822
d42b0965
YG		 4823 /* The multicast router code does not need an abort trap as by default,
4824 * packets that don't match any routes are trapped to the CPU.
4825 */
4826
bc65a8a4
IS		 4827 proto = MLXSW_REG_RALXX_PROTOCOL_IPV6;
4828 return __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
4829 MLXSW_SP_LPM_TREE_MIN + 1);
4830}
4831
9aecce1c
IS		 4832static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
4833 struct mlxsw_sp_fib_node *fib_node)
4834{
4f1c7f1f 4835 struct mlxsw_sp_fib4_entry *fib4_entry, *tmp;
9aecce1c 4836
4f1c7f1f
IS		 4837 list_for_each_entry_safe(fib4_entry, tmp, &fib_node->entry_list,
4838 common.list) {
4839 bool do_break = &tmp->common.list == &fib_node->entry_list;
9aecce1c 4840
4f1c7f1f
IS		 4841 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
4842 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
731ea1ca 4843 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
9aecce1c
IS		 4844 /* Break when entry list is empty and node was freed.
4845 * Otherwise, we'll access freed memory in the next
4846 * iteration.
4847 */
4848 if (do_break)
4849 break;
4850 }
4851}
4852
428b851f
IS		 4853static void mlxsw_sp_fib6_node_flush(struct mlxsw_sp *mlxsw_sp,
4854 struct mlxsw_sp_fib_node *fib_node)
4855{
4856 struct mlxsw_sp_fib6_entry *fib6_entry, *tmp;
4857
4858 list_for_each_entry_safe(fib6_entry, tmp, &fib_node->entry_list,
4859 common.list) {
4860 bool do_break = &tmp->common.list == &fib_node->entry_list;
4861
4862 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
4863 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4864 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4865 if (do_break)
4866 break;
4867 }
4868}
4869
9aecce1c
IS		 4870static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
4871 struct mlxsw_sp_fib_node *fib_node)
4872{
76610ebb 4873 switch (fib_node->fib->proto) {
9aecce1c
IS		 4874 case MLXSW_SP_L3_PROTO_IPV4:
4875 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
4876 break;
4877 case MLXSW_SP_L3_PROTO_IPV6:
428b851f 4878 mlxsw_sp_fib6_node_flush(mlxsw_sp, fib_node);
9aecce1c
IS		 4879 break;
4880 }
4881}
4882
76610ebb
IS		 4883static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
4884 struct mlxsw_sp_vr *vr,
4885 enum mlxsw_sp_l3proto proto)
b45f64d1 4886{
76610ebb 4887 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
9aecce1c 4888 struct mlxsw_sp_fib_node *fib_node, *tmp;
76610ebb
IS		 4889
4890 list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
4891 bool do_break = &tmp->list == &fib->node_list;
4892
4893 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
4894 if (do_break)
4895 break;
4896 }
4897}
4898
4899static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
4900{
b45f64d1 4901 int i;
b45f64d1 4902
c1a38311 4903 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 4904 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
ac571de9 4905
76610ebb 4906 if (!mlxsw_sp_vr_is_used(vr))
b45f64d1 4907 continue;
d42b0965
YG		 4908
4909 mlxsw_sp_mr_table_flush(vr->mr4_table);
76610ebb 4910 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
a3d9bc50
IS		 4911
4912 /* If virtual router was only used for IPv4, then it's no
4913 * longer used.
4914 */
4915 if (!mlxsw_sp_vr_is_used(vr))
4916 continue;
4917 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
b45f64d1 4918 }
ac571de9
IS		 4919}
4920
bc65a8a4 4921static void mlxsw_sp_router_fib_abort(struct mlxsw_sp *mlxsw_sp)
ac571de9
IS		 4922{
4923 int err;
4924
9011b677 4925 if (mlxsw_sp->router->aborted)
d331d303
IS		 4926 return;
4927 dev_warn(mlxsw_sp->bus_info->dev, "FIB abort triggered. Note that FIB entries are no longer being offloaded to this device.\n");
ac571de9 4928 mlxsw_sp_router_fib_flush(mlxsw_sp);
9011b677 4929 mlxsw_sp->router->aborted = true;
b45f64d1
JP		 4930 err = mlxsw_sp_router_set_abort_trap(mlxsw_sp);
4931 if (err)
4932 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set abort trap.\n");
4933}
4934
3057224e 4935struct mlxsw_sp_fib_event_work {
a0e4761d 4936 struct work_struct work;
ad178c8e 4937 union {
428b851f 4938 struct fib6_entry_notifier_info fen6_info;
ad178c8e 4939 struct fib_entry_notifier_info fen_info;
5d7bfd14 4940 struct fib_rule_notifier_info fr_info;
ad178c8e 4941 struct fib_nh_notifier_info fnh_info;
d42b0965
YG		 4942 struct mfc_entry_notifier_info men_info;
4943 struct vif_entry_notifier_info ven_info;
ad178c8e 4944 };
3057224e
IS		 4945 struct mlxsw_sp *mlxsw_sp;
4946 unsigned long event;
4947};
4948
66a5763a 4949static void mlxsw_sp_router_fib4_event_work(struct work_struct *work)
b45f64d1 4950{
3057224e 4951 struct mlxsw_sp_fib_event_work *fib_work =
a0e4761d 4952 container_of(work, struct mlxsw_sp_fib_event_work, work);
3057224e 4953 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
5d7bfd14 4954 struct fib_rule *rule;
599cf8f9 4955 bool replace, append;
b45f64d1
JP		 4956 int err;
4957
3057224e
IS		 4958 /* Protect internal structures from changes */
4959 rtnl_lock();
4960 switch (fib_work->event) {
599cf8f9 4961 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4283bce5 4962 case FIB_EVENT_ENTRY_APPEND: /* fall through */
b45f64d1 4963 case FIB_EVENT_ENTRY_ADD:
599cf8f9 4964 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
4283bce5
IS		 4965 append = fib_work->event == FIB_EVENT_ENTRY_APPEND;
4966 err = mlxsw_sp_router_fib4_add(mlxsw_sp, &fib_work->fen_info,
599cf8f9 4967 replace, append);
b45f64d1 4968 if (err)
bc65a8a4 4969 mlxsw_sp_router_fib_abort(mlxsw_sp);
3057224e 4970 fib_info_put(fib_work->fen_info.fi);
b45f64d1
JP		 4971 break;
4972 case FIB_EVENT_ENTRY_DEL:
3057224e
IS		 4973 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
4974 fib_info_put(fib_work->fen_info.fi);
b45f64d1
JP		 4975 break;
4976 case FIB_EVENT_RULE_ADD: /* fall through */
4977 case FIB_EVENT_RULE_DEL:
5d7bfd14 4978 rule = fib_work->fr_info.rule;
c7f6e665 4979 if (!fib4_rule_default(rule) && !rule->l3mdev)
bc65a8a4 4980 mlxsw_sp_router_fib_abort(mlxsw_sp);
5d7bfd14 4981 fib_rule_put(rule);
b45f64d1 4982 break;
ad178c8e
IS		 4983 case FIB_EVENT_NH_ADD: /* fall through */
4984 case FIB_EVENT_NH_DEL:
0e6ea2a4
IS		 4985 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
4986 fib_work->fnh_info.fib_nh);
ad178c8e
IS		 4987 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
4988 break;
b45f64d1 4989 }
3057224e
IS		 4990 rtnl_unlock();
4991 kfree(fib_work);
4992}
4993
66a5763a
IS		 4994static void mlxsw_sp_router_fib6_event_work(struct work_struct *work)
4995{
583419fd
IS		 4996 struct mlxsw_sp_fib_event_work *fib_work =
4997 container_of(work, struct mlxsw_sp_fib_event_work, work);
4998 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
4999 struct fib_rule *rule;
0a7fd1ac 5000 bool replace;
428b851f 5001 int err;
583419fd
IS		 5002
5003 rtnl_lock();
5004 switch (fib_work->event) {
0a7fd1ac 5005 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
428b851f 5006 case FIB_EVENT_ENTRY_ADD:
0a7fd1ac 5007 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
428b851f 5008 err = mlxsw_sp_router_fib6_add(mlxsw_sp,
0a7fd1ac 5009 fib_work->fen6_info.rt, replace);
428b851f
IS		 5010 if (err)
5011 mlxsw_sp_router_fib_abort(mlxsw_sp);
5012 mlxsw_sp_rt6_release(fib_work->fen6_info.rt);
5013 break;
5014 case FIB_EVENT_ENTRY_DEL:
5015 mlxsw_sp_router_fib6_del(mlxsw_sp, fib_work->fen6_info.rt);
5016 mlxsw_sp_rt6_release(fib_work->fen6_info.rt);
5017 break;
583419fd
IS		 5018 case FIB_EVENT_RULE_ADD: /* fall through */
5019 case FIB_EVENT_RULE_DEL:
5020 rule = fib_work->fr_info.rule;
5021 if (!fib6_rule_default(rule) && !rule->l3mdev)
5022 mlxsw_sp_router_fib_abort(mlxsw_sp);
5023 fib_rule_put(rule);
5024 break;
5025 }
5026 rtnl_unlock();
5027 kfree(fib_work);
66a5763a
IS		 5028}
5029
d42b0965
YG		 5030static void mlxsw_sp_router_fibmr_event_work(struct work_struct *work)
5031{
5032 struct mlxsw_sp_fib_event_work *fib_work =
5033 container_of(work, struct mlxsw_sp_fib_event_work, work);
5034 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
5035 struct fib_rule *rule;
5036 bool replace;
5037 int err;
5038
5039 rtnl_lock();
5040 switch (fib_work->event) {
5041 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
5042 case FIB_EVENT_ENTRY_ADD:
5043 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
5044
5045 err = mlxsw_sp_router_fibmr_add(mlxsw_sp, &fib_work->men_info,
5046 replace);
5047 if (err)
5048 mlxsw_sp_router_fib_abort(mlxsw_sp);
5049 ipmr_cache_put(fib_work->men_info.mfc);
5050 break;
5051 case FIB_EVENT_ENTRY_DEL:
5052 mlxsw_sp_router_fibmr_del(mlxsw_sp, &fib_work->men_info);
5053 ipmr_cache_put(fib_work->men_info.mfc);
5054 break;
5055 case FIB_EVENT_VIF_ADD:
5056 err = mlxsw_sp_router_fibmr_vif_add(mlxsw_sp,
5057 &fib_work->ven_info);
5058 if (err)
5059 mlxsw_sp_router_fib_abort(mlxsw_sp);
5060 dev_put(fib_work->ven_info.dev);
5061 break;
5062 case FIB_EVENT_VIF_DEL:
5063 mlxsw_sp_router_fibmr_vif_del(mlxsw_sp,
5064 &fib_work->ven_info);
5065 dev_put(fib_work->ven_info.dev);
5066 break;
5067 case FIB_EVENT_RULE_ADD: /* fall through */
5068 case FIB_EVENT_RULE_DEL:
5069 rule = fib_work->fr_info.rule;
5070 if (!ipmr_rule_default(rule) && !rule->l3mdev)
5071 mlxsw_sp_router_fib_abort(mlxsw_sp);
5072 fib_rule_put(rule);
5073 break;
5074 }
5075 rtnl_unlock();
5076 kfree(fib_work);
5077}
5078
66a5763a
IS		 5079static void mlxsw_sp_router_fib4_event(struct mlxsw_sp_fib_event_work *fib_work,
5080 struct fib_notifier_info *info)
5081{
5082 switch (fib_work->event) {
5083 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
5084 case FIB_EVENT_ENTRY_APPEND: /* fall through */
5085 case FIB_EVENT_ENTRY_ADD: /* fall through */
5086 case FIB_EVENT_ENTRY_DEL:
5087 memcpy(&fib_work->fen_info, info, sizeof(fib_work->fen_info));
5088 /* Take referece on fib_info to prevent it from being
5089 * freed while work is queued. Release it afterwards.
5090 */
5091 fib_info_hold(fib_work->fen_info.fi);
5092 break;
5093 case FIB_EVENT_RULE_ADD: /* fall through */
5094 case FIB_EVENT_RULE_DEL:
5095 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
5096 fib_rule_get(fib_work->fr_info.rule);
5097 break;
5098 case FIB_EVENT_NH_ADD: /* fall through */
5099 case FIB_EVENT_NH_DEL:
5100 memcpy(&fib_work->fnh_info, info, sizeof(fib_work->fnh_info));
5101 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
5102 break;
5103 }
5104}
5105
5106static void mlxsw_sp_router_fib6_event(struct mlxsw_sp_fib_event_work *fib_work,
5107 struct fib_notifier_info *info)
5108{
583419fd 5109 switch (fib_work->event) {
0a7fd1ac 5110 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
428b851f
IS		 5111 case FIB_EVENT_ENTRY_ADD: /* fall through */
5112 case FIB_EVENT_ENTRY_DEL:
5113 memcpy(&fib_work->fen6_info, info, sizeof(fib_work->fen6_info));
5114 rt6_hold(fib_work->fen6_info.rt);
5115 break;
583419fd
IS		 5116 case FIB_EVENT_RULE_ADD: /* fall through */
5117 case FIB_EVENT_RULE_DEL:
5118 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
5119 fib_rule_get(fib_work->fr_info.rule);
5120 break;
5121 }
66a5763a
IS		 5122}
5123
d42b0965
YG		 5124static void
5125mlxsw_sp_router_fibmr_event(struct mlxsw_sp_fib_event_work *fib_work,
5126 struct fib_notifier_info *info)
5127{
5128 switch (fib_work->event) {
5129 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
5130 case FIB_EVENT_ENTRY_ADD: /* fall through */
5131 case FIB_EVENT_ENTRY_DEL:
5132 memcpy(&fib_work->men_info, info, sizeof(fib_work->men_info));
5133 ipmr_cache_hold(fib_work->men_info.mfc);
5134 break;
5135 case FIB_EVENT_VIF_ADD: /* fall through */
5136 case FIB_EVENT_VIF_DEL:
5137 memcpy(&fib_work->ven_info, info, sizeof(fib_work->ven_info));
5138 dev_hold(fib_work->ven_info.dev);
5139 break;
5140 case FIB_EVENT_RULE_ADD: /* fall through */
5141 case FIB_EVENT_RULE_DEL:
5142 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
5143 fib_rule_get(fib_work->fr_info.rule);
5144 break;
5145 }
5146}
5147
3057224e
IS		 5148/* Called with rcu_read_lock() */
5149static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
5150 unsigned long event, void *ptr)
5151{
3057224e
IS		 5152 struct mlxsw_sp_fib_event_work *fib_work;
5153 struct fib_notifier_info *info = ptr;
7e39d115 5154 struct mlxsw_sp_router *router;
3057224e 5155
8e29f979 5156 if (!net_eq(info->net, &init_net) ||
664375e9
YG		 5157 (info->family != AF_INET && info->family != AF_INET6 &&
5158 info->family != RTNL_FAMILY_IPMR))
3057224e
IS		 5159 return NOTIFY_DONE;
5160
5161 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
5162 if (WARN_ON(!fib_work))
5163 return NOTIFY_BAD;
5164
7e39d115
IS		 5165 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
5166 fib_work->mlxsw_sp = router->mlxsw_sp;
3057224e
IS		 5167 fib_work->event = event;
5168
66a5763a
IS		 5169 switch (info->family) {
5170 case AF_INET:
5171 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib4_event_work);
5172 mlxsw_sp_router_fib4_event(fib_work, info);
3057224e 5173 break;
66a5763a
IS		 5174 case AF_INET6:
5175 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib6_event_work);
5176 mlxsw_sp_router_fib6_event(fib_work, info);
ad178c8e 5177 break;
d42b0965
YG		 5178 case RTNL_FAMILY_IPMR:
5179 INIT_WORK(&fib_work->work, mlxsw_sp_router_fibmr_event_work);
5180 mlxsw_sp_router_fibmr_event(fib_work, info);
5181 break;
3057224e
IS		 5182 }
5183
a0e4761d 5184 mlxsw_core_schedule_work(&fib_work->work);
3057224e 5185
b45f64d1
JP		 5186 return NOTIFY_DONE;
5187}
5188
4724ba56
IS		 5189static struct mlxsw_sp_rif *
5190mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
5191 const struct net_device *dev)
5192{
5193 int i;
5194
5195 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
5f9efffb
IS		 5196 if (mlxsw_sp->router->rifs[i] &&
5197 mlxsw_sp->router->rifs[i]->dev == dev)
5198 return mlxsw_sp->router->rifs[i];
4724ba56
IS		 5199
5200 return NULL;
5201}
5202
5203static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
5204{
5205 char ritr_pl[MLXSW_REG_RITR_LEN];
5206 int err;
5207
5208 mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
5209 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5210 if (WARN_ON_ONCE(err))
5211 return err;
5212
5213 mlxsw_reg_ritr_enable_set(ritr_pl, false);
5214 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5215}
5216
5217static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 5218 struct mlxsw_sp_rif *rif)
4724ba56 5219{
bf95233e
AS		 5220 mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
5221 mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
5222 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
4724ba56
IS		 5223}
5224
5ea1237f
AS		 5225static bool
5226mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
5227 unsigned long event)
4724ba56 5228{
5ea1237f
AS		 5229 struct inet6_dev *inet6_dev;
5230 bool addr_list_empty = true;
5231 struct in_device *idev;
5232
4724ba56
IS		 5233 switch (event) {
5234 case NETDEV_UP:
f1b1f273 5235 return rif == NULL;
4724ba56 5236 case NETDEV_DOWN:
5ea1237f
AS		 5237 idev = __in_dev_get_rtnl(dev);
5238 if (idev && idev->ifa_list)
5239 addr_list_empty = false;
5240
5241 inet6_dev = __in6_dev_get(dev);
5242 if (addr_list_empty && inet6_dev &&
5243 !list_empty(&inet6_dev->addr_list))
5244 addr_list_empty = false;
5245
5246 if (rif && addr_list_empty &&
bf95233e 5247 !netif_is_l3_slave(rif->dev))
4724ba56
IS		 5248 return true;
5249 /* It is possible we already removed the RIF ourselves
5250 * if it was assigned to a netdev that is now a bridge
5251 * or LAG slave.
5252 */
5253 return false;
5254 }
5255
5256 return false;
5257}
5258
e4f3c1c1
IS		 5259static enum mlxsw_sp_rif_type
5260mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
5261 const struct net_device *dev)
5262{
5263 enum mlxsw_sp_fid_type type;
5264
6ddb7426
PM		 5265 if (mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL))
5266 return MLXSW_SP_RIF_TYPE_IPIP_LB;
5267
5268 /* Otherwise RIF type is derived from the type of the underlying FID. */
e4f3c1c1
IS		 5269 if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
5270 type = MLXSW_SP_FID_TYPE_8021Q;
5271 else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
5272 type = MLXSW_SP_FID_TYPE_8021Q;
5273 else if (netif_is_bridge_master(dev))
5274 type = MLXSW_SP_FID_TYPE_8021D;
5275 else
5276 type = MLXSW_SP_FID_TYPE_RFID;
5277
5278 return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
5279}
5280
de5ed99e 5281static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index)
4724ba56
IS		 5282{
5283 int i;
5284
de5ed99e
IS		 5285 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
5286 if (!mlxsw_sp->router->rifs[i]) {
5287 *p_rif_index = i;
5288 return 0;
5289 }
5290 }
4724ba56 5291
de5ed99e 5292 return -ENOBUFS;
4724ba56
IS		 5293}
5294
e4f3c1c1
IS		 5295static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
5296 u16 vr_id,
5297 struct net_device *l3_dev)
4724ba56 5298{
bf95233e 5299 struct mlxsw_sp_rif *rif;
4724ba56 5300
e4f3c1c1 5301 rif = kzalloc(rif_size, GFP_KERNEL);
bf95233e 5302 if (!rif)
4724ba56
IS		 5303 return NULL;
5304
bf95233e
AS		 5305 INIT_LIST_HEAD(&rif->nexthop_list);
5306 INIT_LIST_HEAD(&rif->neigh_list);
5307 ether_addr_copy(rif->addr, l3_dev->dev_addr);
5308 rif->mtu = l3_dev->mtu;
5309 rif->vr_id = vr_id;
5310 rif->dev = l3_dev;
5311 rif->rif_index = rif_index;
4724ba56 5312
bf95233e 5313 return rif;
4724ba56
IS		 5314}
5315
5f9efffb
IS		 5316struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
5317 u16 rif_index)
5318{
5319 return mlxsw_sp->router->rifs[rif_index];
5320}
5321
fd1b9d41
AS		 5322u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
5323{
5324 return rif->rif_index;
5325}
5326
92107cfb
PM		 5327u16 mlxsw_sp_ipip_lb_rif_index(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
5328{
5329 return lb_rif->common.rif_index;
5330}
5331
5332u16 mlxsw_sp_ipip_lb_ul_vr_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
5333{
5334 return lb_rif->ul_vr_id;
5335}
5336
fd1b9d41
AS		 5337int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
5338{
5339 return rif->dev->ifindex;
5340}
5341
91e4d59a
YG		 5342const struct net_device *mlxsw_sp_rif_dev(const struct mlxsw_sp_rif *rif)
5343{
5344 return rif->dev;
5345}
5346
4724ba56 5347static struct mlxsw_sp_rif *
e4f3c1c1
IS		 5348mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
5349 const struct mlxsw_sp_rif_params *params)
4724ba56 5350{
e4f3c1c1
IS		 5351 u32 tb_id = l3mdev_fib_table(params->dev);
5352 const struct mlxsw_sp_rif_ops *ops;
010cadf9 5353 struct mlxsw_sp_fid *fid = NULL;
e4f3c1c1 5354 enum mlxsw_sp_rif_type type;
bf95233e 5355 struct mlxsw_sp_rif *rif;
a1107487
IS		 5356 struct mlxsw_sp_vr *vr;
5357 u16 rif_index;
4724ba56
IS		 5358 int err;
5359
e4f3c1c1
IS		 5360 type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
5361 ops = mlxsw_sp->router->rif_ops_arr[type];
5362
c9ec53f0
IS		 5363 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN);
5364 if (IS_ERR(vr))
5365 return ERR_CAST(vr);
28a04c7b 5366 vr->rif_count++;
c9ec53f0 5367
de5ed99e
IS		 5368 err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index);
5369 if (err)
5370 goto err_rif_index_alloc;
4724ba56 5371
e4f3c1c1 5372 rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, params->dev);
a13a594d
IS		 5373 if (!rif) {
5374 err = -ENOMEM;
5375 goto err_rif_alloc;
5376 }
e4f3c1c1
IS		 5377 rif->mlxsw_sp = mlxsw_sp;
5378 rif->ops = ops;
a13a594d 5379
010cadf9
PM		 5380 if (ops->fid_get) {
5381 fid = ops->fid_get(rif);
5382 if (IS_ERR(fid)) {
5383 err = PTR_ERR(fid);
5384 goto err_fid_get;
5385 }
5386 rif->fid = fid;
4d93ceeb
IS		 5387 }
5388
e4f3c1c1
IS		 5389 if (ops->setup)
5390 ops->setup(rif, params);
5391
5392 err = ops->configure(rif);
4724ba56 5393 if (err)
e4f3c1c1 5394 goto err_configure;
4724ba56 5395
d42b0965
YG		 5396 err = mlxsw_sp_mr_rif_add(vr->mr4_table, rif);
5397 if (err)
5398 goto err_mr_rif_add;
5399
e4f3c1c1 5400 mlxsw_sp_rif_counters_alloc(rif);
5f9efffb 5401 mlxsw_sp->router->rifs[rif_index] = rif;
4724ba56 5402
bf95233e 5403 return rif;
4724ba56 5404
d42b0965
YG		 5405err_mr_rif_add:
5406 ops->deconfigure(rif);
e4f3c1c1 5407err_configure:
010cadf9
PM		 5408 if (fid)
5409 mlxsw_sp_fid_put(fid);
a1107487 5410err_fid_get:
e4f3c1c1
IS		 5411 kfree(rif);
5412err_rif_alloc:
de5ed99e 5413err_rif_index_alloc:
28a04c7b 5414 vr->rif_count--;
c9ec53f0 5415 mlxsw_sp_vr_put(vr);
4724ba56
IS		 5416 return ERR_PTR(err);
5417}
5418
e4f3c1c1 5419void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
4724ba56 5420{
e4f3c1c1
IS		 5421 const struct mlxsw_sp_rif_ops *ops = rif->ops;
5422 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
a1107487 5423 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 5424 struct mlxsw_sp_vr *vr;
4724ba56 5425
bf95233e 5426 mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
e4f3c1c1 5427 vr = &mlxsw_sp->router->vrs[rif->vr_id];
e0c0afd8 5428
e4f3c1c1 5429 mlxsw_sp->router->rifs[rif->rif_index] = NULL;
e4f3c1c1 5430 mlxsw_sp_rif_counters_free(rif);
d42b0965 5431 mlxsw_sp_mr_rif_del(vr->mr4_table, rif);
e4f3c1c1 5432 ops->deconfigure(rif);
010cadf9
PM		 5433 if (fid)
5434 /* Loopback RIFs are not associated with a FID. */
5435 mlxsw_sp_fid_put(fid);
e4f3c1c1 5436 kfree(rif);
28a04c7b 5437 vr->rif_count--;
c9ec53f0 5438 mlxsw_sp_vr_put(vr);
4724ba56
IS		 5439}
5440
e4f3c1c1
IS		 5441static void
5442mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
5443 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
5444{
5445 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
5446
5447 params->vid = mlxsw_sp_port_vlan->vid;
5448 params->lag = mlxsw_sp_port->lagged;
5449 if (params->lag)
5450 params->lag_id = mlxsw_sp_port->lag_id;
5451 else
5452 params->system_port = mlxsw_sp_port->local_port;
5453}
5454
7cbecf24 5455static int
a1107487 5456mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
7cbecf24 5457 struct net_device *l3_dev)
4724ba56 5458{
7cbecf24 5459 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1b8f09a0 5460 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
7cbecf24 5461 u16 vid = mlxsw_sp_port_vlan->vid;
bf95233e 5462 struct mlxsw_sp_rif *rif;
a1107487 5463 struct mlxsw_sp_fid *fid;
03ea01e9 5464 int err;
4724ba56 5465
1b8f09a0 5466 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
bf95233e 5467 if (!rif) {
e4f3c1c1
IS		 5468 struct mlxsw_sp_rif_params params = {
5469 .dev = l3_dev,
5470 };
5471
5472 mlxsw_sp_rif_subport_params_init(&params, mlxsw_sp_port_vlan);
5473 rif = mlxsw_sp_rif_create(mlxsw_sp, &params);
bf95233e
AS		 5474 if (IS_ERR(rif))
5475 return PTR_ERR(rif);
4724ba56
IS		 5476 }
5477
a1107487 5478 /* FID was already created, just take a reference */
e4f3c1c1 5479 fid = rif->ops->fid_get(rif);
a1107487
IS		 5480 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
5481 if (err)
5482 goto err_fid_port_vid_map;
5483
7cbecf24 5484 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
03ea01e9
IS		 5485 if (err)
5486 goto err_port_vid_learning_set;
5487
7cbecf24 5488 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
03ea01e9
IS		 5489 BR_STATE_FORWARDING);
5490 if (err)
5491 goto err_port_vid_stp_set;
5492
a1107487 5493 mlxsw_sp_port_vlan->fid = fid;
4724ba56 5494
4724ba56 5495 return 0;
03ea01e9
IS		 5496
5497err_port_vid_stp_set:
7cbecf24 5498 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
03ea01e9 5499err_port_vid_learning_set:
a1107487
IS		 5500 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
5501err_fid_port_vid_map:
5502 mlxsw_sp_fid_put(fid);
03ea01e9 5503 return err;
4724ba56
IS		 5504}
5505
a1107487
IS		 5506void
5507mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
4724ba56 5508{
ce95e154 5509 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
7cbecf24 5510 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
ce95e154 5511 u16 vid = mlxsw_sp_port_vlan->vid;
ce95e154 5512
a1107487
IS		 5513 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
5514 return;
4aafc368 5515
a1107487 5516 mlxsw_sp_port_vlan->fid = NULL;
7cbecf24
IS		 5517 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
5518 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
a1107487
IS		 5519 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
5520 /* If router port holds the last reference on the rFID, then the
5521 * associated Sub-port RIF will be destroyed.
5522 */
5523 mlxsw_sp_fid_put(fid);
4724ba56
IS		 5524}
5525
7cbecf24
IS		 5526static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
5527 struct net_device *port_dev,
5528 unsigned long event, u16 vid)
4724ba56
IS		 5529{
5530 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
ce95e154 5531 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
4724ba56 5532
ce95e154 5533 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
7cbecf24
IS		 5534 if (WARN_ON(!mlxsw_sp_port_vlan))
5535 return -EINVAL;
4724ba56
IS		 5536
5537 switch (event) {
5538 case NETDEV_UP:
a1107487 5539 return mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
7cbecf24 5540 l3_dev);
4724ba56 5541 case NETDEV_DOWN:
a1107487 5542 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
4724ba56
IS		 5543 break;
5544 }
5545
5546 return 0;
5547}
5548
5549static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
5550 unsigned long event)
5551{
2b94e58d
JP		 5552 if (netif_is_bridge_port(port_dev) ||
5553 netif_is_lag_port(port_dev) ||
5554 netif_is_ovs_port(port_dev))
4724ba56
IS		 5555 return 0;
5556
7cbecf24 5557 return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event, 1);
4724ba56
IS		 5558}
5559
5560static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
5561 struct net_device *lag_dev,
5562 unsigned long event, u16 vid)
5563{
5564 struct net_device *port_dev;
5565 struct list_head *iter;
5566 int err;
5567
5568 netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
5569 if (mlxsw_sp_port_dev_check(port_dev)) {
7cbecf24
IS		 5570 err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
5571 port_dev,
5572 event, vid);
4724ba56
IS		 5573 if (err)
5574 return err;
5575 }
5576 }
5577
5578 return 0;
5579}
5580
5581static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
5582 unsigned long event)
5583{
5584 if (netif_is_bridge_port(lag_dev))
5585 return 0;
5586
5587 return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event, 1);
5588}
5589
4724ba56 5590static int mlxsw_sp_inetaddr_bridge_event(struct net_device *l3_dev,
4724ba56
IS		 5591 unsigned long event)
5592{
5593 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
e4f3c1c1
IS		 5594 struct mlxsw_sp_rif_params params = {
5595 .dev = l3_dev,
5596 };
a1107487 5597 struct mlxsw_sp_rif *rif;
4724ba56
IS		 5598
5599 switch (event) {
5600 case NETDEV_UP:
e4f3c1c1
IS		 5601 rif = mlxsw_sp_rif_create(mlxsw_sp, &params);
5602 if (IS_ERR(rif))
5603 return PTR_ERR(rif);
5604 break;
4724ba56 5605 case NETDEV_DOWN:
a1107487 5606 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
e4f3c1c1 5607 mlxsw_sp_rif_destroy(rif);
4724ba56
IS		 5608 break;
5609 }
5610
5611 return 0;
5612}
5613
5614static int mlxsw_sp_inetaddr_vlan_event(struct net_device *vlan_dev,
5615 unsigned long event)
5616{
5617 struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
4724ba56
IS		 5618 u16 vid = vlan_dev_vlan_id(vlan_dev);
5619
6b27c8ad
IS		 5620 if (netif_is_bridge_port(vlan_dev))
5621 return 0;
5622
4724ba56 5623 if (mlxsw_sp_port_dev_check(real_dev))
7cbecf24
IS		 5624 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
5625 event, vid);
4724ba56
IS		 5626 else if (netif_is_lag_master(real_dev))
5627 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
5628 vid);
c57529e1 5629 else if (netif_is_bridge_master(real_dev) && br_vlan_enabled(real_dev))
a1107487 5630 return mlxsw_sp_inetaddr_bridge_event(vlan_dev, event);
4724ba56
IS		 5631
5632 return 0;
5633}
5634
b1e45526
IS		 5635static int __mlxsw_sp_inetaddr_event(struct net_device *dev,
5636 unsigned long event)
5637{
5638 if (mlxsw_sp_port_dev_check(dev))
5639 return mlxsw_sp_inetaddr_port_event(dev, event);
5640 else if (netif_is_lag_master(dev))
5641 return mlxsw_sp_inetaddr_lag_event(dev, event);
5642 else if (netif_is_bridge_master(dev))
a1107487 5643 return mlxsw_sp_inetaddr_bridge_event(dev, event);
b1e45526
IS		 5644 else if (is_vlan_dev(dev))
5645 return mlxsw_sp_inetaddr_vlan_event(dev, event);
5646 else
5647 return 0;
5648}
5649
4724ba56
IS		 5650int mlxsw_sp_inetaddr_event(struct notifier_block *unused,
5651 unsigned long event, void *ptr)
5652{
5653 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
5654 struct net_device *dev = ifa->ifa_dev->dev;
5655 struct mlxsw_sp *mlxsw_sp;
bf95233e 5656 struct mlxsw_sp_rif *rif;
4724ba56
IS		 5657 int err = 0;
5658
5659 mlxsw_sp = mlxsw_sp_lower_get(dev);
5660 if (!mlxsw_sp)
5661 goto out;
5662
bf95233e 5663 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5ea1237f 5664 if (!mlxsw_sp_rif_should_config(rif, dev, event))
4724ba56
IS		 5665 goto out;
5666
b1e45526 5667 err = __mlxsw_sp_inetaddr_event(dev, event);
4724ba56
IS		 5668out:
5669 return notifier_from_errno(err);
5670}
5671
5ea1237f
AS		 5672struct mlxsw_sp_inet6addr_event_work {
5673 struct work_struct work;
5674 struct net_device *dev;
5675 unsigned long event;
5676};
5677
5678static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
5679{
5680 struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
5681 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
5682 struct net_device *dev = inet6addr_work->dev;
5683 unsigned long event = inet6addr_work->event;
5684 struct mlxsw_sp *mlxsw_sp;
5685 struct mlxsw_sp_rif *rif;
5686
5687 rtnl_lock();
5688 mlxsw_sp = mlxsw_sp_lower_get(dev);
5689 if (!mlxsw_sp)
5690 goto out;
5691
5692 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5693 if (!mlxsw_sp_rif_should_config(rif, dev, event))
5694 goto out;
5695
5696 __mlxsw_sp_inetaddr_event(dev, event);
5697out:
5698 rtnl_unlock();
5699 dev_put(dev);
5700 kfree(inet6addr_work);
5701}
5702
5703/* Called with rcu_read_lock() */
5704int mlxsw_sp_inet6addr_event(struct notifier_block *unused,
5705 unsigned long event, void *ptr)
5706{
5707 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
5708 struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
5709 struct net_device *dev = if6->idev->dev;
5710
5711 if (!mlxsw_sp_port_dev_lower_find_rcu(dev))
5712 return NOTIFY_DONE;
5713
5714 inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
5715 if (!inet6addr_work)
5716 return NOTIFY_BAD;
5717
5718 INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
5719 inet6addr_work->dev = dev;
5720 inet6addr_work->event = event;
5721 dev_hold(dev);
5722 mlxsw_core_schedule_work(&inet6addr_work->work);
5723
5724 return NOTIFY_DONE;
5725}
5726
bf95233e 5727static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
4724ba56
IS		 5728 const char *mac, int mtu)
5729{
5730 char ritr_pl[MLXSW_REG_RITR_LEN];
5731 int err;
5732
bf95233e 5733 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
4724ba56
IS		 5734 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5735 if (err)
5736 return err;
5737
5738 mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
5739 mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
5740 mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
5741 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5742}
5743
5744int mlxsw_sp_netdevice_router_port_event(struct net_device *dev)
5745{
5746 struct mlxsw_sp *mlxsw_sp;
bf95233e 5747 struct mlxsw_sp_rif *rif;
a1107487 5748 u16 fid_index;
4724ba56
IS		 5749 int err;
5750
5751 mlxsw_sp = mlxsw_sp_lower_get(dev);
5752 if (!mlxsw_sp)
5753 return 0;
5754
bf95233e
AS		 5755 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5756 if (!rif)
4724ba56 5757 return 0;
a1107487 5758 fid_index = mlxsw_sp_fid_index(rif->fid);
4724ba56 5759
a1107487 5760 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
4724ba56
IS		 5761 if (err)
5762 return err;
5763
bf95233e
AS		 5764 err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
5765 dev->mtu);
4724ba56
IS		 5766 if (err)
5767 goto err_rif_edit;
5768
a1107487 5769 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
4724ba56
IS		 5770 if (err)
5771 goto err_rif_fdb_op;
5772
fd890fe9
YG		 5773 if (rif->mtu != dev->mtu) {
5774 struct mlxsw_sp_vr *vr;
5775
5776 /* The RIF is relevant only to its mr_table instance, as unlike
5777 * unicast routing, in multicast routing a RIF cannot be shared
5778 * between several multicast routing tables.
5779 */
5780 vr = &mlxsw_sp->router->vrs[rif->vr_id];
5781 mlxsw_sp_mr_rif_mtu_update(vr->mr4_table, rif, dev->mtu);
5782 }
5783
bf95233e
AS		 5784 ether_addr_copy(rif->addr, dev->dev_addr);
5785 rif->mtu = dev->mtu;
4724ba56 5786
bf95233e 5787 netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
4724ba56
IS		 5788
5789 return 0;
5790
5791err_rif_fdb_op:
bf95233e 5792 mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu);
4724ba56 5793err_rif_edit:
a1107487 5794 mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
4724ba56
IS		 5795 return err;
5796}
5797
b1e45526
IS		 5798static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
5799 struct net_device *l3_dev)
7179eb5a 5800{
b1e45526 5801 struct mlxsw_sp_rif *rif;
7179eb5a 5802
b1e45526
IS		 5803 /* If netdev is already associated with a RIF, then we need to
5804 * destroy it and create a new one with the new virtual router ID.
7179eb5a 5805 */
b1e45526
IS		 5806 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5807 if (rif)
5808 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
7179eb5a 5809
b1e45526 5810 return __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_UP);
7179eb5a
IS		 5811}
5812
b1e45526
IS		 5813static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
5814 struct net_device *l3_dev)
7179eb5a 5815{
b1e45526 5816 struct mlxsw_sp_rif *rif;
7179eb5a 5817
b1e45526
IS		 5818 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5819 if (!rif)
7179eb5a 5820 return;
b1e45526 5821 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
7179eb5a
IS		 5822}
5823
b1e45526
IS		 5824int mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
5825 struct netdev_notifier_changeupper_info *info)
3d70e458 5826{
b1e45526
IS		 5827 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
5828 int err = 0;
3d70e458 5829
b1e45526
IS		 5830 if (!mlxsw_sp)
5831 return 0;
3d70e458 5832
b1e45526
IS		 5833 switch (event) {
5834 case NETDEV_PRECHANGEUPPER:
5835 return 0;
5836 case NETDEV_CHANGEUPPER:
5837 if (info->linking)
5838 err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev);
5839 else
5840 mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
5841 break;
5842 }
3d70e458 5843
b1e45526 5844 return err;
3d70e458
IS		 5845}
5846
e4f3c1c1
IS		 5847static struct mlxsw_sp_rif_subport *
5848mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
a1107487 5849{
e4f3c1c1
IS		 5850 return container_of(rif, struct mlxsw_sp_rif_subport, common);
5851}
5852
5853static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
5854 const struct mlxsw_sp_rif_params *params)
5855{
5856 struct mlxsw_sp_rif_subport *rif_subport;
5857
5858 rif_subport = mlxsw_sp_rif_subport_rif(rif);
5859 rif_subport->vid = params->vid;
5860 rif_subport->lag = params->lag;
5861 if (params->lag)
5862 rif_subport->lag_id = params->lag_id;
a1107487 5863 else
e4f3c1c1
IS		 5864 rif_subport->system_port = params->system_port;
5865}
5866
5867static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
5868{
5869 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5870 struct mlxsw_sp_rif_subport *rif_subport;
5871 char ritr_pl[MLXSW_REG_RITR_LEN];
5872
5873 rif_subport = mlxsw_sp_rif_subport_rif(rif);
5874 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
9571e828
PM		 5875 rif->rif_index, rif->vr_id, rif->dev->mtu);
5876 mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
e4f3c1c1
IS		 5877 mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
5878 rif_subport->lag ? rif_subport->lag_id :
5879 rif_subport->system_port,
5880 rif_subport->vid);
5881
5882 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5883}
5884
5885static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif)
5886{
010cadf9
PM		 5887 int err;
5888
5889 err = mlxsw_sp_rif_subport_op(rif, true);
5890 if (err)
5891 return err;
5892
5893 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5894 mlxsw_sp_fid_index(rif->fid), true);
5895 if (err)
5896 goto err_rif_fdb_op;
5897
5898 mlxsw_sp_fid_rif_set(rif->fid, rif);
5899 return 0;
5900
5901err_rif_fdb_op:
5902 mlxsw_sp_rif_subport_op(rif, false);
5903 return err;
a1107487
IS		 5904}
5905
e4f3c1c1
IS		 5906static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
5907{
010cadf9
PM		 5908 struct mlxsw_sp_fid *fid = rif->fid;
5909
5910 mlxsw_sp_fid_rif_set(fid, NULL);
5911 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5912 mlxsw_sp_fid_index(fid), false);
e4f3c1c1
IS		 5913 mlxsw_sp_rif_subport_op(rif, false);
5914}
5915
5916static struct mlxsw_sp_fid *
5917mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif)
5918{
5919 return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
5920}
5921
5922static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
5923 .type = MLXSW_SP_RIF_TYPE_SUBPORT,
5924 .rif_size = sizeof(struct mlxsw_sp_rif_subport),
5925 .setup = mlxsw_sp_rif_subport_setup,
5926 .configure = mlxsw_sp_rif_subport_configure,
5927 .deconfigure = mlxsw_sp_rif_subport_deconfigure,
5928 .fid_get = mlxsw_sp_rif_subport_fid_get,
5929};
5930
5931static int mlxsw_sp_rif_vlan_fid_op(struct mlxsw_sp_rif *rif,
5932 enum mlxsw_reg_ritr_if_type type,
5933 u16 vid_fid, bool enable)
5934{
5935 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5936 char ritr_pl[MLXSW_REG_RITR_LEN];
5937
5938 mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
9571e828
PM		 5939 rif->dev->mtu);
5940 mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
e4f3c1c1
IS		 5941 mlxsw_reg_ritr_fid_set(ritr_pl, type, vid_fid);
5942
5943 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5944}
5945
b35750f1 5946u8 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
e4f3c1c1
IS		 5947{
5948 return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
5949}
5950
5951static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif)
5952{
5953 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5954 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
5955 int err;
5956
5957 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, true);
5958 if (err)
5959 return err;
5960
0d284818
IS		 5961 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5962 mlxsw_sp_router_port(mlxsw_sp), true);
5963 if (err)
5964 goto err_fid_mc_flood_set;
5965
e4f3c1c1
IS		 5966 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5967 mlxsw_sp_router_port(mlxsw_sp), true);
5968 if (err)
5969 goto err_fid_bc_flood_set;
5970
010cadf9
PM		 5971 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5972 mlxsw_sp_fid_index(rif->fid), true);
5973 if (err)
5974 goto err_rif_fdb_op;
5975
5976 mlxsw_sp_fid_rif_set(rif->fid, rif);
e4f3c1c1
IS		 5977 return 0;
5978
010cadf9
PM		 5979err_rif_fdb_op:
5980 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5981 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1 5982err_fid_bc_flood_set:
0d284818
IS		 5983 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5984 mlxsw_sp_router_port(mlxsw_sp), false);
5985err_fid_mc_flood_set:
e4f3c1c1
IS		 5986 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
5987 return err;
5988}
5989
5990static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
5991{
e4f3c1c1 5992 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
010cadf9
PM		 5993 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5994 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 5995
010cadf9
PM		 5996 mlxsw_sp_fid_rif_set(fid, NULL);
5997 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5998 mlxsw_sp_fid_index(fid), false);
e4f3c1c1
IS		 5999 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
6000 mlxsw_sp_router_port(mlxsw_sp), false);
0d284818
IS		 6001 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
6002 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1
IS		 6003 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
6004}
6005
6006static struct mlxsw_sp_fid *
6007mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif)
6008{
6009 u16 vid = is_vlan_dev(rif->dev) ? vlan_dev_vlan_id(rif->dev) : 1;
6010
6011 return mlxsw_sp_fid_8021q_get(rif->mlxsw_sp, vid);
6012}
6013
6014static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_vlan_ops = {
6015 .type = MLXSW_SP_RIF_TYPE_VLAN,
6016 .rif_size = sizeof(struct mlxsw_sp_rif),
6017 .configure = mlxsw_sp_rif_vlan_configure,
6018 .deconfigure = mlxsw_sp_rif_vlan_deconfigure,
6019 .fid_get = mlxsw_sp_rif_vlan_fid_get,
6020};
6021
6022static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif)
6023{
6024 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
6025 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
6026 int err;
6027
6028 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index,
6029 true);
6030 if (err)
6031 return err;
6032
0d284818
IS		 6033 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
6034 mlxsw_sp_router_port(mlxsw_sp), true);
6035 if (err)
6036 goto err_fid_mc_flood_set;
6037
e4f3c1c1
IS		 6038 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
6039 mlxsw_sp_router_port(mlxsw_sp), true);
6040 if (err)
6041 goto err_fid_bc_flood_set;
6042
010cadf9
PM		 6043 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
6044 mlxsw_sp_fid_index(rif->fid), true);
6045 if (err)
6046 goto err_rif_fdb_op;
6047
6048 mlxsw_sp_fid_rif_set(rif->fid, rif);
e4f3c1c1
IS		 6049 return 0;
6050
010cadf9
PM		 6051err_rif_fdb_op:
6052 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
6053 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1 6054err_fid_bc_flood_set:
0d284818
IS		 6055 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
6056 mlxsw_sp_router_port(mlxsw_sp), false);
6057err_fid_mc_flood_set:
e4f3c1c1
IS		 6058 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
6059 return err;
6060}
6061
6062static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
6063{
e4f3c1c1 6064 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
010cadf9
PM		 6065 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
6066 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 6067
010cadf9
PM		 6068 mlxsw_sp_fid_rif_set(fid, NULL);
6069 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
6070 mlxsw_sp_fid_index(fid), false);
e4f3c1c1
IS		 6071 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
6072 mlxsw_sp_router_port(mlxsw_sp), false);
0d284818
IS		 6073 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
6074 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1
IS		 6075 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
6076}
6077
6078static struct mlxsw_sp_fid *
6079mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif)
6080{
6081 return mlxsw_sp_fid_8021d_get(rif->mlxsw_sp, rif->dev->ifindex);
6082}
6083
6084static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
6085 .type = MLXSW_SP_RIF_TYPE_FID,
6086 .rif_size = sizeof(struct mlxsw_sp_rif),
6087 .configure = mlxsw_sp_rif_fid_configure,
6088 .deconfigure = mlxsw_sp_rif_fid_deconfigure,
6089 .fid_get = mlxsw_sp_rif_fid_fid_get,
6090};
6091
6ddb7426
PM		 6092static struct mlxsw_sp_rif_ipip_lb *
6093mlxsw_sp_rif_ipip_lb_rif(struct mlxsw_sp_rif *rif)
6094{
6095 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
6096}
6097
6098static void
6099mlxsw_sp_rif_ipip_lb_setup(struct mlxsw_sp_rif *rif,
6100 const struct mlxsw_sp_rif_params *params)
6101{
6102 struct mlxsw_sp_rif_params_ipip_lb *params_lb;
6103 struct mlxsw_sp_rif_ipip_lb *rif_lb;
6104
6105 params_lb = container_of(params, struct mlxsw_sp_rif_params_ipip_lb,
6106 common);
6107 rif_lb = mlxsw_sp_rif_ipip_lb_rif(rif);
6108 rif_lb->lb_config = params_lb->lb_config;
6109}
6110
6111static int
6112mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif,
6113 struct mlxsw_sp_vr *ul_vr, bool enable)
6114{
6115 struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config;
6116 struct mlxsw_sp_rif *rif = &lb_rif->common;
6117 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
6118 char ritr_pl[MLXSW_REG_RITR_LEN];
6119 u32 saddr4;
6120
6121 switch (lb_cf.ul_protocol) {
6122 case MLXSW_SP_L3_PROTO_IPV4:
6123 saddr4 = be32_to_cpu(lb_cf.saddr.addr4);
6124 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
6125 rif->rif_index, rif->vr_id, rif->dev->mtu);
6126 mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt,
6127 MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET,
6128 ul_vr->id, saddr4, lb_cf.okey);
6129 break;
6130
6131 case MLXSW_SP_L3_PROTO_IPV6:
6132 return -EAFNOSUPPORT;
6133 }
6134
6135 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
6136}
6137
6138static int
6139mlxsw_sp_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif)
6140{
6141 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
6142 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(rif->dev);
6143 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
6144 struct mlxsw_sp_vr *ul_vr;
6145 int err;
6146
6147 ul_vr = mlxsw_sp_vr_get(mlxsw_sp, ul_tb_id);
6148 if (IS_ERR(ul_vr))
6149 return PTR_ERR(ul_vr);
6150
6151 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr, true);
6152 if (err)
6153 goto err_loopback_op;
6154
6155 lb_rif->ul_vr_id = ul_vr->id;
6156 ++ul_vr->rif_count;
6157 return 0;
6158
6159err_loopback_op:
6160 mlxsw_sp_vr_put(ul_vr);
6161 return err;
6162}
6163
6164static void mlxsw_sp_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
6165{
6166 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
6167 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
6168 struct mlxsw_sp_vr *ul_vr;
6169
6170 ul_vr = &mlxsw_sp->router->vrs[lb_rif->ul_vr_id];
6171 mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr, false);
6172
6173 --ul_vr->rif_count;
6174 mlxsw_sp_vr_put(ul_vr);
6175}
6176
6177static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_ipip_lb_ops = {
6178 .type = MLXSW_SP_RIF_TYPE_IPIP_LB,
6179 .rif_size = sizeof(struct mlxsw_sp_rif_ipip_lb),
6180 .setup = mlxsw_sp_rif_ipip_lb_setup,
6181 .configure = mlxsw_sp_rif_ipip_lb_configure,
6182 .deconfigure = mlxsw_sp_rif_ipip_lb_deconfigure,
6183};
6184
e4f3c1c1
IS		 6185static const struct mlxsw_sp_rif_ops *mlxsw_sp_rif_ops_arr[] = {
6186 [MLXSW_SP_RIF_TYPE_SUBPORT] = &mlxsw_sp_rif_subport_ops,
6187 [MLXSW_SP_RIF_TYPE_VLAN] = &mlxsw_sp_rif_vlan_ops,
6188 [MLXSW_SP_RIF_TYPE_FID] = &mlxsw_sp_rif_fid_ops,
6ddb7426 6189 [MLXSW_SP_RIF_TYPE_IPIP_LB] = &mlxsw_sp_rif_ipip_lb_ops,
e4f3c1c1
IS		 6190};
6191
348b8fc3
IS		 6192static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
6193{
6194 u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
6195
6196 mlxsw_sp->router->rifs = kcalloc(max_rifs,
6197 sizeof(struct mlxsw_sp_rif *),
6198 GFP_KERNEL);
6199 if (!mlxsw_sp->router->rifs)
6200 return -ENOMEM;
e4f3c1c1
IS		 6201
6202 mlxsw_sp->router->rif_ops_arr = mlxsw_sp_rif_ops_arr;
6203
348b8fc3
IS		 6204 return 0;
6205}
6206
6207static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
6208{
6209 int i;
6210
6211 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
6212 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
6213
6214 kfree(mlxsw_sp->router->rifs);
6215}
6216
38ebc0f4
PM		 6217static int mlxsw_sp_ipips_init(struct mlxsw_sp *mlxsw_sp)
6218{
6219 mlxsw_sp->router->ipip_ops_arr = mlxsw_sp_ipip_ops_arr;
1012b9ac 6220 INIT_LIST_HEAD(&mlxsw_sp->router->ipip_list);
38ebc0f4
PM		 6221 return 0;
6222}
6223
6224static void mlxsw_sp_ipips_fini(struct mlxsw_sp *mlxsw_sp)
6225{
1012b9ac 6226 WARN_ON(!list_empty(&mlxsw_sp->router->ipip_list));
38ebc0f4
PM		 6227}
6228
c3852ef7
IS		 6229static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
6230{
7e39d115 6231 struct mlxsw_sp_router *router;
c3852ef7
IS		 6232
6233 /* Flush pending FIB notifications and then flush the device's
6234 * table before requesting another dump. The FIB notification
6235 * block is unregistered, so no need to take RTNL.
6236 */
6237 mlxsw_core_flush_owq();
7e39d115
IS		 6238 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
6239 mlxsw_sp_router_fib_flush(router->mlxsw_sp);
c3852ef7
IS		 6240}
6241
4724ba56
IS		 6242static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
6243{
6244 char rgcr_pl[MLXSW_REG_RGCR_LEN];
6245 u64 max_rifs;
6246 int err;
6247
6248 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
6249 return -EIO;
4724ba56 6250 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
4724ba56 6251
e29237e7 6252 mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
4724ba56
IS		 6253 mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
6254 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
6255 if (err)
348b8fc3 6256 return err;
4724ba56 6257 return 0;
4724ba56
IS		 6258}
6259
6260static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
6261{
6262 char rgcr_pl[MLXSW_REG_RGCR_LEN];
4724ba56 6263
e29237e7 6264 mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
4724ba56 6265 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
4724ba56
IS		 6266}
6267
b45f64d1
JP		 6268int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
6269{
9011b677 6270 struct mlxsw_sp_router *router;
b45f64d1
JP		 6271 int err;
6272
9011b677
IS		 6273 router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
6274 if (!router)
6275 return -ENOMEM;
6276 mlxsw_sp->router = router;
6277 router->mlxsw_sp = mlxsw_sp;
6278
6279 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
b45f64d1
JP		 6280 err = __mlxsw_sp_router_init(mlxsw_sp);
6281 if (err)
9011b677 6282 goto err_router_init;
b45f64d1 6283
348b8fc3
IS		 6284 err = mlxsw_sp_rifs_init(mlxsw_sp);
6285 if (err)
6286 goto err_rifs_init;
6287
38ebc0f4
PM		 6288 err = mlxsw_sp_ipips_init(mlxsw_sp);
6289 if (err)
6290 goto err_ipips_init;
6291
9011b677 6292 err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
c53b8e1b
IS		 6293 &mlxsw_sp_nexthop_ht_params);
6294 if (err)
6295 goto err_nexthop_ht_init;
6296
9011b677 6297 err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 6298 &mlxsw_sp_nexthop_group_ht_params);
6299 if (err)
6300 goto err_nexthop_group_ht_init;
6301
dbe4598c 6302 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_list);
8494ab06
IS		 6303 err = mlxsw_sp_lpm_init(mlxsw_sp);
6304 if (err)
6305 goto err_lpm_init;
6306
d42b0965
YG		 6307 err = mlxsw_sp_mr_init(mlxsw_sp, &mlxsw_sp_mr_tcam_ops);
6308 if (err)
6309 goto err_mr_init;
6310
b45f64d1
JP		 6311 err = mlxsw_sp_vrs_init(mlxsw_sp);
6312 if (err)
6313 goto err_vrs_init;
6314
8c9583a8 6315 err = mlxsw_sp_neigh_init(mlxsw_sp);
b45f64d1
JP		 6316 if (err)
6317 goto err_neigh_init;
6318
7e39d115
IS		 6319 mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
6320 err = register_fib_notifier(&mlxsw_sp->router->fib_nb,
c3852ef7
IS		 6321 mlxsw_sp_router_fib_dump_flush);
6322 if (err)
6323 goto err_register_fib_notifier;
6324
b45f64d1
JP		 6325 return 0;
6326
c3852ef7
IS		 6327err_register_fib_notifier:
6328 mlxsw_sp_neigh_fini(mlxsw_sp);
b45f64d1
JP		 6329err_neigh_init:
6330 mlxsw_sp_vrs_fini(mlxsw_sp);
6331err_vrs_init:
d42b0965
YG		 6332 mlxsw_sp_mr_fini(mlxsw_sp);
6333err_mr_init:
8494ab06
IS		 6334 mlxsw_sp_lpm_fini(mlxsw_sp);
6335err_lpm_init:
9011b677 6336 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
e9ad5e7d 6337err_nexthop_group_ht_init:
9011b677 6338 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
c53b8e1b 6339err_nexthop_ht_init:
38ebc0f4
PM		 6340 mlxsw_sp_ipips_fini(mlxsw_sp);
6341err_ipips_init:
348b8fc3
IS		 6342 mlxsw_sp_rifs_fini(mlxsw_sp);
6343err_rifs_init:
b45f64d1 6344 __mlxsw_sp_router_fini(mlxsw_sp);
9011b677
IS		 6345err_router_init:
6346 kfree(mlxsw_sp->router);
b45f64d1
JP		 6347 return err;
6348}
6349
6350void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
6351{
7e39d115 6352 unregister_fib_notifier(&mlxsw_sp->router->fib_nb);
b45f64d1
JP		 6353 mlxsw_sp_neigh_fini(mlxsw_sp);
6354 mlxsw_sp_vrs_fini(mlxsw_sp);
d42b0965 6355 mlxsw_sp_mr_fini(mlxsw_sp);
8494ab06 6356 mlxsw_sp_lpm_fini(mlxsw_sp);
9011b677
IS		 6357 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
6358 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
38ebc0f4 6359 mlxsw_sp_ipips_fini(mlxsw_sp);
348b8fc3 6360 mlxsw_sp_rifs_fini(mlxsw_sp);
b45f64d1 6361 __mlxsw_sp_router_fini(mlxsw_sp);
9011b677 6362 kfree(mlxsw_sp->router);
b45f64d1 6363}
Linux 6.x block layer and io_uring tree(s)