2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
3 * Copyright (c) 2016-2017 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 * Copyright (c) 2016 Ido Schimmel <idosch@mellanox.com>
6 * Copyright (c) 2016 Yotam Gigi <yotamg@mellanox.com>
7 * Copyright (c) 2017 Petr Machata <petrm@mellanox.com>
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
38 #include <linux/kernel.h>
39 #include <linux/types.h>
40 #include <linux/rhashtable.h>
41 #include <linux/bitops.h>
42 #include <linux/in6.h>
43 #include <linux/notifier.h>
44 #include <linux/inetdevice.h>
45 #include <linux/netdevice.h>
46 #include <linux/if_bridge.h>
47 #include <linux/socket.h>
48 #include <linux/route.h>
49 #include <net/netevent.h>
50 #include <net/neighbour.h>
52 #include <net/ip_fib.h>
53 #include <net/ip6_fib.h>
54 #include <net/fib_rules.h>
55 #include <net/ip_tunnels.h>
56 #include <net/l3mdev.h>
57 #include <net/addrconf.h>
58 #include <net/ndisc.h>
60 #include <net/fib_notifier.h>
65 #include "spectrum_cnt.h"
66 #include "spectrum_dpipe.h"
67 #include "spectrum_ipip.h"
68 #include "spectrum_router.h"
71 struct mlxsw_sp_lpm_tree;
72 struct mlxsw_sp_rif_ops;
74 struct mlxsw_sp_router {
75 struct mlxsw_sp *mlxsw_sp;
76 struct mlxsw_sp_rif **rifs;
77 struct mlxsw_sp_vr *vrs;
78 struct rhashtable neigh_ht;
79 struct rhashtable nexthop_group_ht;
80 struct rhashtable nexthop_ht;
82 struct mlxsw_sp_lpm_tree *trees;
83 unsigned int tree_count;
86 struct delayed_work dw;
87 unsigned long interval; /* ms */
89 struct delayed_work nexthop_probe_dw;
90 #define MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL 5000 /* ms */
91 struct list_head nexthop_neighs_list;
92 struct list_head ipip_list;
94 struct notifier_block fib_nb;
95 const struct mlxsw_sp_rif_ops **rif_ops_arr;
96 const struct mlxsw_sp_ipip_ops **ipip_ops_arr;
100 struct list_head nexthop_list;
101 struct list_head neigh_list;
102 struct net_device *dev;
103 struct mlxsw_sp_fid *fid;
104 unsigned char addr[ETH_ALEN];
108 const struct mlxsw_sp_rif_ops *ops;
109 struct mlxsw_sp *mlxsw_sp;
111 unsigned int counter_ingress;
112 bool counter_ingress_valid;
113 unsigned int counter_egress;
114 bool counter_egress_valid;
117 struct mlxsw_sp_rif_params {
118 struct net_device *dev;
127 struct mlxsw_sp_rif_subport {
128 struct mlxsw_sp_rif common;
137 struct mlxsw_sp_rif_ipip_lb {
138 struct mlxsw_sp_rif common;
139 struct mlxsw_sp_rif_ipip_lb_config lb_config;
140 u16 ul_vr_id; /* Reserved for Spectrum-2. */
143 struct mlxsw_sp_rif_params_ipip_lb {
144 struct mlxsw_sp_rif_params common;
145 struct mlxsw_sp_rif_ipip_lb_config lb_config;
148 struct mlxsw_sp_rif_ops {
149 enum mlxsw_sp_rif_type type;
152 void (*setup)(struct mlxsw_sp_rif *rif,
153 const struct mlxsw_sp_rif_params *params);
154 int (*configure)(struct mlxsw_sp_rif *rif);
155 void (*deconfigure)(struct mlxsw_sp_rif *rif);
156 struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif);
159 static unsigned int *
160 mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif,
161 enum mlxsw_sp_rif_counter_dir dir)
164 case MLXSW_SP_RIF_COUNTER_EGRESS:
165 return &rif->counter_egress;
166 case MLXSW_SP_RIF_COUNTER_INGRESS:
167 return &rif->counter_ingress;
173 mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif,
174 enum mlxsw_sp_rif_counter_dir dir)
177 case MLXSW_SP_RIF_COUNTER_EGRESS:
178 return rif->counter_egress_valid;
179 case MLXSW_SP_RIF_COUNTER_INGRESS:
180 return rif->counter_ingress_valid;
186 mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
187 enum mlxsw_sp_rif_counter_dir dir,
191 case MLXSW_SP_RIF_COUNTER_EGRESS:
192 rif->counter_egress_valid = valid;
194 case MLXSW_SP_RIF_COUNTER_INGRESS:
195 rif->counter_ingress_valid = valid;
200 static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
201 unsigned int counter_index, bool enable,
202 enum mlxsw_sp_rif_counter_dir dir)
204 char ritr_pl[MLXSW_REG_RITR_LEN];
205 bool is_egress = false;
208 if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
210 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
211 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
215 mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
217 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
220 int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
221 struct mlxsw_sp_rif *rif,
222 enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
224 char ricnt_pl[MLXSW_REG_RICNT_LEN];
225 unsigned int *p_counter_index;
229 valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
233 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
234 if (!p_counter_index)
236 mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
237 MLXSW_REG_RICNT_OPCODE_NOP);
238 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
241 *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
245 static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
246 unsigned int counter_index)
248 char ricnt_pl[MLXSW_REG_RICNT_LEN];
250 mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
251 MLXSW_REG_RICNT_OPCODE_CLEAR);
252 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
255 int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp *mlxsw_sp,
256 struct mlxsw_sp_rif *rif,
257 enum mlxsw_sp_rif_counter_dir dir)
259 unsigned int *p_counter_index;
262 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
263 if (!p_counter_index)
265 err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
270 err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
272 goto err_counter_clear;
274 err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
275 *p_counter_index, true, dir);
277 goto err_counter_edit;
278 mlxsw_sp_rif_counter_valid_set(rif, dir, true);
283 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
288 void mlxsw_sp_rif_counter_free(struct mlxsw_sp *mlxsw_sp,
289 struct mlxsw_sp_rif *rif,
290 enum mlxsw_sp_rif_counter_dir dir)
292 unsigned int *p_counter_index;
294 if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
297 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
298 if (WARN_ON(!p_counter_index))
300 mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
301 *p_counter_index, false, dir);
302 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
304 mlxsw_sp_rif_counter_valid_set(rif, dir, false);
307 static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
309 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
310 struct devlink *devlink;
312 devlink = priv_to_devlink(mlxsw_sp->core);
313 if (!devlink_dpipe_table_counter_enabled(devlink,
314 MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
316 mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
319 static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
321 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
323 mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
326 static struct mlxsw_sp_rif *
327 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
328 const struct net_device *dev);
330 #define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
332 struct mlxsw_sp_prefix_usage {
333 DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
336 #define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
337 for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
340 mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
341 struct mlxsw_sp_prefix_usage *prefix_usage2)
343 return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
347 mlxsw_sp_prefix_usage_none(struct mlxsw_sp_prefix_usage *prefix_usage)
349 struct mlxsw_sp_prefix_usage prefix_usage_none = {{ 0 } };
351 return mlxsw_sp_prefix_usage_eq(prefix_usage, &prefix_usage_none);
355 mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
356 struct mlxsw_sp_prefix_usage *prefix_usage2)
358 memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
362 mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
363 unsigned char prefix_len)
365 set_bit(prefix_len, prefix_usage->b);
369 mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
370 unsigned char prefix_len)
372 clear_bit(prefix_len, prefix_usage->b);
375 struct mlxsw_sp_fib_key {
376 unsigned char addr[sizeof(struct in6_addr)];
377 unsigned char prefix_len;
380 enum mlxsw_sp_fib_entry_type {
381 MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
382 MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
383 MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
385 /* This is a special case of local delivery, where a packet should be
386 * decapsulated on reception. Note that there is no corresponding ENCAP,
387 * because that's a type of next hop, not of FIB entry. (There can be
388 * several next hops in a REMOTE entry, and some of them may be
389 * encapsulating entries.)
391 MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP,
394 struct mlxsw_sp_nexthop_group;
397 struct mlxsw_sp_fib_node {
398 struct list_head entry_list;
399 struct list_head list;
400 struct rhash_head ht_node;
401 struct mlxsw_sp_fib *fib;
402 struct mlxsw_sp_fib_key key;
405 struct mlxsw_sp_fib_entry_decap {
406 struct mlxsw_sp_ipip_entry *ipip_entry;
410 struct mlxsw_sp_fib_entry {
411 struct list_head list;
412 struct mlxsw_sp_fib_node *fib_node;
413 enum mlxsw_sp_fib_entry_type type;
414 struct list_head nexthop_group_node;
415 struct mlxsw_sp_nexthop_group *nh_group;
416 struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */
419 struct mlxsw_sp_fib4_entry {
420 struct mlxsw_sp_fib_entry common;
427 struct mlxsw_sp_fib6_entry {
428 struct mlxsw_sp_fib_entry common;
429 struct list_head rt6_list;
433 struct mlxsw_sp_rt6 {
434 struct list_head list;
438 struct mlxsw_sp_lpm_tree {
440 unsigned int ref_count;
441 enum mlxsw_sp_l3proto proto;
442 struct mlxsw_sp_prefix_usage prefix_usage;
445 struct mlxsw_sp_fib {
446 struct rhashtable ht;
447 struct list_head node_list;
448 struct mlxsw_sp_vr *vr;
449 struct mlxsw_sp_lpm_tree *lpm_tree;
450 unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
451 struct mlxsw_sp_prefix_usage prefix_usage;
452 enum mlxsw_sp_l3proto proto;
456 u16 id; /* virtual router ID */
457 u32 tb_id; /* kernel fib table id */
458 unsigned int rif_count;
459 struct mlxsw_sp_fib *fib4;
460 struct mlxsw_sp_fib *fib6;
463 static const struct rhashtable_params mlxsw_sp_fib_ht_params;
465 static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp_vr *vr,
466 enum mlxsw_sp_l3proto proto)
468 struct mlxsw_sp_fib *fib;
471 fib = kzalloc(sizeof(*fib), GFP_KERNEL);
473 return ERR_PTR(-ENOMEM);
474 err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
476 goto err_rhashtable_init;
477 INIT_LIST_HEAD(&fib->node_list);
487 static void mlxsw_sp_fib_destroy(struct mlxsw_sp_fib *fib)
489 WARN_ON(!list_empty(&fib->node_list));
490 WARN_ON(fib->lpm_tree);
491 rhashtable_destroy(&fib->ht);
495 static struct mlxsw_sp_lpm_tree *
496 mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
498 static struct mlxsw_sp_lpm_tree *lpm_tree;
501 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
502 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
503 if (lpm_tree->ref_count == 0)
509 static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
510 struct mlxsw_sp_lpm_tree *lpm_tree)
512 char ralta_pl[MLXSW_REG_RALTA_LEN];
514 mlxsw_reg_ralta_pack(ralta_pl, true,
515 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
517 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
520 static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
521 struct mlxsw_sp_lpm_tree *lpm_tree)
523 char ralta_pl[MLXSW_REG_RALTA_LEN];
525 mlxsw_reg_ralta_pack(ralta_pl, false,
526 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
528 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
532 mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
533 struct mlxsw_sp_prefix_usage *prefix_usage,
534 struct mlxsw_sp_lpm_tree *lpm_tree)
536 char ralst_pl[MLXSW_REG_RALST_LEN];
539 u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
541 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
544 mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
545 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
548 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
549 MLXSW_REG_RALST_BIN_NO_CHILD);
550 last_prefix = prefix;
552 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
555 static struct mlxsw_sp_lpm_tree *
556 mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
557 struct mlxsw_sp_prefix_usage *prefix_usage,
558 enum mlxsw_sp_l3proto proto)
560 struct mlxsw_sp_lpm_tree *lpm_tree;
563 lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
565 return ERR_PTR(-EBUSY);
566 lpm_tree->proto = proto;
567 err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
571 err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
574 goto err_left_struct_set;
575 memcpy(&lpm_tree->prefix_usage, prefix_usage,
576 sizeof(lpm_tree->prefix_usage));
580 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
584 static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
585 struct mlxsw_sp_lpm_tree *lpm_tree)
587 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
590 static struct mlxsw_sp_lpm_tree *
591 mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
592 struct mlxsw_sp_prefix_usage *prefix_usage,
593 enum mlxsw_sp_l3proto proto)
595 struct mlxsw_sp_lpm_tree *lpm_tree;
598 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
599 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
600 if (lpm_tree->ref_count != 0 &&
601 lpm_tree->proto == proto &&
602 mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
606 return mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage, proto);
609 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree)
611 lpm_tree->ref_count++;
614 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
615 struct mlxsw_sp_lpm_tree *lpm_tree)
617 if (--lpm_tree->ref_count == 0)
618 mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
621 #define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
623 static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
625 struct mlxsw_sp_lpm_tree *lpm_tree;
629 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
632 max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
633 mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
634 mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
635 sizeof(struct mlxsw_sp_lpm_tree),
637 if (!mlxsw_sp->router->lpm.trees)
640 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
641 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
642 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
648 static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
650 kfree(mlxsw_sp->router->lpm.trees);
653 static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
655 return !!vr->fib4 || !!vr->fib6;
658 static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
660 struct mlxsw_sp_vr *vr;
663 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
664 vr = &mlxsw_sp->router->vrs[i];
665 if (!mlxsw_sp_vr_is_used(vr))
671 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
672 const struct mlxsw_sp_fib *fib, u8 tree_id)
674 char raltb_pl[MLXSW_REG_RALTB_LEN];
676 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
677 (enum mlxsw_reg_ralxx_protocol) fib->proto,
679 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
682 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
683 const struct mlxsw_sp_fib *fib)
685 char raltb_pl[MLXSW_REG_RALTB_LEN];
687 /* Bind to tree 0 which is default */
688 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
689 (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
690 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
693 static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
695 /* For our purpose, squash main and local table into one */
696 if (tb_id == RT_TABLE_LOCAL)
697 tb_id = RT_TABLE_MAIN;
701 static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
704 struct mlxsw_sp_vr *vr;
707 tb_id = mlxsw_sp_fix_tb_id(tb_id);
709 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
710 vr = &mlxsw_sp->router->vrs[i];
711 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
717 static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
718 enum mlxsw_sp_l3proto proto)
721 case MLXSW_SP_L3_PROTO_IPV4:
723 case MLXSW_SP_L3_PROTO_IPV6:
729 static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
732 struct mlxsw_sp_vr *vr;
735 vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
737 return ERR_PTR(-EBUSY);
738 vr->fib4 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV4);
739 if (IS_ERR(vr->fib4))
740 return ERR_CAST(vr->fib4);
741 vr->fib6 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV6);
742 if (IS_ERR(vr->fib6)) {
743 err = PTR_ERR(vr->fib6);
744 goto err_fib6_create;
750 mlxsw_sp_fib_destroy(vr->fib4);
755 static void mlxsw_sp_vr_destroy(struct mlxsw_sp_vr *vr)
757 mlxsw_sp_fib_destroy(vr->fib6);
759 mlxsw_sp_fib_destroy(vr->fib4);
763 static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id)
765 struct mlxsw_sp_vr *vr;
767 tb_id = mlxsw_sp_fix_tb_id(tb_id);
768 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
770 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id);
774 static void mlxsw_sp_vr_put(struct mlxsw_sp_vr *vr)
776 if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
777 list_empty(&vr->fib6->node_list))
778 mlxsw_sp_vr_destroy(vr);
782 mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr,
783 enum mlxsw_sp_l3proto proto, u8 tree_id)
785 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
787 if (!mlxsw_sp_vr_is_used(vr))
789 if (fib->lpm_tree && fib->lpm_tree->id == tree_id)
794 static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
795 struct mlxsw_sp_fib *fib,
796 struct mlxsw_sp_lpm_tree *new_tree)
798 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
801 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
804 fib->lpm_tree = new_tree;
805 mlxsw_sp_lpm_tree_hold(new_tree);
806 mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
810 static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
811 struct mlxsw_sp_fib *fib,
812 struct mlxsw_sp_lpm_tree *new_tree)
814 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
815 enum mlxsw_sp_l3proto proto = fib->proto;
816 u8 old_id, new_id = new_tree->id;
817 struct mlxsw_sp_vr *vr;
822 old_id = old_tree->id;
824 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
825 vr = &mlxsw_sp->router->vrs[i];
826 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id))
828 err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
829 mlxsw_sp_vr_fib(vr, proto),
832 goto err_tree_replace;
838 for (i--; i >= 0; i--) {
839 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id))
841 mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
842 mlxsw_sp_vr_fib(vr, proto),
848 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
851 fib->lpm_tree = new_tree;
852 mlxsw_sp_lpm_tree_hold(new_tree);
857 mlxsw_sp_vrs_prefixes(struct mlxsw_sp *mlxsw_sp,
858 enum mlxsw_sp_l3proto proto,
859 struct mlxsw_sp_prefix_usage *req_prefix_usage)
863 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
864 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
865 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
866 unsigned char prefix;
868 if (!mlxsw_sp_vr_is_used(vr))
870 mlxsw_sp_prefix_usage_for_each(prefix, &fib->prefix_usage)
871 mlxsw_sp_prefix_usage_set(req_prefix_usage, prefix);
875 static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
877 struct mlxsw_sp_vr *vr;
881 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
884 max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
885 mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
887 if (!mlxsw_sp->router->vrs)
890 for (i = 0; i < max_vrs; i++) {
891 vr = &mlxsw_sp->router->vrs[i];
898 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
900 static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
902 /* At this stage we're guaranteed not to have new incoming
903 * FIB notifications and the work queue is free from FIBs
904 * sitting on top of mlxsw netdevs. However, we can still
905 * have other FIBs queued. Flush the queue before flushing
906 * the device's tables. No need for locks, as we're the only
909 mlxsw_core_flush_owq();
910 mlxsw_sp_router_fib_flush(mlxsw_sp);
911 kfree(mlxsw_sp->router->vrs);
914 static struct net_device *
915 __mlxsw_sp_ipip_netdev_ul_dev_get(const struct net_device *ol_dev)
917 struct ip_tunnel *tun = netdev_priv(ol_dev);
918 struct net *net = dev_net(ol_dev);
920 return __dev_get_by_index(net, tun->parms.link);
923 static u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev)
925 struct net_device *d = __mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
928 return l3mdev_fib_table(d) ? : RT_TABLE_MAIN;
930 return l3mdev_fib_table(ol_dev) ? : RT_TABLE_MAIN;
933 static struct mlxsw_sp_rif *
934 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
935 const struct mlxsw_sp_rif_params *params);
937 static struct mlxsw_sp_rif_ipip_lb *
938 mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp,
939 enum mlxsw_sp_ipip_type ipipt,
940 struct net_device *ol_dev)
942 struct mlxsw_sp_rif_params_ipip_lb lb_params;
943 const struct mlxsw_sp_ipip_ops *ipip_ops;
944 struct mlxsw_sp_rif *rif;
946 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
947 lb_params = (struct mlxsw_sp_rif_params_ipip_lb) {
948 .common.dev = ol_dev,
950 .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev),
953 rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common);
955 return ERR_CAST(rif);
956 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
959 static struct mlxsw_sp_ipip_entry *
960 mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp,
961 enum mlxsw_sp_ipip_type ipipt,
962 struct net_device *ol_dev)
964 struct mlxsw_sp_ipip_entry *ipip_entry;
965 struct mlxsw_sp_ipip_entry *ret = NULL;
967 ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL);
969 return ERR_PTR(-ENOMEM);
971 ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt,
973 if (IS_ERR(ipip_entry->ol_lb)) {
974 ret = ERR_CAST(ipip_entry->ol_lb);
975 goto err_ol_ipip_lb_create;
978 ipip_entry->ipipt = ipipt;
979 ipip_entry->ol_dev = ol_dev;
983 err_ol_ipip_lb_create:
989 mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp_ipip_entry *ipip_entry)
991 WARN_ON(ipip_entry->ref_count > 0);
992 mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
997 mlxsw_sp_ipip_netdev_saddr4(const struct net_device *ol_dev)
999 struct ip_tunnel *tun = netdev_priv(ol_dev);
1001 return tun->parms.iph.saddr;
1004 union mlxsw_sp_l3addr
1005 mlxsw_sp_ipip_netdev_saddr(enum mlxsw_sp_l3proto proto,
1006 const struct net_device *ol_dev)
1009 case MLXSW_SP_L3_PROTO_IPV4:
1010 return (union mlxsw_sp_l3addr) {
1011 .addr4 = mlxsw_sp_ipip_netdev_saddr4(ol_dev),
1013 case MLXSW_SP_L3_PROTO_IPV6:
1018 return (union mlxsw_sp_l3addr) {
1023 __be32 mlxsw_sp_ipip_netdev_daddr4(const struct net_device *ol_dev)
1025 struct ip_tunnel *tun = netdev_priv(ol_dev);
1027 return tun->parms.iph.daddr;
1030 union mlxsw_sp_l3addr
1031 mlxsw_sp_ipip_netdev_daddr(enum mlxsw_sp_l3proto proto,
1032 const struct net_device *ol_dev)
1035 case MLXSW_SP_L3_PROTO_IPV4:
1036 return (union mlxsw_sp_l3addr) {
1037 .addr4 = mlxsw_sp_ipip_netdev_daddr4(ol_dev),
1039 case MLXSW_SP_L3_PROTO_IPV6:
1044 return (union mlxsw_sp_l3addr) {
1049 static bool mlxsw_sp_l3addr_eq(const union mlxsw_sp_l3addr *addr1,
1050 const union mlxsw_sp_l3addr *addr2)
1052 return !memcmp(addr1, addr2, sizeof(*addr1));
1056 mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp,
1057 const enum mlxsw_sp_l3proto ul_proto,
1058 union mlxsw_sp_l3addr saddr,
1060 struct mlxsw_sp_ipip_entry *ipip_entry)
1062 u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1063 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1064 union mlxsw_sp_l3addr tun_saddr;
1066 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1069 tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1070 return tun_ul_tb_id == ul_tb_id &&
1071 mlxsw_sp_l3addr_eq(&tun_saddr, &saddr);
1075 mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp,
1076 struct mlxsw_sp_fib_entry *fib_entry,
1077 struct mlxsw_sp_ipip_entry *ipip_entry)
1082 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, 1, &tunnel_index);
1086 ipip_entry->decap_fib_entry = fib_entry;
1087 fib_entry->decap.ipip_entry = ipip_entry;
1088 fib_entry->decap.tunnel_index = tunnel_index;
1092 static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp,
1093 struct mlxsw_sp_fib_entry *fib_entry)
1095 /* Unlink this node from the IPIP entry that it's the decap entry of. */
1096 fib_entry->decap.ipip_entry->decap_fib_entry = NULL;
1097 fib_entry->decap.ipip_entry = NULL;
1098 mlxsw_sp_kvdl_free(mlxsw_sp, fib_entry->decap.tunnel_index);
1101 static struct mlxsw_sp_fib_node *
1102 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
1103 size_t addr_len, unsigned char prefix_len);
1104 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1105 struct mlxsw_sp_fib_entry *fib_entry);
1108 mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp,
1109 struct mlxsw_sp_ipip_entry *ipip_entry)
1111 struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry;
1113 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
1114 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1116 mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1120 mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp,
1121 struct mlxsw_sp_ipip_entry *ipip_entry,
1122 struct mlxsw_sp_fib_entry *decap_fib_entry)
1124 if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry,
1127 decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
1129 if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry))
1130 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1133 /* Given an IPIP entry, find the corresponding decap route. */
1134 static struct mlxsw_sp_fib_entry *
1135 mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp,
1136 struct mlxsw_sp_ipip_entry *ipip_entry)
1138 static struct mlxsw_sp_fib_node *fib_node;
1139 const struct mlxsw_sp_ipip_ops *ipip_ops;
1140 struct mlxsw_sp_fib_entry *fib_entry;
1141 unsigned char saddr_prefix_len;
1142 union mlxsw_sp_l3addr saddr;
1143 struct mlxsw_sp_fib *ul_fib;
1144 struct mlxsw_sp_vr *ul_vr;
1150 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1152 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1153 ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id);
1157 ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto);
1158 saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto,
1159 ipip_entry->ol_dev);
1161 switch (ipip_ops->ul_proto) {
1162 case MLXSW_SP_L3_PROTO_IPV4:
1163 saddr4 = be32_to_cpu(saddr.addr4);
1166 saddr_prefix_len = 32;
1168 case MLXSW_SP_L3_PROTO_IPV6:
1173 fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len,
1175 if (!fib_node || list_empty(&fib_node->entry_list))
1178 fib_entry = list_first_entry(&fib_node->entry_list,
1179 struct mlxsw_sp_fib_entry, list);
1180 if (fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP)
1186 static struct mlxsw_sp_ipip_entry *
1187 mlxsw_sp_ipip_entry_get(struct mlxsw_sp *mlxsw_sp,
1188 enum mlxsw_sp_ipip_type ipipt,
1189 struct net_device *ol_dev)
1191 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev);
1192 struct mlxsw_sp_router *router = mlxsw_sp->router;
1193 struct mlxsw_sp_fib_entry *decap_fib_entry;
1194 struct mlxsw_sp_ipip_entry *ipip_entry;
1195 enum mlxsw_sp_l3proto ul_proto;
1196 union mlxsw_sp_l3addr saddr;
1198 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1200 if (ipip_entry->ol_dev == ol_dev)
1203 /* The configuration where several tunnels have the same local
1204 * address in the same underlay table needs special treatment in
1205 * the HW. That is currently not implemented in the driver.
1207 ul_proto = router->ipip_ops_arr[ipip_entry->ipipt]->ul_proto;
1208 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev);
1209 if (mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr,
1210 ul_tb_id, ipip_entry))
1211 return ERR_PTR(-EEXIST);
1214 ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev);
1215 if (IS_ERR(ipip_entry))
1218 decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry);
1219 if (decap_fib_entry)
1220 mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry,
1223 list_add_tail(&ipip_entry->ipip_list_node,
1224 &mlxsw_sp->router->ipip_list);
1227 ++ipip_entry->ref_count;
1232 mlxsw_sp_ipip_entry_put(struct mlxsw_sp *mlxsw_sp,
1233 struct mlxsw_sp_ipip_entry *ipip_entry)
1235 if (--ipip_entry->ref_count == 0) {
1236 list_del(&ipip_entry->ipip_list_node);
1237 if (ipip_entry->decap_fib_entry)
1238 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1239 mlxsw_sp_ipip_entry_destroy(ipip_entry);
1244 mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp,
1245 const struct net_device *ul_dev,
1246 enum mlxsw_sp_l3proto ul_proto,
1247 union mlxsw_sp_l3addr ul_dip,
1248 struct mlxsw_sp_ipip_entry *ipip_entry)
1250 u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1251 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1252 struct net_device *ipip_ul_dev;
1254 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1257 ipip_ul_dev = __mlxsw_sp_ipip_netdev_ul_dev_get(ipip_entry->ol_dev);
1258 return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip,
1259 ul_tb_id, ipip_entry) &&
1260 (!ipip_ul_dev || ipip_ul_dev == ul_dev);
1263 /* Given decap parameters, find the corresponding IPIP entry. */
1264 static struct mlxsw_sp_ipip_entry *
1265 mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp,
1266 const struct net_device *ul_dev,
1267 enum mlxsw_sp_l3proto ul_proto,
1268 union mlxsw_sp_l3addr ul_dip)
1270 struct mlxsw_sp_ipip_entry *ipip_entry;
1272 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1274 if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev,
1282 struct mlxsw_sp_neigh_key {
1283 struct neighbour *n;
1286 struct mlxsw_sp_neigh_entry {
1287 struct list_head rif_list_node;
1288 struct rhash_head ht_node;
1289 struct mlxsw_sp_neigh_key key;
1292 unsigned char ha[ETH_ALEN];
1293 struct list_head nexthop_list; /* list of nexthops using
1296 struct list_head nexthop_neighs_list_node;
1297 unsigned int counter_index;
1301 static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
1302 .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
1303 .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
1304 .key_len = sizeof(struct mlxsw_sp_neigh_key),
1307 struct mlxsw_sp_neigh_entry *
1308 mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif,
1309 struct mlxsw_sp_neigh_entry *neigh_entry)
1312 if (list_empty(&rif->neigh_list))
1315 return list_first_entry(&rif->neigh_list,
1316 typeof(*neigh_entry),
1319 if (neigh_entry->rif_list_node.next == &rif->neigh_list)
1321 return list_next_entry(neigh_entry, rif_list_node);
1324 int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry)
1326 return neigh_entry->key.n->tbl->family;
1330 mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry)
1332 return neigh_entry->ha;
1335 u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1337 struct neighbour *n;
1339 n = neigh_entry->key.n;
1340 return ntohl(*((__be32 *) n->primary_key));
1344 mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1346 struct neighbour *n;
1348 n = neigh_entry->key.n;
1349 return (struct in6_addr *) &n->primary_key;
1352 int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp,
1353 struct mlxsw_sp_neigh_entry *neigh_entry,
1356 if (!neigh_entry->counter_valid)
1359 return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index,
1363 static struct mlxsw_sp_neigh_entry *
1364 mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
1367 struct mlxsw_sp_neigh_entry *neigh_entry;
1369 neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
1373 neigh_entry->key.n = n;
1374 neigh_entry->rif = rif;
1375 INIT_LIST_HEAD(&neigh_entry->nexthop_list);
1380 static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
1386 mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
1387 struct mlxsw_sp_neigh_entry *neigh_entry)
1389 return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
1390 &neigh_entry->ht_node,
1391 mlxsw_sp_neigh_ht_params);
1395 mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
1396 struct mlxsw_sp_neigh_entry *neigh_entry)
1398 rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
1399 &neigh_entry->ht_node,
1400 mlxsw_sp_neigh_ht_params);
1404 mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp,
1405 struct mlxsw_sp_neigh_entry *neigh_entry)
1407 struct devlink *devlink;
1408 const char *table_name;
1410 switch (mlxsw_sp_neigh_entry_type(neigh_entry)) {
1412 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4;
1415 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6;
1422 devlink = priv_to_devlink(mlxsw_sp->core);
1423 return devlink_dpipe_table_counter_enabled(devlink, table_name);
1427 mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp,
1428 struct mlxsw_sp_neigh_entry *neigh_entry)
1430 if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry))
1433 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index))
1436 neigh_entry->counter_valid = true;
1440 mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp,
1441 struct mlxsw_sp_neigh_entry *neigh_entry)
1443 if (!neigh_entry->counter_valid)
1445 mlxsw_sp_flow_counter_free(mlxsw_sp,
1446 neigh_entry->counter_index);
1447 neigh_entry->counter_valid = false;
1450 static struct mlxsw_sp_neigh_entry *
1451 mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
1453 struct mlxsw_sp_neigh_entry *neigh_entry;
1454 struct mlxsw_sp_rif *rif;
1457 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
1459 return ERR_PTR(-EINVAL);
1461 neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
1463 return ERR_PTR(-ENOMEM);
1465 err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
1467 goto err_neigh_entry_insert;
1469 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
1470 list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
1474 err_neigh_entry_insert:
1475 mlxsw_sp_neigh_entry_free(neigh_entry);
1476 return ERR_PTR(err);
1480 mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1481 struct mlxsw_sp_neigh_entry *neigh_entry)
1483 list_del(&neigh_entry->rif_list_node);
1484 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
1485 mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
1486 mlxsw_sp_neigh_entry_free(neigh_entry);
1489 static struct mlxsw_sp_neigh_entry *
1490 mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
1492 struct mlxsw_sp_neigh_key key;
1495 return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
1496 &key, mlxsw_sp_neigh_ht_params);
1500 mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
1502 unsigned long interval;
1504 #if IS_ENABLED(CONFIG_IPV6)
1505 interval = min_t(unsigned long,
1506 NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
1507 NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
1509 interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
1511 mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
1514 static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1518 struct net_device *dev;
1519 struct neighbour *n;
1524 mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
1526 if (!mlxsw_sp->router->rifs[rif]) {
1527 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1532 dev = mlxsw_sp->router->rifs[rif]->dev;
1533 n = neigh_lookup(&arp_tbl, &dipn, dev);
1535 netdev_err(dev, "Failed to find matching neighbour for IP=%pI4h\n",
1540 netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
1541 neigh_event_send(n, NULL);
1545 #if IS_ENABLED(CONFIG_IPV6)
1546 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1550 struct net_device *dev;
1551 struct neighbour *n;
1552 struct in6_addr dip;
1555 mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
1558 if (!mlxsw_sp->router->rifs[rif]) {
1559 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1563 dev = mlxsw_sp->router->rifs[rif]->dev;
1564 n = neigh_lookup(&nd_tbl, &dip, dev);
1566 netdev_err(dev, "Failed to find matching neighbour for IP=%pI6c\n",
1571 netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
1572 neigh_event_send(n, NULL);
1576 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1583 static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1590 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1592 /* Hardware starts counting at 0, so add 1. */
1595 /* Each record consists of several neighbour entries. */
1596 for (i = 0; i < num_entries; i++) {
1599 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
1600 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
1606 static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1610 /* One record contains one entry. */
1611 mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
1615 static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
1616 char *rauhtd_pl, int rec_index)
1618 switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
1619 case MLXSW_REG_RAUHTD_TYPE_IPV4:
1620 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
1623 case MLXSW_REG_RAUHTD_TYPE_IPV6:
1624 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
1630 static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
1632 u8 num_rec, last_rec_index, num_entries;
1634 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1635 last_rec_index = num_rec - 1;
1637 if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
1639 if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
1640 MLXSW_REG_RAUHTD_TYPE_IPV6)
1643 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1645 if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
1651 __mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
1653 enum mlxsw_reg_rauhtd_type type)
1658 /* Make sure the neighbour's netdev isn't removed in the
1663 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
1664 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
1667 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour talbe\n");
1670 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1671 for (i = 0; i < num_rec; i++)
1672 mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
1674 } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
1680 static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
1682 enum mlxsw_reg_rauhtd_type type;
1686 rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
1690 type = MLXSW_REG_RAUHTD_TYPE_IPV4;
1691 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1695 type = MLXSW_REG_RAUHTD_TYPE_IPV6;
1696 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1702 static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
1704 struct mlxsw_sp_neigh_entry *neigh_entry;
1706 /* Take RTNL mutex here to prevent lists from changes */
1708 list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
1709 nexthop_neighs_list_node)
1710 /* If this neigh have nexthops, make the kernel think this neigh
1711 * is active regardless of the traffic.
1713 neigh_event_send(neigh_entry->key.n, NULL);
1718 mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
1720 unsigned long interval = mlxsw_sp->router->neighs_update.interval;
1722 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
1723 msecs_to_jiffies(interval));
1726 static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
1728 struct mlxsw_sp_router *router;
1731 router = container_of(work, struct mlxsw_sp_router,
1732 neighs_update.dw.work);
1733 err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
1735 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
1737 mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
1739 mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
1742 static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
1744 struct mlxsw_sp_neigh_entry *neigh_entry;
1745 struct mlxsw_sp_router *router;
1747 router = container_of(work, struct mlxsw_sp_router,
1748 nexthop_probe_dw.work);
1749 /* Iterate over nexthop neighbours, find those who are unresolved and
1750 * send arp on them. This solves the chicken-egg problem when
1751 * the nexthop wouldn't get offloaded until the neighbor is resolved
1752 * but it wouldn't get resolved ever in case traffic is flowing in HW
1753 * using different nexthop.
1755 * Take RTNL mutex here to prevent lists from changes.
1758 list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
1759 nexthop_neighs_list_node)
1760 if (!neigh_entry->connected)
1761 neigh_event_send(neigh_entry->key.n, NULL);
1764 mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
1765 MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
1769 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
1770 struct mlxsw_sp_neigh_entry *neigh_entry,
1773 static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
1775 return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
1776 MLXSW_REG_RAUHT_OP_WRITE_DELETE;
1780 mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
1781 struct mlxsw_sp_neigh_entry *neigh_entry,
1782 enum mlxsw_reg_rauht_op op)
1784 struct neighbour *n = neigh_entry->key.n;
1785 u32 dip = ntohl(*((__be32 *) n->primary_key));
1786 char rauht_pl[MLXSW_REG_RAUHT_LEN];
1788 mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1790 if (neigh_entry->counter_valid)
1791 mlxsw_reg_rauht_pack_counter(rauht_pl,
1792 neigh_entry->counter_index);
1793 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1797 mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
1798 struct mlxsw_sp_neigh_entry *neigh_entry,
1799 enum mlxsw_reg_rauht_op op)
1801 struct neighbour *n = neigh_entry->key.n;
1802 char rauht_pl[MLXSW_REG_RAUHT_LEN];
1803 const char *dip = n->primary_key;
1805 mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1807 if (neigh_entry->counter_valid)
1808 mlxsw_reg_rauht_pack_counter(rauht_pl,
1809 neigh_entry->counter_index);
1810 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1813 bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry)
1815 struct neighbour *n = neigh_entry->key.n;
1817 /* Packets with a link-local destination address are trapped
1818 * after LPM lookup and never reach the neighbour table, so
1819 * there is no need to program such neighbours to the device.
1821 if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
1822 IPV6_ADDR_LINKLOCAL)
1828 mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
1829 struct mlxsw_sp_neigh_entry *neigh_entry,
1832 if (!adding && !neigh_entry->connected)
1834 neigh_entry->connected = adding;
1835 if (neigh_entry->key.n->tbl->family == AF_INET) {
1836 mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
1837 mlxsw_sp_rauht_op(adding));
1838 } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
1839 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry))
1841 mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
1842 mlxsw_sp_rauht_op(adding));
1849 mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp,
1850 struct mlxsw_sp_neigh_entry *neigh_entry,
1854 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
1856 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
1857 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true);
1860 struct mlxsw_sp_neigh_event_work {
1861 struct work_struct work;
1862 struct mlxsw_sp *mlxsw_sp;
1863 struct neighbour *n;
1866 static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
1868 struct mlxsw_sp_neigh_event_work *neigh_work =
1869 container_of(work, struct mlxsw_sp_neigh_event_work, work);
1870 struct mlxsw_sp *mlxsw_sp = neigh_work->mlxsw_sp;
1871 struct mlxsw_sp_neigh_entry *neigh_entry;
1872 struct neighbour *n = neigh_work->n;
1873 unsigned char ha[ETH_ALEN];
1874 bool entry_connected;
1877 /* If these parameters are changed after we release the lock,
1878 * then we are guaranteed to receive another event letting us
1881 read_lock_bh(&n->lock);
1882 memcpy(ha, n->ha, ETH_ALEN);
1883 nud_state = n->nud_state;
1885 read_unlock_bh(&n->lock);
1888 entry_connected = nud_state & NUD_VALID && !dead;
1889 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
1890 if (!entry_connected && !neigh_entry)
1893 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
1894 if (IS_ERR(neigh_entry))
1898 memcpy(neigh_entry->ha, ha, ETH_ALEN);
1899 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
1900 mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected);
1902 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
1903 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
1911 int mlxsw_sp_router_netevent_event(struct notifier_block *unused,
1912 unsigned long event, void *ptr)
1914 struct mlxsw_sp_neigh_event_work *neigh_work;
1915 struct mlxsw_sp_port *mlxsw_sp_port;
1916 struct mlxsw_sp *mlxsw_sp;
1917 unsigned long interval;
1918 struct neigh_parms *p;
1919 struct neighbour *n;
1922 case NETEVENT_DELAY_PROBE_TIME_UPDATE:
1925 /* We don't care about changes in the default table. */
1926 if (!p->dev || (p->tbl->family != AF_INET &&
1927 p->tbl->family != AF_INET6))
1930 /* We are in atomic context and can't take RTNL mutex,
1931 * so use RCU variant to walk the device chain.
1933 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(p->dev);
1937 mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1938 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
1939 mlxsw_sp->router->neighs_update.interval = interval;
1941 mlxsw_sp_port_dev_put(mlxsw_sp_port);
1943 case NETEVENT_NEIGH_UPDATE:
1946 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
1949 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(n->dev);
1953 neigh_work = kzalloc(sizeof(*neigh_work), GFP_ATOMIC);
1955 mlxsw_sp_port_dev_put(mlxsw_sp_port);
1959 INIT_WORK(&neigh_work->work, mlxsw_sp_router_neigh_event_work);
1960 neigh_work->mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1963 /* Take a reference to ensure the neighbour won't be
1964 * destructed until we drop the reference in delayed
1968 mlxsw_core_schedule_work(&neigh_work->work);
1969 mlxsw_sp_port_dev_put(mlxsw_sp_port);
1976 static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
1980 err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
1981 &mlxsw_sp_neigh_ht_params);
1985 /* Initialize the polling interval according to the default
1988 mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
1990 /* Create the delayed works for the activity_update */
1991 INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
1992 mlxsw_sp_router_neighs_update_work);
1993 INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
1994 mlxsw_sp_router_probe_unresolved_nexthops);
1995 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
1996 mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
2000 static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
2002 cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
2003 cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
2004 rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
2007 static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
2008 struct mlxsw_sp_rif *rif)
2010 struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
2012 list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
2014 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
2015 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2019 enum mlxsw_sp_nexthop_type {
2020 MLXSW_SP_NEXTHOP_TYPE_ETH,
2021 MLXSW_SP_NEXTHOP_TYPE_IPIP,
2024 struct mlxsw_sp_nexthop_key {
2025 struct fib_nh *fib_nh;
2028 struct mlxsw_sp_nexthop {
2029 struct list_head neigh_list_node; /* member of neigh entry list */
2030 struct list_head rif_list_node;
2031 struct mlxsw_sp_nexthop_group *nh_grp; /* pointer back to the group
2034 struct rhash_head ht_node;
2035 struct mlxsw_sp_nexthop_key key;
2036 unsigned char gw_addr[sizeof(struct in6_addr)];
2038 struct mlxsw_sp_rif *rif;
2039 u8 should_offload:1, /* set indicates this neigh is connected and
2040 * should be put to KVD linear area of this group.
2042 offloaded:1, /* set in case the neigh is actually put into
2043 * KVD linear area of this group.
2045 update:1; /* set indicates that MAC of this neigh should be
2048 enum mlxsw_sp_nexthop_type type;
2050 struct mlxsw_sp_neigh_entry *neigh_entry;
2051 struct mlxsw_sp_ipip_entry *ipip_entry;
2055 struct mlxsw_sp_nexthop_group {
2057 struct rhash_head ht_node;
2058 struct list_head fib_list; /* list of fib entries that use this group */
2059 struct neigh_table *neigh_tbl;
2060 u8 adj_index_valid:1,
2061 gateway:1; /* routes using the group use a gateway */
2065 struct mlxsw_sp_nexthop nexthops[0];
2066 #define nh_rif nexthops[0].rif
2069 static struct fib_info *
2070 mlxsw_sp_nexthop4_group_fi(const struct mlxsw_sp_nexthop_group *nh_grp)
2072 return nh_grp->priv;
2075 struct mlxsw_sp_nexthop_group_cmp_arg {
2076 enum mlxsw_sp_l3proto proto;
2078 struct fib_info *fi;
2079 struct mlxsw_sp_fib6_entry *fib6_entry;
2084 mlxsw_sp_nexthop6_group_has_nexthop(const struct mlxsw_sp_nexthop_group *nh_grp,
2085 const struct in6_addr *gw, int ifindex)
2089 for (i = 0; i < nh_grp->count; i++) {
2090 const struct mlxsw_sp_nexthop *nh;
2092 nh = &nh_grp->nexthops[i];
2093 if (nh->ifindex == ifindex &&
2094 ipv6_addr_equal(gw, (struct in6_addr *) nh->gw_addr))
2102 mlxsw_sp_nexthop6_group_cmp(const struct mlxsw_sp_nexthop_group *nh_grp,
2103 const struct mlxsw_sp_fib6_entry *fib6_entry)
2105 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2107 if (nh_grp->count != fib6_entry->nrt6)
2110 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2111 struct in6_addr *gw;
2114 ifindex = mlxsw_sp_rt6->rt->dst.dev->ifindex;
2115 gw = &mlxsw_sp_rt6->rt->rt6i_gateway;
2116 if (!mlxsw_sp_nexthop6_group_has_nexthop(nh_grp, gw, ifindex))
2124 mlxsw_sp_nexthop_group_cmp(struct rhashtable_compare_arg *arg, const void *ptr)
2126 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = arg->key;
2127 const struct mlxsw_sp_nexthop_group *nh_grp = ptr;
2129 switch (cmp_arg->proto) {
2130 case MLXSW_SP_L3_PROTO_IPV4:
2131 return cmp_arg->fi != mlxsw_sp_nexthop4_group_fi(nh_grp);
2132 case MLXSW_SP_L3_PROTO_IPV6:
2133 return !mlxsw_sp_nexthop6_group_cmp(nh_grp,
2134 cmp_arg->fib6_entry);
2142 mlxsw_sp_nexthop_group_type(const struct mlxsw_sp_nexthop_group *nh_grp)
2144 return nh_grp->neigh_tbl->family;
2147 static u32 mlxsw_sp_nexthop_group_hash_obj(const void *data, u32 len, u32 seed)
2149 const struct mlxsw_sp_nexthop_group *nh_grp = data;
2150 const struct mlxsw_sp_nexthop *nh;
2151 struct fib_info *fi;
2155 switch (mlxsw_sp_nexthop_group_type(nh_grp)) {
2157 fi = mlxsw_sp_nexthop4_group_fi(nh_grp);
2158 return jhash(&fi, sizeof(fi), seed);
2160 val = nh_grp->count;
2161 for (i = 0; i < nh_grp->count; i++) {
2162 nh = &nh_grp->nexthops[i];
2165 return jhash(&val, sizeof(val), seed);
2173 mlxsw_sp_nexthop6_group_hash(struct mlxsw_sp_fib6_entry *fib6_entry, u32 seed)
2175 unsigned int val = fib6_entry->nrt6;
2176 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2177 struct net_device *dev;
2179 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2180 dev = mlxsw_sp_rt6->rt->dst.dev;
2181 val ^= dev->ifindex;
2184 return jhash(&val, sizeof(val), seed);
2188 mlxsw_sp_nexthop_group_hash(const void *data, u32 len, u32 seed)
2190 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = data;
2192 switch (cmp_arg->proto) {
2193 case MLXSW_SP_L3_PROTO_IPV4:
2194 return jhash(&cmp_arg->fi, sizeof(cmp_arg->fi), seed);
2195 case MLXSW_SP_L3_PROTO_IPV6:
2196 return mlxsw_sp_nexthop6_group_hash(cmp_arg->fib6_entry, seed);
2203 static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
2204 .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
2205 .hashfn = mlxsw_sp_nexthop_group_hash,
2206 .obj_hashfn = mlxsw_sp_nexthop_group_hash_obj,
2207 .obj_cmpfn = mlxsw_sp_nexthop_group_cmp,
2210 static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
2211 struct mlxsw_sp_nexthop_group *nh_grp)
2213 if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2217 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
2219 mlxsw_sp_nexthop_group_ht_params);
2222 static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
2223 struct mlxsw_sp_nexthop_group *nh_grp)
2225 if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2229 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
2231 mlxsw_sp_nexthop_group_ht_params);
2234 static struct mlxsw_sp_nexthop_group *
2235 mlxsw_sp_nexthop4_group_lookup(struct mlxsw_sp *mlxsw_sp,
2236 struct fib_info *fi)
2238 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
2240 cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV4;
2242 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
2244 mlxsw_sp_nexthop_group_ht_params);
2247 static struct mlxsw_sp_nexthop_group *
2248 mlxsw_sp_nexthop6_group_lookup(struct mlxsw_sp *mlxsw_sp,
2249 struct mlxsw_sp_fib6_entry *fib6_entry)
2251 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
2253 cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV6;
2254 cmp_arg.fib6_entry = fib6_entry;
2255 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
2257 mlxsw_sp_nexthop_group_ht_params);
2260 static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
2261 .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
2262 .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
2263 .key_len = sizeof(struct mlxsw_sp_nexthop_key),
2266 static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
2267 struct mlxsw_sp_nexthop *nh)
2269 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
2270 &nh->ht_node, mlxsw_sp_nexthop_ht_params);
2273 static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
2274 struct mlxsw_sp_nexthop *nh)
2276 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
2277 mlxsw_sp_nexthop_ht_params);
2280 static struct mlxsw_sp_nexthop *
2281 mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
2282 struct mlxsw_sp_nexthop_key key)
2284 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
2285 mlxsw_sp_nexthop_ht_params);
2288 static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
2289 const struct mlxsw_sp_fib *fib,
2290 u32 adj_index, u16 ecmp_size,
2294 char raleu_pl[MLXSW_REG_RALEU_LEN];
2296 mlxsw_reg_raleu_pack(raleu_pl,
2297 (enum mlxsw_reg_ralxx_protocol) fib->proto,
2298 fib->vr->id, adj_index, ecmp_size, new_adj_index,
2300 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
2303 static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
2304 struct mlxsw_sp_nexthop_group *nh_grp,
2305 u32 old_adj_index, u16 old_ecmp_size)
2307 struct mlxsw_sp_fib_entry *fib_entry;
2308 struct mlxsw_sp_fib *fib = NULL;
2311 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
2312 if (fib == fib_entry->fib_node->fib)
2314 fib = fib_entry->fib_node->fib;
2315 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, fib,
2326 static int mlxsw_sp_nexthop_mac_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
2327 struct mlxsw_sp_nexthop *nh)
2329 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
2330 char ratr_pl[MLXSW_REG_RATR_LEN];
2332 mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY,
2333 true, MLXSW_REG_RATR_TYPE_ETHERNET,
2334 adj_index, neigh_entry->rif);
2335 mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
2336 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
2339 static int mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
2341 struct mlxsw_sp_nexthop *nh)
2343 const struct mlxsw_sp_ipip_ops *ipip_ops;
2345 ipip_ops = mlxsw_sp->router->ipip_ops_arr[nh->ipip_entry->ipipt];
2346 return ipip_ops->nexthop_update(mlxsw_sp, adj_index, nh->ipip_entry);
2350 mlxsw_sp_nexthop_group_update(struct mlxsw_sp *mlxsw_sp,
2351 struct mlxsw_sp_nexthop_group *nh_grp,
2354 u32 adj_index = nh_grp->adj_index; /* base */
2355 struct mlxsw_sp_nexthop *nh;
2359 for (i = 0; i < nh_grp->count; i++) {
2360 nh = &nh_grp->nexthops[i];
2362 if (!nh->should_offload) {
2367 if (nh->update || reallocate) {
2369 case MLXSW_SP_NEXTHOP_TYPE_ETH:
2370 err = mlxsw_sp_nexthop_mac_update
2371 (mlxsw_sp, adj_index, nh);
2373 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
2374 err = mlxsw_sp_nexthop_ipip_update
2375 (mlxsw_sp, adj_index, nh);
2389 mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
2390 const struct mlxsw_sp_fib_entry *fib_entry);
2393 mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
2394 struct mlxsw_sp_nexthop_group *nh_grp)
2396 struct mlxsw_sp_fib_entry *fib_entry;
2399 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
2400 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
2403 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2411 mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
2412 enum mlxsw_reg_ralue_op op, int err);
2415 mlxsw_sp_nexthop_fib_entries_refresh(struct mlxsw_sp_nexthop_group *nh_grp)
2417 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_WRITE;
2418 struct mlxsw_sp_fib_entry *fib_entry;
2420 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
2421 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
2424 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
2429 mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
2430 struct mlxsw_sp_nexthop_group *nh_grp)
2432 struct mlxsw_sp_nexthop *nh;
2433 bool offload_change = false;
2436 bool old_adj_index_valid;
2442 if (!nh_grp->gateway) {
2443 mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2447 for (i = 0; i < nh_grp->count; i++) {
2448 nh = &nh_grp->nexthops[i];
2450 if (nh->should_offload != nh->offloaded) {
2451 offload_change = true;
2452 if (nh->should_offload)
2455 if (nh->should_offload)
2458 if (!offload_change) {
2459 /* Nothing was added or removed, so no need to reallocate. Just
2460 * update MAC on existing adjacency indexes.
2462 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, false);
2464 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
2470 /* No neigh of this group is connected so we just set
2471 * the trap and let everthing flow through kernel.
2475 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, ecmp_size, &adj_index);
2477 /* We ran out of KVD linear space, just set the
2478 * trap and let everything flow through kernel.
2480 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
2483 old_adj_index_valid = nh_grp->adj_index_valid;
2484 old_adj_index = nh_grp->adj_index;
2485 old_ecmp_size = nh_grp->ecmp_size;
2486 nh_grp->adj_index_valid = 1;
2487 nh_grp->adj_index = adj_index;
2488 nh_grp->ecmp_size = ecmp_size;
2489 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, true);
2491 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
2495 if (!old_adj_index_valid) {
2496 /* The trap was set for fib entries, so we have to call
2497 * fib entry update to unset it and use adjacency index.
2499 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2501 dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
2507 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
2508 old_adj_index, old_ecmp_size);
2509 mlxsw_sp_kvdl_free(mlxsw_sp, old_adj_index);
2511 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
2515 /* Offload state within the group changed, so update the flags. */
2516 mlxsw_sp_nexthop_fib_entries_refresh(nh_grp);
2521 old_adj_index_valid = nh_grp->adj_index_valid;
2522 nh_grp->adj_index_valid = 0;
2523 for (i = 0; i < nh_grp->count; i++) {
2524 nh = &nh_grp->nexthops[i];
2527 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2529 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
2530 if (old_adj_index_valid)
2531 mlxsw_sp_kvdl_free(mlxsw_sp, nh_grp->adj_index);
2534 static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
2538 nh->should_offload = 1;
2539 else if (nh->offloaded)
2540 nh->should_offload = 0;
2545 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
2546 struct mlxsw_sp_neigh_entry *neigh_entry,
2549 struct mlxsw_sp_nexthop *nh;
2551 list_for_each_entry(nh, &neigh_entry->nexthop_list,
2553 __mlxsw_sp_nexthop_neigh_update(nh, removing);
2554 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2558 static void mlxsw_sp_nexthop_rif_init(struct mlxsw_sp_nexthop *nh,
2559 struct mlxsw_sp_rif *rif)
2565 list_add(&nh->rif_list_node, &rif->nexthop_list);
2568 static void mlxsw_sp_nexthop_rif_fini(struct mlxsw_sp_nexthop *nh)
2573 list_del(&nh->rif_list_node);
2577 static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
2578 struct mlxsw_sp_nexthop *nh)
2580 struct mlxsw_sp_neigh_entry *neigh_entry;
2581 struct neighbour *n;
2585 if (!nh->nh_grp->gateway || nh->neigh_entry)
2588 /* Take a reference of neigh here ensuring that neigh would
2589 * not be destructed before the nexthop entry is finished.
2590 * The reference is taken either in neigh_lookup() or
2591 * in neigh_create() in case n is not found.
2593 n = neigh_lookup(nh->nh_grp->neigh_tbl, &nh->gw_addr, nh->rif->dev);
2595 n = neigh_create(nh->nh_grp->neigh_tbl, &nh->gw_addr,
2599 neigh_event_send(n, NULL);
2601 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
2603 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
2604 if (IS_ERR(neigh_entry)) {
2606 goto err_neigh_entry_create;
2610 /* If that is the first nexthop connected to that neigh, add to
2611 * nexthop_neighs_list
2613 if (list_empty(&neigh_entry->nexthop_list))
2614 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
2615 &mlxsw_sp->router->nexthop_neighs_list);
2617 nh->neigh_entry = neigh_entry;
2618 list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
2619 read_lock_bh(&n->lock);
2620 nud_state = n->nud_state;
2622 read_unlock_bh(&n->lock);
2623 __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
2627 err_neigh_entry_create:
2632 static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
2633 struct mlxsw_sp_nexthop *nh)
2635 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
2636 struct neighbour *n;
2640 n = neigh_entry->key.n;
2642 __mlxsw_sp_nexthop_neigh_update(nh, true);
2643 list_del(&nh->neigh_list_node);
2644 nh->neigh_entry = NULL;
2646 /* If that is the last nexthop connected to that neigh, remove from
2647 * nexthop_neighs_list
2649 if (list_empty(&neigh_entry->nexthop_list))
2650 list_del(&neigh_entry->nexthop_neighs_list_node);
2652 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
2653 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2658 static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp,
2659 const struct net_device *dev,
2660 enum mlxsw_sp_ipip_type *p_type)
2662 struct mlxsw_sp_router *router = mlxsw_sp->router;
2663 const struct mlxsw_sp_ipip_ops *ipip_ops;
2664 enum mlxsw_sp_ipip_type ipipt;
2666 for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) {
2667 ipip_ops = router->ipip_ops_arr[ipipt];
2668 if (dev->type == ipip_ops->dev_type) {
2677 static int mlxsw_sp_nexthop_ipip_init(struct mlxsw_sp *mlxsw_sp,
2678 enum mlxsw_sp_ipip_type ipipt,
2679 struct mlxsw_sp_nexthop *nh,
2680 struct net_device *ol_dev)
2682 if (!nh->nh_grp->gateway || nh->ipip_entry)
2685 nh->ipip_entry = mlxsw_sp_ipip_entry_get(mlxsw_sp, ipipt, ol_dev);
2686 if (IS_ERR(nh->ipip_entry))
2687 return PTR_ERR(nh->ipip_entry);
2689 __mlxsw_sp_nexthop_neigh_update(nh, false);
2693 static void mlxsw_sp_nexthop_ipip_fini(struct mlxsw_sp *mlxsw_sp,
2694 struct mlxsw_sp_nexthop *nh)
2696 struct mlxsw_sp_ipip_entry *ipip_entry = nh->ipip_entry;
2701 __mlxsw_sp_nexthop_neigh_update(nh, true);
2702 mlxsw_sp_ipip_entry_put(mlxsw_sp, ipip_entry);
2703 nh->ipip_entry = NULL;
2706 static bool mlxsw_sp_nexthop4_ipip_type(const struct mlxsw_sp *mlxsw_sp,
2707 const struct fib_nh *fib_nh,
2708 enum mlxsw_sp_ipip_type *p_ipipt)
2710 struct net_device *dev = fib_nh->nh_dev;
2713 fib_nh->nh_parent->fib_type == RTN_UNICAST &&
2714 mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, p_ipipt);
2717 static void mlxsw_sp_nexthop_type_fini(struct mlxsw_sp *mlxsw_sp,
2718 struct mlxsw_sp_nexthop *nh)
2721 case MLXSW_SP_NEXTHOP_TYPE_ETH:
2722 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
2723 mlxsw_sp_nexthop_rif_fini(nh);
2725 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
2726 mlxsw_sp_nexthop_rif_fini(nh);
2727 mlxsw_sp_nexthop_ipip_fini(mlxsw_sp, nh);
2732 static int mlxsw_sp_nexthop4_type_init(struct mlxsw_sp *mlxsw_sp,
2733 struct mlxsw_sp_nexthop *nh,
2734 struct fib_nh *fib_nh)
2736 struct mlxsw_sp_router *router = mlxsw_sp->router;
2737 struct net_device *dev = fib_nh->nh_dev;
2738 enum mlxsw_sp_ipip_type ipipt;
2739 struct mlxsw_sp_rif *rif;
2742 if (mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, fib_nh, &ipipt) &&
2743 router->ipip_ops_arr[ipipt]->can_offload(mlxsw_sp, dev,
2744 MLXSW_SP_L3_PROTO_IPV4)) {
2745 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
2746 err = mlxsw_sp_nexthop_ipip_init(mlxsw_sp, ipipt, nh, dev);
2749 mlxsw_sp_nexthop_rif_init(nh, &nh->ipip_entry->ol_lb->common);
2753 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
2754 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
2758 mlxsw_sp_nexthop_rif_init(nh, rif);
2759 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
2761 goto err_neigh_init;
2766 mlxsw_sp_nexthop_rif_fini(nh);
2770 static void mlxsw_sp_nexthop4_type_fini(struct mlxsw_sp *mlxsw_sp,
2771 struct mlxsw_sp_nexthop *nh)
2773 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
2776 static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
2777 struct mlxsw_sp_nexthop_group *nh_grp,
2778 struct mlxsw_sp_nexthop *nh,
2779 struct fib_nh *fib_nh)
2781 struct net_device *dev = fib_nh->nh_dev;
2782 struct in_device *in_dev;
2785 nh->nh_grp = nh_grp;
2786 nh->key.fib_nh = fib_nh;
2787 memcpy(&nh->gw_addr, &fib_nh->nh_gw, sizeof(fib_nh->nh_gw));
2788 err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
2795 in_dev = __in_dev_get_rtnl(dev);
2796 if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
2797 fib_nh->nh_flags & RTNH_F_LINKDOWN)
2800 err = mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
2802 goto err_nexthop_neigh_init;
2806 err_nexthop_neigh_init:
2807 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
2811 static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
2812 struct mlxsw_sp_nexthop *nh)
2814 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
2815 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
2818 static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
2819 unsigned long event, struct fib_nh *fib_nh)
2821 struct mlxsw_sp_nexthop_key key;
2822 struct mlxsw_sp_nexthop *nh;
2824 if (mlxsw_sp->router->aborted)
2827 key.fib_nh = fib_nh;
2828 nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
2829 if (WARN_ON_ONCE(!nh))
2833 case FIB_EVENT_NH_ADD:
2834 mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
2836 case FIB_EVENT_NH_DEL:
2837 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
2841 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2844 static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
2845 struct mlxsw_sp_rif *rif)
2847 struct mlxsw_sp_nexthop *nh, *tmp;
2849 list_for_each_entry_safe(nh, tmp, &rif->nexthop_list, rif_list_node) {
2850 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
2851 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2855 static bool mlxsw_sp_fi_is_gateway(const struct mlxsw_sp *mlxsw_sp,
2856 const struct fib_info *fi)
2858 return fi->fib_nh->nh_scope == RT_SCOPE_LINK ||
2859 mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, fi->fib_nh, NULL);
2862 static struct mlxsw_sp_nexthop_group *
2863 mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
2865 struct mlxsw_sp_nexthop_group *nh_grp;
2866 struct mlxsw_sp_nexthop *nh;
2867 struct fib_nh *fib_nh;
2872 alloc_size = sizeof(*nh_grp) +
2873 fi->fib_nhs * sizeof(struct mlxsw_sp_nexthop);
2874 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
2876 return ERR_PTR(-ENOMEM);
2878 INIT_LIST_HEAD(&nh_grp->fib_list);
2879 nh_grp->neigh_tbl = &arp_tbl;
2881 nh_grp->gateway = mlxsw_sp_fi_is_gateway(mlxsw_sp, fi);
2882 nh_grp->count = fi->fib_nhs;
2884 for (i = 0; i < nh_grp->count; i++) {
2885 nh = &nh_grp->nexthops[i];
2886 fib_nh = &fi->fib_nh[i];
2887 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
2889 goto err_nexthop4_init;
2891 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
2893 goto err_nexthop_group_insert;
2894 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
2897 err_nexthop_group_insert:
2899 for (i--; i >= 0; i--) {
2900 nh = &nh_grp->nexthops[i];
2901 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
2905 return ERR_PTR(err);
2909 mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
2910 struct mlxsw_sp_nexthop_group *nh_grp)
2912 struct mlxsw_sp_nexthop *nh;
2915 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
2916 for (i = 0; i < nh_grp->count; i++) {
2917 nh = &nh_grp->nexthops[i];
2918 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
2920 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
2921 WARN_ON_ONCE(nh_grp->adj_index_valid);
2922 fib_info_put(mlxsw_sp_nexthop4_group_fi(nh_grp));
2926 static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
2927 struct mlxsw_sp_fib_entry *fib_entry,
2928 struct fib_info *fi)
2930 struct mlxsw_sp_nexthop_group *nh_grp;
2932 nh_grp = mlxsw_sp_nexthop4_group_lookup(mlxsw_sp, fi);
2934 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
2936 return PTR_ERR(nh_grp);
2938 list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
2939 fib_entry->nh_group = nh_grp;
2943 static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
2944 struct mlxsw_sp_fib_entry *fib_entry)
2946 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
2948 list_del(&fib_entry->nexthop_group_node);
2949 if (!list_empty(&nh_grp->fib_list))
2951 mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
2955 mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
2957 struct mlxsw_sp_fib4_entry *fib4_entry;
2959 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
2961 return !fib4_entry->tos;
2965 mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
2967 struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
2969 switch (fib_entry->fib_node->fib->proto) {
2970 case MLXSW_SP_L3_PROTO_IPV4:
2971 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
2974 case MLXSW_SP_L3_PROTO_IPV6:
2978 switch (fib_entry->type) {
2979 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
2980 return !!nh_group->adj_index_valid;
2981 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
2982 return !!nh_group->nh_rif;
2983 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
2990 static struct mlxsw_sp_nexthop *
2991 mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
2992 const struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
2996 for (i = 0; i < nh_grp->count; i++) {
2997 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
2998 struct rt6_info *rt = mlxsw_sp_rt6->rt;
3000 if (nh->rif && nh->rif->dev == rt->dst.dev &&
3001 ipv6_addr_equal((const struct in6_addr *) &nh->gw_addr,
3011 mlxsw_sp_fib4_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3013 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3016 if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ||
3017 fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP) {
3018 nh_grp->nexthops->key.fib_nh->nh_flags |= RTNH_F_OFFLOAD;
3022 for (i = 0; i < nh_grp->count; i++) {
3023 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3026 nh->key.fib_nh->nh_flags |= RTNH_F_OFFLOAD;
3028 nh->key.fib_nh->nh_flags &= ~RTNH_F_OFFLOAD;
3033 mlxsw_sp_fib4_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3035 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3038 for (i = 0; i < nh_grp->count; i++) {
3039 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3041 nh->key.fib_nh->nh_flags &= ~RTNH_F_OFFLOAD;
3046 mlxsw_sp_fib6_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3048 struct mlxsw_sp_fib6_entry *fib6_entry;
3049 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3051 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
3054 if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL) {
3055 list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
3056 list)->rt->rt6i_nh_flags |= RTNH_F_OFFLOAD;
3060 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3061 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3062 struct mlxsw_sp_nexthop *nh;
3064 nh = mlxsw_sp_rt6_nexthop(nh_grp, mlxsw_sp_rt6);
3065 if (nh && nh->offloaded)
3066 mlxsw_sp_rt6->rt->rt6i_nh_flags |= RTNH_F_OFFLOAD;
3068 mlxsw_sp_rt6->rt->rt6i_nh_flags &= ~RTNH_F_OFFLOAD;
3073 mlxsw_sp_fib6_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3075 struct mlxsw_sp_fib6_entry *fib6_entry;
3076 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3078 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
3080 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3081 struct rt6_info *rt = mlxsw_sp_rt6->rt;
3083 rt->rt6i_nh_flags &= ~RTNH_F_OFFLOAD;
3087 static void mlxsw_sp_fib_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3089 switch (fib_entry->fib_node->fib->proto) {
3090 case MLXSW_SP_L3_PROTO_IPV4:
3091 mlxsw_sp_fib4_entry_offload_set(fib_entry);
3093 case MLXSW_SP_L3_PROTO_IPV6:
3094 mlxsw_sp_fib6_entry_offload_set(fib_entry);
3100 mlxsw_sp_fib_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3102 switch (fib_entry->fib_node->fib->proto) {
3103 case MLXSW_SP_L3_PROTO_IPV4:
3104 mlxsw_sp_fib4_entry_offload_unset(fib_entry);
3106 case MLXSW_SP_L3_PROTO_IPV6:
3107 mlxsw_sp_fib6_entry_offload_unset(fib_entry);
3113 mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
3114 enum mlxsw_reg_ralue_op op, int err)
3117 case MLXSW_REG_RALUE_OP_WRITE_DELETE:
3118 return mlxsw_sp_fib_entry_offload_unset(fib_entry);
3119 case MLXSW_REG_RALUE_OP_WRITE_WRITE:
3122 if (mlxsw_sp_fib_entry_should_offload(fib_entry))
3123 mlxsw_sp_fib_entry_offload_set(fib_entry);
3124 else if (!mlxsw_sp_fib_entry_should_offload(fib_entry))
3125 mlxsw_sp_fib_entry_offload_unset(fib_entry);
3133 mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
3134 const struct mlxsw_sp_fib_entry *fib_entry,
3135 enum mlxsw_reg_ralue_op op)
3137 struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
3138 enum mlxsw_reg_ralxx_protocol proto;
3141 proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
3143 switch (fib->proto) {
3144 case MLXSW_SP_L3_PROTO_IPV4:
3145 p_dip = (u32 *) fib_entry->fib_node->key.addr;
3146 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
3147 fib_entry->fib_node->key.prefix_len,
3150 case MLXSW_SP_L3_PROTO_IPV6:
3151 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
3152 fib_entry->fib_node->key.prefix_len,
3153 fib_entry->fib_node->key.addr);
3158 static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
3159 struct mlxsw_sp_fib_entry *fib_entry,
3160 enum mlxsw_reg_ralue_op op)
3162 char ralue_pl[MLXSW_REG_RALUE_LEN];
3163 enum mlxsw_reg_ralue_trap_action trap_action;
3165 u32 adjacency_index = 0;
3168 /* In case the nexthop group adjacency index is valid, use it
3169 * with provided ECMP size. Otherwise, setup trap and pass
3170 * traffic to kernel.
3172 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
3173 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
3174 adjacency_index = fib_entry->nh_group->adj_index;
3175 ecmp_size = fib_entry->nh_group->ecmp_size;
3177 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
3178 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
3181 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
3182 mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
3183 adjacency_index, ecmp_size);
3184 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3187 static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
3188 struct mlxsw_sp_fib_entry *fib_entry,
3189 enum mlxsw_reg_ralue_op op)
3191 struct mlxsw_sp_rif *rif = fib_entry->nh_group->nh_rif;
3192 enum mlxsw_reg_ralue_trap_action trap_action;
3193 char ralue_pl[MLXSW_REG_RALUE_LEN];
3197 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
3198 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
3199 rif_index = rif->rif_index;
3201 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
3202 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
3205 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
3206 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
3208 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3211 static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
3212 struct mlxsw_sp_fib_entry *fib_entry,
3213 enum mlxsw_reg_ralue_op op)
3215 char ralue_pl[MLXSW_REG_RALUE_LEN];
3217 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
3218 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
3219 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3223 mlxsw_sp_fib_entry_op_ipip_decap(struct mlxsw_sp *mlxsw_sp,
3224 struct mlxsw_sp_fib_entry *fib_entry,
3225 enum mlxsw_reg_ralue_op op)
3227 struct mlxsw_sp_ipip_entry *ipip_entry = fib_entry->decap.ipip_entry;
3228 const struct mlxsw_sp_ipip_ops *ipip_ops;
3230 if (WARN_ON(!ipip_entry))
3233 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
3234 return ipip_ops->fib_entry_op(mlxsw_sp, ipip_entry, op,
3235 fib_entry->decap.tunnel_index);
3238 static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
3239 struct mlxsw_sp_fib_entry *fib_entry,
3240 enum mlxsw_reg_ralue_op op)
3242 switch (fib_entry->type) {
3243 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
3244 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
3245 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
3246 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
3247 case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
3248 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
3249 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
3250 return mlxsw_sp_fib_entry_op_ipip_decap(mlxsw_sp,
3256 static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
3257 struct mlxsw_sp_fib_entry *fib_entry,
3258 enum mlxsw_reg_ralue_op op)
3260 int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
3262 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, err);
3267 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
3268 struct mlxsw_sp_fib_entry *fib_entry)
3270 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
3271 MLXSW_REG_RALUE_OP_WRITE_WRITE);
3274 static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
3275 struct mlxsw_sp_fib_entry *fib_entry)
3277 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
3278 MLXSW_REG_RALUE_OP_WRITE_DELETE);
3282 mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
3283 const struct fib_entry_notifier_info *fen_info,
3284 struct mlxsw_sp_fib_entry *fib_entry)
3286 union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };
3287 struct net_device *dev = fen_info->fi->fib_dev;
3288 struct mlxsw_sp_ipip_entry *ipip_entry;
3289 struct fib_info *fi = fen_info->fi;
3291 switch (fen_info->type) {
3293 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, dev,
3294 MLXSW_SP_L3_PROTO_IPV4, dip);
3296 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
3297 return mlxsw_sp_fib_entry_decap_init(mlxsw_sp,
3303 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
3305 case RTN_UNREACHABLE: /* fall through */
3306 case RTN_BLACKHOLE: /* fall through */
3308 /* Packets hitting these routes need to be trapped, but
3309 * can do so with a lower priority than packets directed
3310 * at the host, so use action type local instead of trap.
3312 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
3315 if (mlxsw_sp_fi_is_gateway(mlxsw_sp, fi))
3316 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
3318 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
3325 static struct mlxsw_sp_fib4_entry *
3326 mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
3327 struct mlxsw_sp_fib_node *fib_node,
3328 const struct fib_entry_notifier_info *fen_info)
3330 struct mlxsw_sp_fib4_entry *fib4_entry;
3331 struct mlxsw_sp_fib_entry *fib_entry;
3334 fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
3336 return ERR_PTR(-ENOMEM);
3337 fib_entry = &fib4_entry->common;
3339 err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
3341 goto err_fib4_entry_type_set;
3343 err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
3345 goto err_nexthop4_group_get;
3347 fib4_entry->prio = fen_info->fi->fib_priority;
3348 fib4_entry->tb_id = fen_info->tb_id;
3349 fib4_entry->type = fen_info->type;
3350 fib4_entry->tos = fen_info->tos;
3352 fib_entry->fib_node = fib_node;
3356 err_nexthop4_group_get:
3357 err_fib4_entry_type_set:
3359 return ERR_PTR(err);
3362 static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
3363 struct mlxsw_sp_fib4_entry *fib4_entry)
3365 mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
3369 static struct mlxsw_sp_fib4_entry *
3370 mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
3371 const struct fib_entry_notifier_info *fen_info)
3373 struct mlxsw_sp_fib4_entry *fib4_entry;
3374 struct mlxsw_sp_fib_node *fib_node;
3375 struct mlxsw_sp_fib *fib;
3376 struct mlxsw_sp_vr *vr;
3378 vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
3381 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
3383 fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
3384 sizeof(fen_info->dst),
3389 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
3390 if (fib4_entry->tb_id == fen_info->tb_id &&
3391 fib4_entry->tos == fen_info->tos &&
3392 fib4_entry->type == fen_info->type &&
3393 mlxsw_sp_nexthop4_group_fi(fib4_entry->common.nh_group) ==
3402 static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
3403 .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
3404 .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
3405 .key_len = sizeof(struct mlxsw_sp_fib_key),
3406 .automatic_shrinking = true,
3409 static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
3410 struct mlxsw_sp_fib_node *fib_node)
3412 return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
3413 mlxsw_sp_fib_ht_params);
3416 static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
3417 struct mlxsw_sp_fib_node *fib_node)
3419 rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
3420 mlxsw_sp_fib_ht_params);
3423 static struct mlxsw_sp_fib_node *
3424 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
3425 size_t addr_len, unsigned char prefix_len)
3427 struct mlxsw_sp_fib_key key;
3429 memset(&key, 0, sizeof(key));
3430 memcpy(key.addr, addr, addr_len);
3431 key.prefix_len = prefix_len;
3432 return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
3435 static struct mlxsw_sp_fib_node *
3436 mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
3437 size_t addr_len, unsigned char prefix_len)
3439 struct mlxsw_sp_fib_node *fib_node;
3441 fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
3445 INIT_LIST_HEAD(&fib_node->entry_list);
3446 list_add(&fib_node->list, &fib->node_list);
3447 memcpy(fib_node->key.addr, addr, addr_len);
3448 fib_node->key.prefix_len = prefix_len;
3453 static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
3455 list_del(&fib_node->list);
3456 WARN_ON(!list_empty(&fib_node->entry_list));
3461 mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
3462 const struct mlxsw_sp_fib_entry *fib_entry)
3464 return list_first_entry(&fib_node->entry_list,
3465 struct mlxsw_sp_fib_entry, list) == fib_entry;
3468 static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp,
3469 struct mlxsw_sp_fib *fib,
3470 struct mlxsw_sp_fib_node *fib_node)
3472 struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
3473 struct mlxsw_sp_lpm_tree *lpm_tree;
3476 /* Since the tree is shared between all virtual routers we must
3477 * make sure it contains all the required prefix lengths. This
3478 * can be computed by either adding the new prefix length to the
3479 * existing prefix usage of a bound tree, or by aggregating the
3480 * prefix lengths across all virtual routers and adding the new
3484 mlxsw_sp_prefix_usage_cpy(&req_prefix_usage,
3485 &fib->lpm_tree->prefix_usage);
3487 mlxsw_sp_vrs_prefixes(mlxsw_sp, fib->proto, &req_prefix_usage);
3488 mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
3490 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
3492 if (IS_ERR(lpm_tree))
3493 return PTR_ERR(lpm_tree);
3495 if (fib->lpm_tree && fib->lpm_tree->id == lpm_tree->id)
3498 err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
3505 static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
3506 struct mlxsw_sp_fib *fib)
3508 struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
3509 struct mlxsw_sp_lpm_tree *lpm_tree;
3511 /* Aggregate prefix lengths across all virtual routers to make
3512 * sure we only have used prefix lengths in the LPM tree.
3514 mlxsw_sp_vrs_prefixes(mlxsw_sp, fib->proto, &req_prefix_usage);
3515 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
3517 if (IS_ERR(lpm_tree))
3519 mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
3522 if (!mlxsw_sp_prefix_usage_none(&fib->prefix_usage))
3524 mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
3525 mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree);
3526 fib->lpm_tree = NULL;
3529 static void mlxsw_sp_fib_node_prefix_inc(struct mlxsw_sp_fib_node *fib_node)
3531 unsigned char prefix_len = fib_node->key.prefix_len;
3532 struct mlxsw_sp_fib *fib = fib_node->fib;
3534 if (fib->prefix_ref_count[prefix_len]++ == 0)
3535 mlxsw_sp_prefix_usage_set(&fib->prefix_usage, prefix_len);
3538 static void mlxsw_sp_fib_node_prefix_dec(struct mlxsw_sp_fib_node *fib_node)
3540 unsigned char prefix_len = fib_node->key.prefix_len;
3541 struct mlxsw_sp_fib *fib = fib_node->fib;
3543 if (--fib->prefix_ref_count[prefix_len] == 0)
3544 mlxsw_sp_prefix_usage_clear(&fib->prefix_usage, prefix_len);
3547 static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
3548 struct mlxsw_sp_fib_node *fib_node,
3549 struct mlxsw_sp_fib *fib)
3553 err = mlxsw_sp_fib_node_insert(fib, fib_node);
3556 fib_node->fib = fib;
3558 err = mlxsw_sp_fib_lpm_tree_link(mlxsw_sp, fib, fib_node);
3560 goto err_fib_lpm_tree_link;
3562 mlxsw_sp_fib_node_prefix_inc(fib_node);
3566 err_fib_lpm_tree_link:
3567 fib_node->fib = NULL;
3568 mlxsw_sp_fib_node_remove(fib, fib_node);
3572 static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
3573 struct mlxsw_sp_fib_node *fib_node)
3575 struct mlxsw_sp_fib *fib = fib_node->fib;
3577 mlxsw_sp_fib_node_prefix_dec(fib_node);
3578 mlxsw_sp_fib_lpm_tree_unlink(mlxsw_sp, fib);
3579 fib_node->fib = NULL;
3580 mlxsw_sp_fib_node_remove(fib, fib_node);
3583 static struct mlxsw_sp_fib_node *
3584 mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
3585 size_t addr_len, unsigned char prefix_len,
3586 enum mlxsw_sp_l3proto proto)
3588 struct mlxsw_sp_fib_node *fib_node;
3589 struct mlxsw_sp_fib *fib;
3590 struct mlxsw_sp_vr *vr;
3593 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id);
3595 return ERR_CAST(vr);
3596 fib = mlxsw_sp_vr_fib(vr, proto);
3598 fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
3602 fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
3605 goto err_fib_node_create;
3608 err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
3610 goto err_fib_node_init;
3615 mlxsw_sp_fib_node_destroy(fib_node);
3616 err_fib_node_create:
3617 mlxsw_sp_vr_put(vr);
3618 return ERR_PTR(err);
3621 static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
3622 struct mlxsw_sp_fib_node *fib_node)
3624 struct mlxsw_sp_vr *vr = fib_node->fib->vr;
3626 if (!list_empty(&fib_node->entry_list))
3628 mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
3629 mlxsw_sp_fib_node_destroy(fib_node);
3630 mlxsw_sp_vr_put(vr);
3633 static struct mlxsw_sp_fib4_entry *
3634 mlxsw_sp_fib4_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
3635 const struct mlxsw_sp_fib4_entry *new4_entry)
3637 struct mlxsw_sp_fib4_entry *fib4_entry;
3639 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
3640 if (fib4_entry->tb_id > new4_entry->tb_id)
3642 if (fib4_entry->tb_id != new4_entry->tb_id)
3644 if (fib4_entry->tos > new4_entry->tos)
3646 if (fib4_entry->prio >= new4_entry->prio ||
3647 fib4_entry->tos < new4_entry->tos)
3655 mlxsw_sp_fib4_node_list_append(struct mlxsw_sp_fib4_entry *fib4_entry,
3656 struct mlxsw_sp_fib4_entry *new4_entry)
3658 struct mlxsw_sp_fib_node *fib_node;
3660 if (WARN_ON(!fib4_entry))
3663 fib_node = fib4_entry->common.fib_node;
3664 list_for_each_entry_from(fib4_entry, &fib_node->entry_list,
3666 if (fib4_entry->tb_id != new4_entry->tb_id ||
3667 fib4_entry->tos != new4_entry->tos ||
3668 fib4_entry->prio != new4_entry->prio)
3672 list_add_tail(&new4_entry->common.list, &fib4_entry->common.list);
3677 mlxsw_sp_fib4_node_list_insert(struct mlxsw_sp_fib4_entry *new4_entry,
3678 bool replace, bool append)
3680 struct mlxsw_sp_fib_node *fib_node = new4_entry->common.fib_node;
3681 struct mlxsw_sp_fib4_entry *fib4_entry;
3683 fib4_entry = mlxsw_sp_fib4_node_entry_find(fib_node, new4_entry);
3686 return mlxsw_sp_fib4_node_list_append(fib4_entry, new4_entry);
3687 if (replace && WARN_ON(!fib4_entry))
3690 /* Insert new entry before replaced one, so that we can later
3691 * remove the second.
3694 list_add_tail(&new4_entry->common.list,
3695 &fib4_entry->common.list);
3697 struct mlxsw_sp_fib4_entry *last;
3699 list_for_each_entry(last, &fib_node->entry_list, common.list) {
3700 if (new4_entry->tb_id > last->tb_id)
3706 list_add(&new4_entry->common.list,
3707 &fib4_entry->common.list);
3709 list_add(&new4_entry->common.list,
3710 &fib_node->entry_list);
3717 mlxsw_sp_fib4_node_list_remove(struct mlxsw_sp_fib4_entry *fib4_entry)
3719 list_del(&fib4_entry->common.list);
3722 static int mlxsw_sp_fib_node_entry_add(struct mlxsw_sp *mlxsw_sp,
3723 struct mlxsw_sp_fib_entry *fib_entry)
3725 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
3727 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
3730 /* To prevent packet loss, overwrite the previously offloaded
3733 if (!list_is_singular(&fib_node->entry_list)) {
3734 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
3735 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
3737 mlxsw_sp_fib_entry_offload_refresh(n, op, 0);
3740 return mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
3743 static void mlxsw_sp_fib_node_entry_del(struct mlxsw_sp *mlxsw_sp,
3744 struct mlxsw_sp_fib_entry *fib_entry)
3746 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
3748 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
3751 /* Promote the next entry by overwriting the deleted entry */
3752 if (!list_is_singular(&fib_node->entry_list)) {
3753 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
3754 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
3756 mlxsw_sp_fib_entry_update(mlxsw_sp, n);
3757 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
3761 mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
3764 static int mlxsw_sp_fib4_node_entry_link(struct mlxsw_sp *mlxsw_sp,
3765 struct mlxsw_sp_fib4_entry *fib4_entry,
3766 bool replace, bool append)
3770 err = mlxsw_sp_fib4_node_list_insert(fib4_entry, replace, append);
3774 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib4_entry->common);
3776 goto err_fib_node_entry_add;
3780 err_fib_node_entry_add:
3781 mlxsw_sp_fib4_node_list_remove(fib4_entry);
3786 mlxsw_sp_fib4_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
3787 struct mlxsw_sp_fib4_entry *fib4_entry)
3789 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib4_entry->common);
3790 mlxsw_sp_fib4_node_list_remove(fib4_entry);
3792 if (fib4_entry->common.type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP)
3793 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, &fib4_entry->common);
3796 static void mlxsw_sp_fib4_entry_replace(struct mlxsw_sp *mlxsw_sp,
3797 struct mlxsw_sp_fib4_entry *fib4_entry,
3800 struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
3801 struct mlxsw_sp_fib4_entry *replaced;
3806 /* We inserted the new entry before replaced one */
3807 replaced = list_next_entry(fib4_entry, common.list);
3809 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, replaced);
3810 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, replaced);
3811 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
3815 mlxsw_sp_router_fib4_add(struct mlxsw_sp *mlxsw_sp,
3816 const struct fib_entry_notifier_info *fen_info,
3817 bool replace, bool append)
3819 struct mlxsw_sp_fib4_entry *fib4_entry;
3820 struct mlxsw_sp_fib_node *fib_node;
3823 if (mlxsw_sp->router->aborted)
3826 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
3827 &fen_info->dst, sizeof(fen_info->dst),
3829 MLXSW_SP_L3_PROTO_IPV4);
3830 if (IS_ERR(fib_node)) {
3831 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
3832 return PTR_ERR(fib_node);
3835 fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
3836 if (IS_ERR(fib4_entry)) {
3837 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
3838 err = PTR_ERR(fib4_entry);
3839 goto err_fib4_entry_create;
3842 err = mlxsw_sp_fib4_node_entry_link(mlxsw_sp, fib4_entry, replace,
3845 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
3846 goto err_fib4_node_entry_link;
3849 mlxsw_sp_fib4_entry_replace(mlxsw_sp, fib4_entry, replace);
3853 err_fib4_node_entry_link:
3854 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
3855 err_fib4_entry_create:
3856 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
3860 static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
3861 struct fib_entry_notifier_info *fen_info)
3863 struct mlxsw_sp_fib4_entry *fib4_entry;
3864 struct mlxsw_sp_fib_node *fib_node;
3866 if (mlxsw_sp->router->aborted)
3869 fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
3870 if (WARN_ON(!fib4_entry))
3872 fib_node = fib4_entry->common.fib_node;
3874 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
3875 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
3876 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
3879 static bool mlxsw_sp_fib6_rt_should_ignore(const struct rt6_info *rt)
3881 /* Packets with link-local destination IP arriving to the router
3882 * are trapped to the CPU, so no need to program specific routes
3885 if (ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_LINKLOCAL)
3888 /* Multicast routes aren't supported, so ignore them. Neighbour
3889 * Discovery packets are specifically trapped.
3891 if (ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_MULTICAST)
3894 /* Cloned routes are irrelevant in the forwarding path. */
3895 if (rt->rt6i_flags & RTF_CACHE)
3901 static struct mlxsw_sp_rt6 *mlxsw_sp_rt6_create(struct rt6_info *rt)
3903 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3905 mlxsw_sp_rt6 = kzalloc(sizeof(*mlxsw_sp_rt6), GFP_KERNEL);
3907 return ERR_PTR(-ENOMEM);
3909 /* In case of route replace, replaced route is deleted with
3910 * no notification. Take reference to prevent accessing freed
3913 mlxsw_sp_rt6->rt = rt;
3916 return mlxsw_sp_rt6;
3919 #if IS_ENABLED(CONFIG_IPV6)
3920 static void mlxsw_sp_rt6_release(struct rt6_info *rt)
3925 static void mlxsw_sp_rt6_release(struct rt6_info *rt)
3930 static void mlxsw_sp_rt6_destroy(struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
3932 mlxsw_sp_rt6_release(mlxsw_sp_rt6->rt);
3933 kfree(mlxsw_sp_rt6);
3936 static bool mlxsw_sp_fib6_rt_can_mp(const struct rt6_info *rt)
3938 /* RTF_CACHE routes are ignored */
3939 return (rt->rt6i_flags & (RTF_GATEWAY | RTF_ADDRCONF)) == RTF_GATEWAY;
3942 static struct rt6_info *
3943 mlxsw_sp_fib6_entry_rt(const struct mlxsw_sp_fib6_entry *fib6_entry)
3945 return list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
3949 static struct mlxsw_sp_fib6_entry *
3950 mlxsw_sp_fib6_node_mp_entry_find(const struct mlxsw_sp_fib_node *fib_node,
3951 const struct rt6_info *nrt, bool replace)
3953 struct mlxsw_sp_fib6_entry *fib6_entry;
3955 if (!mlxsw_sp_fib6_rt_can_mp(nrt) || replace)
3958 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
3959 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
3961 /* RT6_TABLE_LOCAL and RT6_TABLE_MAIN share the same
3964 if (rt->rt6i_table->tb6_id > nrt->rt6i_table->tb6_id)
3966 if (rt->rt6i_table->tb6_id != nrt->rt6i_table->tb6_id)
3968 if (rt->rt6i_metric < nrt->rt6i_metric)
3970 if (rt->rt6i_metric == nrt->rt6i_metric &&
3971 mlxsw_sp_fib6_rt_can_mp(rt))
3973 if (rt->rt6i_metric > nrt->rt6i_metric)
3980 static struct mlxsw_sp_rt6 *
3981 mlxsw_sp_fib6_entry_rt_find(const struct mlxsw_sp_fib6_entry *fib6_entry,
3982 const struct rt6_info *rt)
3984 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3986 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3987 if (mlxsw_sp_rt6->rt == rt)
3988 return mlxsw_sp_rt6;
3994 static bool mlxsw_sp_nexthop6_ipip_type(const struct mlxsw_sp *mlxsw_sp,
3995 const struct rt6_info *rt,
3996 enum mlxsw_sp_ipip_type *ret)
3998 return rt->dst.dev &&
3999 mlxsw_sp_netdev_ipip_type(mlxsw_sp, rt->dst.dev, ret);
4002 static int mlxsw_sp_nexthop6_type_init(struct mlxsw_sp *mlxsw_sp,
4003 struct mlxsw_sp_nexthop_group *nh_grp,
4004 struct mlxsw_sp_nexthop *nh,
4005 const struct rt6_info *rt)
4007 struct mlxsw_sp_router *router = mlxsw_sp->router;
4008 struct net_device *dev = rt->dst.dev;
4009 enum mlxsw_sp_ipip_type ipipt;
4010 struct mlxsw_sp_rif *rif;
4013 if (mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, &ipipt) &&
4014 router->ipip_ops_arr[ipipt]->can_offload(mlxsw_sp, dev,
4015 MLXSW_SP_L3_PROTO_IPV6)) {
4016 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
4017 err = mlxsw_sp_nexthop_ipip_init(mlxsw_sp, ipipt, nh, dev);
4020 mlxsw_sp_nexthop_rif_init(nh, &nh->ipip_entry->ol_lb->common);
4024 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
4025 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
4028 mlxsw_sp_nexthop_rif_init(nh, rif);
4030 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
4032 goto err_nexthop_neigh_init;
4036 err_nexthop_neigh_init:
4037 mlxsw_sp_nexthop_rif_fini(nh);
4041 static void mlxsw_sp_nexthop6_type_fini(struct mlxsw_sp *mlxsw_sp,
4042 struct mlxsw_sp_nexthop *nh)
4044 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4047 static int mlxsw_sp_nexthop6_init(struct mlxsw_sp *mlxsw_sp,
4048 struct mlxsw_sp_nexthop_group *nh_grp,
4049 struct mlxsw_sp_nexthop *nh,
4050 const struct rt6_info *rt)
4052 struct net_device *dev = rt->dst.dev;
4054 nh->nh_grp = nh_grp;
4055 memcpy(&nh->gw_addr, &rt->rt6i_gateway, sizeof(nh->gw_addr));
4059 nh->ifindex = dev->ifindex;
4061 return mlxsw_sp_nexthop6_type_init(mlxsw_sp, nh_grp, nh, rt);
4064 static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,
4065 struct mlxsw_sp_nexthop *nh)
4067 mlxsw_sp_nexthop6_type_fini(mlxsw_sp, nh);
4070 static bool mlxsw_sp_rt6_is_gateway(const struct mlxsw_sp *mlxsw_sp,
4071 const struct rt6_info *rt)
4073 return rt->rt6i_flags & RTF_GATEWAY ||
4074 mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, NULL);
4077 static struct mlxsw_sp_nexthop_group *
4078 mlxsw_sp_nexthop6_group_create(struct mlxsw_sp *mlxsw_sp,
4079 struct mlxsw_sp_fib6_entry *fib6_entry)
4081 struct mlxsw_sp_nexthop_group *nh_grp;
4082 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4083 struct mlxsw_sp_nexthop *nh;
4088 alloc_size = sizeof(*nh_grp) +
4089 fib6_entry->nrt6 * sizeof(struct mlxsw_sp_nexthop);
4090 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
4092 return ERR_PTR(-ENOMEM);
4093 INIT_LIST_HEAD(&nh_grp->fib_list);
4094 #if IS_ENABLED(CONFIG_IPV6)
4095 nh_grp->neigh_tbl = &nd_tbl;
4097 mlxsw_sp_rt6 = list_first_entry(&fib6_entry->rt6_list,
4098 struct mlxsw_sp_rt6, list);
4099 nh_grp->gateway = mlxsw_sp_rt6_is_gateway(mlxsw_sp, mlxsw_sp_rt6->rt);
4100 nh_grp->count = fib6_entry->nrt6;
4101 for (i = 0; i < nh_grp->count; i++) {
4102 struct rt6_info *rt = mlxsw_sp_rt6->rt;
4104 nh = &nh_grp->nexthops[i];
4105 err = mlxsw_sp_nexthop6_init(mlxsw_sp, nh_grp, nh, rt);
4107 goto err_nexthop6_init;
4108 mlxsw_sp_rt6 = list_next_entry(mlxsw_sp_rt6, list);
4111 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
4113 goto err_nexthop_group_insert;
4115 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
4118 err_nexthop_group_insert:
4120 for (i--; i >= 0; i--) {
4121 nh = &nh_grp->nexthops[i];
4122 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
4125 return ERR_PTR(err);
4129 mlxsw_sp_nexthop6_group_destroy(struct mlxsw_sp *mlxsw_sp,
4130 struct mlxsw_sp_nexthop_group *nh_grp)
4132 struct mlxsw_sp_nexthop *nh;
4133 int i = nh_grp->count;
4135 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
4136 for (i--; i >= 0; i--) {
4137 nh = &nh_grp->nexthops[i];
4138 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
4140 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
4141 WARN_ON(nh_grp->adj_index_valid);
4145 static int mlxsw_sp_nexthop6_group_get(struct mlxsw_sp *mlxsw_sp,
4146 struct mlxsw_sp_fib6_entry *fib6_entry)
4148 struct mlxsw_sp_nexthop_group *nh_grp;
4150 nh_grp = mlxsw_sp_nexthop6_group_lookup(mlxsw_sp, fib6_entry);
4152 nh_grp = mlxsw_sp_nexthop6_group_create(mlxsw_sp, fib6_entry);
4154 return PTR_ERR(nh_grp);
4157 list_add_tail(&fib6_entry->common.nexthop_group_node,
4159 fib6_entry->common.nh_group = nh_grp;
4164 static void mlxsw_sp_nexthop6_group_put(struct mlxsw_sp *mlxsw_sp,
4165 struct mlxsw_sp_fib_entry *fib_entry)
4167 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
4169 list_del(&fib_entry->nexthop_group_node);
4170 if (!list_empty(&nh_grp->fib_list))
4172 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, nh_grp);
4176 mlxsw_sp_nexthop6_group_update(struct mlxsw_sp *mlxsw_sp,
4177 struct mlxsw_sp_fib6_entry *fib6_entry)
4179 struct mlxsw_sp_nexthop_group *old_nh_grp = fib6_entry->common.nh_group;
4182 fib6_entry->common.nh_group = NULL;
4183 list_del(&fib6_entry->common.nexthop_group_node);
4185 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
4187 goto err_nexthop6_group_get;
4189 /* In case this entry is offloaded, then the adjacency index
4190 * currently associated with it in the device's table is that
4191 * of the old group. Start using the new one instead.
4193 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
4195 goto err_fib_node_entry_add;
4197 if (list_empty(&old_nh_grp->fib_list))
4198 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, old_nh_grp);
4202 err_fib_node_entry_add:
4203 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
4204 err_nexthop6_group_get:
4205 list_add_tail(&fib6_entry->common.nexthop_group_node,
4206 &old_nh_grp->fib_list);
4207 fib6_entry->common.nh_group = old_nh_grp;
4212 mlxsw_sp_fib6_entry_nexthop_add(struct mlxsw_sp *mlxsw_sp,
4213 struct mlxsw_sp_fib6_entry *fib6_entry,
4214 struct rt6_info *rt)
4216 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4219 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt);
4220 if (IS_ERR(mlxsw_sp_rt6))
4221 return PTR_ERR(mlxsw_sp_rt6);
4223 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
4226 err = mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
4228 goto err_nexthop6_group_update;
4232 err_nexthop6_group_update:
4234 list_del(&mlxsw_sp_rt6->list);
4235 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4240 mlxsw_sp_fib6_entry_nexthop_del(struct mlxsw_sp *mlxsw_sp,
4241 struct mlxsw_sp_fib6_entry *fib6_entry,
4242 struct rt6_info *rt)
4244 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4246 mlxsw_sp_rt6 = mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt);
4247 if (WARN_ON(!mlxsw_sp_rt6))
4251 list_del(&mlxsw_sp_rt6->list);
4252 mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
4253 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4256 static void mlxsw_sp_fib6_entry_type_set(struct mlxsw_sp *mlxsw_sp,
4257 struct mlxsw_sp_fib_entry *fib_entry,
4258 const struct rt6_info *rt)
4260 /* Packets hitting RTF_REJECT routes need to be discarded by the
4261 * stack. We can rely on their destination device not having a
4262 * RIF (it's the loopback device) and can thus use action type
4263 * local, which will cause them to be trapped with a lower
4264 * priority than packets that need to be locally received.
4266 if (rt->rt6i_flags & (RTF_LOCAL | RTF_ANYCAST))
4267 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
4268 else if (rt->rt6i_flags & RTF_REJECT)
4269 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
4270 else if (mlxsw_sp_rt6_is_gateway(mlxsw_sp, rt))
4271 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
4273 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
4277 mlxsw_sp_fib6_entry_rt_destroy_all(struct mlxsw_sp_fib6_entry *fib6_entry)
4279 struct mlxsw_sp_rt6 *mlxsw_sp_rt6, *tmp;
4281 list_for_each_entry_safe(mlxsw_sp_rt6, tmp, &fib6_entry->rt6_list,
4284 list_del(&mlxsw_sp_rt6->list);
4285 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4289 static struct mlxsw_sp_fib6_entry *
4290 mlxsw_sp_fib6_entry_create(struct mlxsw_sp *mlxsw_sp,
4291 struct mlxsw_sp_fib_node *fib_node,
4292 struct rt6_info *rt)
4294 struct mlxsw_sp_fib6_entry *fib6_entry;
4295 struct mlxsw_sp_fib_entry *fib_entry;
4296 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4299 fib6_entry = kzalloc(sizeof(*fib6_entry), GFP_KERNEL);
4301 return ERR_PTR(-ENOMEM);
4302 fib_entry = &fib6_entry->common;
4304 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt);
4305 if (IS_ERR(mlxsw_sp_rt6)) {
4306 err = PTR_ERR(mlxsw_sp_rt6);
4307 goto err_rt6_create;
4310 mlxsw_sp_fib6_entry_type_set(mlxsw_sp, fib_entry, mlxsw_sp_rt6->rt);
4312 INIT_LIST_HEAD(&fib6_entry->rt6_list);
4313 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
4314 fib6_entry->nrt6 = 1;
4315 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
4317 goto err_nexthop6_group_get;
4319 fib_entry->fib_node = fib_node;
4323 err_nexthop6_group_get:
4324 list_del(&mlxsw_sp_rt6->list);
4325 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4328 return ERR_PTR(err);
4331 static void mlxsw_sp_fib6_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4332 struct mlxsw_sp_fib6_entry *fib6_entry)
4334 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
4335 mlxsw_sp_fib6_entry_rt_destroy_all(fib6_entry);
4336 WARN_ON(fib6_entry->nrt6);
4340 static struct mlxsw_sp_fib6_entry *
4341 mlxsw_sp_fib6_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
4342 const struct rt6_info *nrt, bool replace)
4344 struct mlxsw_sp_fib6_entry *fib6_entry, *fallback = NULL;
4346 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4347 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4349 if (rt->rt6i_table->tb6_id > nrt->rt6i_table->tb6_id)
4351 if (rt->rt6i_table->tb6_id != nrt->rt6i_table->tb6_id)
4353 if (replace && rt->rt6i_metric == nrt->rt6i_metric) {
4354 if (mlxsw_sp_fib6_rt_can_mp(rt) ==
4355 mlxsw_sp_fib6_rt_can_mp(nrt))
4357 if (mlxsw_sp_fib6_rt_can_mp(nrt))
4358 fallback = fallback ?: fib6_entry;
4360 if (rt->rt6i_metric > nrt->rt6i_metric)
4361 return fallback ?: fib6_entry;
4368 mlxsw_sp_fib6_node_list_insert(struct mlxsw_sp_fib6_entry *new6_entry,
4371 struct mlxsw_sp_fib_node *fib_node = new6_entry->common.fib_node;
4372 struct rt6_info *nrt = mlxsw_sp_fib6_entry_rt(new6_entry);
4373 struct mlxsw_sp_fib6_entry *fib6_entry;
4375 fib6_entry = mlxsw_sp_fib6_node_entry_find(fib_node, nrt, replace);
4377 if (replace && WARN_ON(!fib6_entry))
4381 list_add_tail(&new6_entry->common.list,
4382 &fib6_entry->common.list);
4384 struct mlxsw_sp_fib6_entry *last;
4386 list_for_each_entry(last, &fib_node->entry_list, common.list) {
4387 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(last);
4389 if (nrt->rt6i_table->tb6_id > rt->rt6i_table->tb6_id)
4395 list_add(&new6_entry->common.list,
4396 &fib6_entry->common.list);
4398 list_add(&new6_entry->common.list,
4399 &fib_node->entry_list);
4406 mlxsw_sp_fib6_node_list_remove(struct mlxsw_sp_fib6_entry *fib6_entry)
4408 list_del(&fib6_entry->common.list);
4411 static int mlxsw_sp_fib6_node_entry_link(struct mlxsw_sp *mlxsw_sp,
4412 struct mlxsw_sp_fib6_entry *fib6_entry,
4417 err = mlxsw_sp_fib6_node_list_insert(fib6_entry, replace);
4421 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
4423 goto err_fib_node_entry_add;
4427 err_fib_node_entry_add:
4428 mlxsw_sp_fib6_node_list_remove(fib6_entry);
4433 mlxsw_sp_fib6_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4434 struct mlxsw_sp_fib6_entry *fib6_entry)
4436 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib6_entry->common);
4437 mlxsw_sp_fib6_node_list_remove(fib6_entry);
4440 static struct mlxsw_sp_fib6_entry *
4441 mlxsw_sp_fib6_entry_lookup(struct mlxsw_sp *mlxsw_sp,
4442 const struct rt6_info *rt)
4444 struct mlxsw_sp_fib6_entry *fib6_entry;
4445 struct mlxsw_sp_fib_node *fib_node;
4446 struct mlxsw_sp_fib *fib;
4447 struct mlxsw_sp_vr *vr;
4449 vr = mlxsw_sp_vr_find(mlxsw_sp, rt->rt6i_table->tb6_id);
4452 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV6);
4454 fib_node = mlxsw_sp_fib_node_lookup(fib, &rt->rt6i_dst.addr,
4455 sizeof(rt->rt6i_dst.addr),
4460 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4461 struct rt6_info *iter_rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4463 if (rt->rt6i_table->tb6_id == iter_rt->rt6i_table->tb6_id &&
4464 rt->rt6i_metric == iter_rt->rt6i_metric &&
4465 mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt))
4472 static void mlxsw_sp_fib6_entry_replace(struct mlxsw_sp *mlxsw_sp,
4473 struct mlxsw_sp_fib6_entry *fib6_entry,
4476 struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
4477 struct mlxsw_sp_fib6_entry *replaced;
4482 replaced = list_next_entry(fib6_entry, common.list);
4484 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, replaced);
4485 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, replaced);
4486 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4489 static int mlxsw_sp_router_fib6_add(struct mlxsw_sp *mlxsw_sp,
4490 struct rt6_info *rt, bool replace)
4492 struct mlxsw_sp_fib6_entry *fib6_entry;
4493 struct mlxsw_sp_fib_node *fib_node;
4496 if (mlxsw_sp->router->aborted)
4499 if (rt->rt6i_src.plen)
4502 if (mlxsw_sp_fib6_rt_should_ignore(rt))
4505 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->rt6i_table->tb6_id,
4507 sizeof(rt->rt6i_dst.addr),
4509 MLXSW_SP_L3_PROTO_IPV6);
4510 if (IS_ERR(fib_node))
4511 return PTR_ERR(fib_node);
4513 /* Before creating a new entry, try to append route to an existing
4516 fib6_entry = mlxsw_sp_fib6_node_mp_entry_find(fib_node, rt, replace);
4518 err = mlxsw_sp_fib6_entry_nexthop_add(mlxsw_sp, fib6_entry, rt);
4520 goto err_fib6_entry_nexthop_add;
4524 fib6_entry = mlxsw_sp_fib6_entry_create(mlxsw_sp, fib_node, rt);
4525 if (IS_ERR(fib6_entry)) {
4526 err = PTR_ERR(fib6_entry);
4527 goto err_fib6_entry_create;
4530 err = mlxsw_sp_fib6_node_entry_link(mlxsw_sp, fib6_entry, replace);
4532 goto err_fib6_node_entry_link;
4534 mlxsw_sp_fib6_entry_replace(mlxsw_sp, fib6_entry, replace);
4538 err_fib6_node_entry_link:
4539 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4540 err_fib6_entry_create:
4541 err_fib6_entry_nexthop_add:
4542 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4546 static void mlxsw_sp_router_fib6_del(struct mlxsw_sp *mlxsw_sp,
4547 struct rt6_info *rt)
4549 struct mlxsw_sp_fib6_entry *fib6_entry;
4550 struct mlxsw_sp_fib_node *fib_node;
4552 if (mlxsw_sp->router->aborted)
4555 if (mlxsw_sp_fib6_rt_should_ignore(rt))
4558 fib6_entry = mlxsw_sp_fib6_entry_lookup(mlxsw_sp, rt);
4559 if (WARN_ON(!fib6_entry))
4562 /* If route is part of a multipath entry, but not the last one
4563 * removed, then only reduce its nexthop group.
4565 if (!list_is_singular(&fib6_entry->rt6_list)) {
4566 mlxsw_sp_fib6_entry_nexthop_del(mlxsw_sp, fib6_entry, rt);
4570 fib_node = fib6_entry->common.fib_node;
4572 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
4573 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4574 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4577 static int __mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp,
4578 enum mlxsw_reg_ralxx_protocol proto,
4581 char ralta_pl[MLXSW_REG_RALTA_LEN];
4582 char ralst_pl[MLXSW_REG_RALST_LEN];
4585 mlxsw_reg_ralta_pack(ralta_pl, true, proto, tree_id);
4586 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
4590 mlxsw_reg_ralst_pack(ralst_pl, 0xff, tree_id);
4591 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
4595 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
4596 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
4597 char raltb_pl[MLXSW_REG_RALTB_LEN];
4598 char ralue_pl[MLXSW_REG_RALUE_LEN];
4600 mlxsw_reg_raltb_pack(raltb_pl, vr->id, proto, tree_id);
4601 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb),
4606 mlxsw_reg_ralue_pack(ralue_pl, proto,
4607 MLXSW_REG_RALUE_OP_WRITE_WRITE, vr->id, 0);
4608 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
4609 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue),
4618 static int mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp)
4620 enum mlxsw_reg_ralxx_protocol proto = MLXSW_REG_RALXX_PROTOCOL_IPV4;
4623 err = __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
4624 MLXSW_SP_LPM_TREE_MIN);
4628 proto = MLXSW_REG_RALXX_PROTOCOL_IPV6;
4629 return __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
4630 MLXSW_SP_LPM_TREE_MIN + 1);
4633 static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
4634 struct mlxsw_sp_fib_node *fib_node)
4636 struct mlxsw_sp_fib4_entry *fib4_entry, *tmp;
4638 list_for_each_entry_safe(fib4_entry, tmp, &fib_node->entry_list,
4640 bool do_break = &tmp->common.list == &fib_node->entry_list;
4642 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
4643 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
4644 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4645 /* Break when entry list is empty and node was freed.
4646 * Otherwise, we'll access freed memory in the next
4654 static void mlxsw_sp_fib6_node_flush(struct mlxsw_sp *mlxsw_sp,
4655 struct mlxsw_sp_fib_node *fib_node)
4657 struct mlxsw_sp_fib6_entry *fib6_entry, *tmp;
4659 list_for_each_entry_safe(fib6_entry, tmp, &fib_node->entry_list,
4661 bool do_break = &tmp->common.list == &fib_node->entry_list;
4663 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
4664 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4665 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4671 static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
4672 struct mlxsw_sp_fib_node *fib_node)
4674 switch (fib_node->fib->proto) {
4675 case MLXSW_SP_L3_PROTO_IPV4:
4676 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
4678 case MLXSW_SP_L3_PROTO_IPV6:
4679 mlxsw_sp_fib6_node_flush(mlxsw_sp, fib_node);
4684 static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
4685 struct mlxsw_sp_vr *vr,
4686 enum mlxsw_sp_l3proto proto)
4688 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
4689 struct mlxsw_sp_fib_node *fib_node, *tmp;
4691 list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
4692 bool do_break = &tmp->list == &fib->node_list;
4694 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
4700 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
4704 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
4705 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
4707 if (!mlxsw_sp_vr_is_used(vr))
4709 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
4711 /* If virtual router was only used for IPv4, then it's no
4714 if (!mlxsw_sp_vr_is_used(vr))
4716 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
4720 static void mlxsw_sp_router_fib_abort(struct mlxsw_sp *mlxsw_sp)
4724 if (mlxsw_sp->router->aborted)
4726 dev_warn(mlxsw_sp->bus_info->dev, "FIB abort triggered. Note that FIB entries are no longer being offloaded to this device.\n");
4727 mlxsw_sp_router_fib_flush(mlxsw_sp);
4728 mlxsw_sp->router->aborted = true;
4729 err = mlxsw_sp_router_set_abort_trap(mlxsw_sp);
4731 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set abort trap.\n");
4734 struct mlxsw_sp_fib_event_work {
4735 struct work_struct work;
4737 struct fib6_entry_notifier_info fen6_info;
4738 struct fib_entry_notifier_info fen_info;
4739 struct fib_rule_notifier_info fr_info;
4740 struct fib_nh_notifier_info fnh_info;
4742 struct mlxsw_sp *mlxsw_sp;
4743 unsigned long event;
4746 static void mlxsw_sp_router_fib4_event_work(struct work_struct *work)
4748 struct mlxsw_sp_fib_event_work *fib_work =
4749 container_of(work, struct mlxsw_sp_fib_event_work, work);
4750 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
4751 struct fib_rule *rule;
4752 bool replace, append;
4755 /* Protect internal structures from changes */
4757 switch (fib_work->event) {
4758 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4759 case FIB_EVENT_ENTRY_APPEND: /* fall through */
4760 case FIB_EVENT_ENTRY_ADD:
4761 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
4762 append = fib_work->event == FIB_EVENT_ENTRY_APPEND;
4763 err = mlxsw_sp_router_fib4_add(mlxsw_sp, &fib_work->fen_info,
4766 mlxsw_sp_router_fib_abort(mlxsw_sp);
4767 fib_info_put(fib_work->fen_info.fi);
4769 case FIB_EVENT_ENTRY_DEL:
4770 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
4771 fib_info_put(fib_work->fen_info.fi);
4773 case FIB_EVENT_RULE_ADD: /* fall through */
4774 case FIB_EVENT_RULE_DEL:
4775 rule = fib_work->fr_info.rule;
4776 if (!fib4_rule_default(rule) && !rule->l3mdev)
4777 mlxsw_sp_router_fib_abort(mlxsw_sp);
4780 case FIB_EVENT_NH_ADD: /* fall through */
4781 case FIB_EVENT_NH_DEL:
4782 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
4783 fib_work->fnh_info.fib_nh);
4784 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
4791 static void mlxsw_sp_router_fib6_event_work(struct work_struct *work)
4793 struct mlxsw_sp_fib_event_work *fib_work =
4794 container_of(work, struct mlxsw_sp_fib_event_work, work);
4795 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
4796 struct fib_rule *rule;
4801 switch (fib_work->event) {
4802 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4803 case FIB_EVENT_ENTRY_ADD:
4804 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
4805 err = mlxsw_sp_router_fib6_add(mlxsw_sp,
4806 fib_work->fen6_info.rt, replace);
4808 mlxsw_sp_router_fib_abort(mlxsw_sp);
4809 mlxsw_sp_rt6_release(fib_work->fen6_info.rt);
4811 case FIB_EVENT_ENTRY_DEL:
4812 mlxsw_sp_router_fib6_del(mlxsw_sp, fib_work->fen6_info.rt);
4813 mlxsw_sp_rt6_release(fib_work->fen6_info.rt);
4815 case FIB_EVENT_RULE_ADD: /* fall through */
4816 case FIB_EVENT_RULE_DEL:
4817 rule = fib_work->fr_info.rule;
4818 if (!fib6_rule_default(rule) && !rule->l3mdev)
4819 mlxsw_sp_router_fib_abort(mlxsw_sp);
4827 static void mlxsw_sp_router_fib4_event(struct mlxsw_sp_fib_event_work *fib_work,
4828 struct fib_notifier_info *info)
4830 switch (fib_work->event) {
4831 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4832 case FIB_EVENT_ENTRY_APPEND: /* fall through */
4833 case FIB_EVENT_ENTRY_ADD: /* fall through */
4834 case FIB_EVENT_ENTRY_DEL:
4835 memcpy(&fib_work->fen_info, info, sizeof(fib_work->fen_info));
4836 /* Take referece on fib_info to prevent it from being
4837 * freed while work is queued. Release it afterwards.
4839 fib_info_hold(fib_work->fen_info.fi);
4841 case FIB_EVENT_RULE_ADD: /* fall through */
4842 case FIB_EVENT_RULE_DEL:
4843 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
4844 fib_rule_get(fib_work->fr_info.rule);
4846 case FIB_EVENT_NH_ADD: /* fall through */
4847 case FIB_EVENT_NH_DEL:
4848 memcpy(&fib_work->fnh_info, info, sizeof(fib_work->fnh_info));
4849 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
4854 static void mlxsw_sp_router_fib6_event(struct mlxsw_sp_fib_event_work *fib_work,
4855 struct fib_notifier_info *info)
4857 switch (fib_work->event) {
4858 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4859 case FIB_EVENT_ENTRY_ADD: /* fall through */
4860 case FIB_EVENT_ENTRY_DEL:
4861 memcpy(&fib_work->fen6_info, info, sizeof(fib_work->fen6_info));
4862 rt6_hold(fib_work->fen6_info.rt);
4864 case FIB_EVENT_RULE_ADD: /* fall through */
4865 case FIB_EVENT_RULE_DEL:
4866 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
4867 fib_rule_get(fib_work->fr_info.rule);
4872 /* Called with rcu_read_lock() */
4873 static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
4874 unsigned long event, void *ptr)
4876 struct mlxsw_sp_fib_event_work *fib_work;
4877 struct fib_notifier_info *info = ptr;
4878 struct mlxsw_sp_router *router;
4880 if (!net_eq(info->net, &init_net) ||
4881 (info->family != AF_INET && info->family != AF_INET6))
4884 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
4885 if (WARN_ON(!fib_work))
4888 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
4889 fib_work->mlxsw_sp = router->mlxsw_sp;
4890 fib_work->event = event;
4892 switch (info->family) {
4894 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib4_event_work);
4895 mlxsw_sp_router_fib4_event(fib_work, info);
4898 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib6_event_work);
4899 mlxsw_sp_router_fib6_event(fib_work, info);
4903 mlxsw_core_schedule_work(&fib_work->work);
4908 static struct mlxsw_sp_rif *
4909 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
4910 const struct net_device *dev)
4914 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
4915 if (mlxsw_sp->router->rifs[i] &&
4916 mlxsw_sp->router->rifs[i]->dev == dev)
4917 return mlxsw_sp->router->rifs[i];
4922 static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
4924 char ritr_pl[MLXSW_REG_RITR_LEN];
4927 mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
4928 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
4929 if (WARN_ON_ONCE(err))
4932 mlxsw_reg_ritr_enable_set(ritr_pl, false);
4933 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
4936 static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
4937 struct mlxsw_sp_rif *rif)
4939 mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
4940 mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
4941 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
4945 mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
4946 unsigned long event)
4948 struct inet6_dev *inet6_dev;
4949 bool addr_list_empty = true;
4950 struct in_device *idev;
4956 idev = __in_dev_get_rtnl(dev);
4957 if (idev && idev->ifa_list)
4958 addr_list_empty = false;
4960 inet6_dev = __in6_dev_get(dev);
4961 if (addr_list_empty && inet6_dev &&
4962 !list_empty(&inet6_dev->addr_list))
4963 addr_list_empty = false;
4965 if (rif && addr_list_empty &&
4966 !netif_is_l3_slave(rif->dev))
4968 /* It is possible we already removed the RIF ourselves
4969 * if it was assigned to a netdev that is now a bridge
4978 static enum mlxsw_sp_rif_type
4979 mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
4980 const struct net_device *dev)
4982 enum mlxsw_sp_fid_type type;
4984 if (mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL))
4985 return MLXSW_SP_RIF_TYPE_IPIP_LB;
4987 /* Otherwise RIF type is derived from the type of the underlying FID. */
4988 if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
4989 type = MLXSW_SP_FID_TYPE_8021Q;
4990 else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
4991 type = MLXSW_SP_FID_TYPE_8021Q;
4992 else if (netif_is_bridge_master(dev))
4993 type = MLXSW_SP_FID_TYPE_8021D;
4995 type = MLXSW_SP_FID_TYPE_RFID;
4997 return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
5000 static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index)
5004 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
5005 if (!mlxsw_sp->router->rifs[i]) {
5014 static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
5016 struct net_device *l3_dev)
5018 struct mlxsw_sp_rif *rif;
5020 rif = kzalloc(rif_size, GFP_KERNEL);
5024 INIT_LIST_HEAD(&rif->nexthop_list);
5025 INIT_LIST_HEAD(&rif->neigh_list);
5026 ether_addr_copy(rif->addr, l3_dev->dev_addr);
5027 rif->mtu = l3_dev->mtu;
5030 rif->rif_index = rif_index;
5035 struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
5038 return mlxsw_sp->router->rifs[rif_index];
5041 u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
5043 return rif->rif_index;
5046 u16 mlxsw_sp_ipip_lb_rif_index(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
5048 return lb_rif->common.rif_index;
5051 u16 mlxsw_sp_ipip_lb_ul_vr_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
5053 return lb_rif->ul_vr_id;
5056 int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
5058 return rif->dev->ifindex;
5061 static struct mlxsw_sp_rif *
5062 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
5063 const struct mlxsw_sp_rif_params *params)
5065 u32 tb_id = l3mdev_fib_table(params->dev);
5066 const struct mlxsw_sp_rif_ops *ops;
5067 struct mlxsw_sp_fid *fid = NULL;
5068 enum mlxsw_sp_rif_type type;
5069 struct mlxsw_sp_rif *rif;
5070 struct mlxsw_sp_vr *vr;
5074 type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
5075 ops = mlxsw_sp->router->rif_ops_arr[type];
5077 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN);
5079 return ERR_CAST(vr);
5082 err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index);
5084 goto err_rif_index_alloc;
5086 rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, params->dev);
5091 rif->mlxsw_sp = mlxsw_sp;
5095 fid = ops->fid_get(rif);
5104 ops->setup(rif, params);
5106 err = ops->configure(rif);
5110 mlxsw_sp_rif_counters_alloc(rif);
5111 mlxsw_sp->router->rifs[rif_index] = rif;
5117 mlxsw_sp_fid_put(fid);
5121 err_rif_index_alloc:
5123 mlxsw_sp_vr_put(vr);
5124 return ERR_PTR(err);
5127 void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
5129 const struct mlxsw_sp_rif_ops *ops = rif->ops;
5130 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5131 struct mlxsw_sp_fid *fid = rif->fid;
5132 struct mlxsw_sp_vr *vr;
5134 mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
5135 vr = &mlxsw_sp->router->vrs[rif->vr_id];
5137 mlxsw_sp->router->rifs[rif->rif_index] = NULL;
5138 mlxsw_sp_rif_counters_free(rif);
5139 ops->deconfigure(rif);
5141 /* Loopback RIFs are not associated with a FID. */
5142 mlxsw_sp_fid_put(fid);
5145 mlxsw_sp_vr_put(vr);
5149 mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
5150 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
5152 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
5154 params->vid = mlxsw_sp_port_vlan->vid;
5155 params->lag = mlxsw_sp_port->lagged;
5157 params->lag_id = mlxsw_sp_port->lag_id;
5159 params->system_port = mlxsw_sp_port->local_port;
5163 mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
5164 struct net_device *l3_dev)
5166 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
5167 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
5168 u16 vid = mlxsw_sp_port_vlan->vid;
5169 struct mlxsw_sp_rif *rif;
5170 struct mlxsw_sp_fid *fid;
5173 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5175 struct mlxsw_sp_rif_params params = {
5179 mlxsw_sp_rif_subport_params_init(¶ms, mlxsw_sp_port_vlan);
5180 rif = mlxsw_sp_rif_create(mlxsw_sp, ¶ms);
5182 return PTR_ERR(rif);
5185 /* FID was already created, just take a reference */
5186 fid = rif->ops->fid_get(rif);
5187 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
5189 goto err_fid_port_vid_map;
5191 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
5193 goto err_port_vid_learning_set;
5195 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
5196 BR_STATE_FORWARDING);
5198 goto err_port_vid_stp_set;
5200 mlxsw_sp_port_vlan->fid = fid;
5204 err_port_vid_stp_set:
5205 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
5206 err_port_vid_learning_set:
5207 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
5208 err_fid_port_vid_map:
5209 mlxsw_sp_fid_put(fid);
5214 mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
5216 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
5217 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
5218 u16 vid = mlxsw_sp_port_vlan->vid;
5220 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
5223 mlxsw_sp_port_vlan->fid = NULL;
5224 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
5225 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
5226 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
5227 /* If router port holds the last reference on the rFID, then the
5228 * associated Sub-port RIF will be destroyed.
5230 mlxsw_sp_fid_put(fid);
5233 static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
5234 struct net_device *port_dev,
5235 unsigned long event, u16 vid)
5237 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
5238 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
5240 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
5241 if (WARN_ON(!mlxsw_sp_port_vlan))
5246 return mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
5249 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
5256 static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
5257 unsigned long event)
5259 if (netif_is_bridge_port(port_dev) ||
5260 netif_is_lag_port(port_dev) ||
5261 netif_is_ovs_port(port_dev))
5264 return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event, 1);
5267 static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
5268 struct net_device *lag_dev,
5269 unsigned long event, u16 vid)
5271 struct net_device *port_dev;
5272 struct list_head *iter;
5275 netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
5276 if (mlxsw_sp_port_dev_check(port_dev)) {
5277 err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
5288 static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
5289 unsigned long event)
5291 if (netif_is_bridge_port(lag_dev))
5294 return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event, 1);
5297 static int mlxsw_sp_inetaddr_bridge_event(struct net_device *l3_dev,
5298 unsigned long event)
5300 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
5301 struct mlxsw_sp_rif_params params = {
5304 struct mlxsw_sp_rif *rif;
5308 rif = mlxsw_sp_rif_create(mlxsw_sp, ¶ms);
5310 return PTR_ERR(rif);
5313 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5314 mlxsw_sp_rif_destroy(rif);
5321 static int mlxsw_sp_inetaddr_vlan_event(struct net_device *vlan_dev,
5322 unsigned long event)
5324 struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
5325 u16 vid = vlan_dev_vlan_id(vlan_dev);
5327 if (netif_is_bridge_port(vlan_dev))
5330 if (mlxsw_sp_port_dev_check(real_dev))
5331 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
5333 else if (netif_is_lag_master(real_dev))
5334 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
5336 else if (netif_is_bridge_master(real_dev) && br_vlan_enabled(real_dev))
5337 return mlxsw_sp_inetaddr_bridge_event(vlan_dev, event);
5342 static int __mlxsw_sp_inetaddr_event(struct net_device *dev,
5343 unsigned long event)
5345 if (mlxsw_sp_port_dev_check(dev))
5346 return mlxsw_sp_inetaddr_port_event(dev, event);
5347 else if (netif_is_lag_master(dev))
5348 return mlxsw_sp_inetaddr_lag_event(dev, event);
5349 else if (netif_is_bridge_master(dev))
5350 return mlxsw_sp_inetaddr_bridge_event(dev, event);
5351 else if (is_vlan_dev(dev))
5352 return mlxsw_sp_inetaddr_vlan_event(dev, event);
5357 int mlxsw_sp_inetaddr_event(struct notifier_block *unused,
5358 unsigned long event, void *ptr)
5360 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
5361 struct net_device *dev = ifa->ifa_dev->dev;
5362 struct mlxsw_sp *mlxsw_sp;
5363 struct mlxsw_sp_rif *rif;
5366 mlxsw_sp = mlxsw_sp_lower_get(dev);
5370 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5371 if (!mlxsw_sp_rif_should_config(rif, dev, event))
5374 err = __mlxsw_sp_inetaddr_event(dev, event);
5376 return notifier_from_errno(err);
5379 struct mlxsw_sp_inet6addr_event_work {
5380 struct work_struct work;
5381 struct net_device *dev;
5382 unsigned long event;
5385 static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
5387 struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
5388 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
5389 struct net_device *dev = inet6addr_work->dev;
5390 unsigned long event = inet6addr_work->event;
5391 struct mlxsw_sp *mlxsw_sp;
5392 struct mlxsw_sp_rif *rif;
5395 mlxsw_sp = mlxsw_sp_lower_get(dev);
5399 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5400 if (!mlxsw_sp_rif_should_config(rif, dev, event))
5403 __mlxsw_sp_inetaddr_event(dev, event);
5407 kfree(inet6addr_work);
5410 /* Called with rcu_read_lock() */
5411 int mlxsw_sp_inet6addr_event(struct notifier_block *unused,
5412 unsigned long event, void *ptr)
5414 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
5415 struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
5416 struct net_device *dev = if6->idev->dev;
5418 if (!mlxsw_sp_port_dev_lower_find_rcu(dev))
5421 inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
5422 if (!inet6addr_work)
5425 INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
5426 inet6addr_work->dev = dev;
5427 inet6addr_work->event = event;
5429 mlxsw_core_schedule_work(&inet6addr_work->work);
5434 static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
5435 const char *mac, int mtu)
5437 char ritr_pl[MLXSW_REG_RITR_LEN];
5440 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
5441 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5445 mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
5446 mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
5447 mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
5448 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5451 int mlxsw_sp_netdevice_router_port_event(struct net_device *dev)
5453 struct mlxsw_sp *mlxsw_sp;
5454 struct mlxsw_sp_rif *rif;
5458 mlxsw_sp = mlxsw_sp_lower_get(dev);
5462 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5465 fid_index = mlxsw_sp_fid_index(rif->fid);
5467 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
5471 err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
5476 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
5478 goto err_rif_fdb_op;
5480 ether_addr_copy(rif->addr, dev->dev_addr);
5481 rif->mtu = dev->mtu;
5483 netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
5488 mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu);
5490 mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
5494 static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
5495 struct net_device *l3_dev)
5497 struct mlxsw_sp_rif *rif;
5499 /* If netdev is already associated with a RIF, then we need to
5500 * destroy it and create a new one with the new virtual router ID.
5502 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5504 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
5506 return __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_UP);
5509 static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
5510 struct net_device *l3_dev)
5512 struct mlxsw_sp_rif *rif;
5514 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5517 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
5520 int mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
5521 struct netdev_notifier_changeupper_info *info)
5523 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
5530 case NETDEV_PRECHANGEUPPER:
5532 case NETDEV_CHANGEUPPER:
5534 err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev);
5536 mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
5543 static struct mlxsw_sp_rif_subport *
5544 mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
5546 return container_of(rif, struct mlxsw_sp_rif_subport, common);
5549 static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
5550 const struct mlxsw_sp_rif_params *params)
5552 struct mlxsw_sp_rif_subport *rif_subport;
5554 rif_subport = mlxsw_sp_rif_subport_rif(rif);
5555 rif_subport->vid = params->vid;
5556 rif_subport->lag = params->lag;
5558 rif_subport->lag_id = params->lag_id;
5560 rif_subport->system_port = params->system_port;
5563 static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
5565 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5566 struct mlxsw_sp_rif_subport *rif_subport;
5567 char ritr_pl[MLXSW_REG_RITR_LEN];
5569 rif_subport = mlxsw_sp_rif_subport_rif(rif);
5570 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
5571 rif->rif_index, rif->vr_id, rif->dev->mtu);
5572 mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
5573 mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
5574 rif_subport->lag ? rif_subport->lag_id :
5575 rif_subport->system_port,
5578 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5581 static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif)
5585 err = mlxsw_sp_rif_subport_op(rif, true);
5589 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5590 mlxsw_sp_fid_index(rif->fid), true);
5592 goto err_rif_fdb_op;
5594 mlxsw_sp_fid_rif_set(rif->fid, rif);
5598 mlxsw_sp_rif_subport_op(rif, false);
5602 static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
5604 struct mlxsw_sp_fid *fid = rif->fid;
5606 mlxsw_sp_fid_rif_set(fid, NULL);
5607 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5608 mlxsw_sp_fid_index(fid), false);
5609 mlxsw_sp_rif_subport_op(rif, false);
5612 static struct mlxsw_sp_fid *
5613 mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif)
5615 return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
5618 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
5619 .type = MLXSW_SP_RIF_TYPE_SUBPORT,
5620 .rif_size = sizeof(struct mlxsw_sp_rif_subport),
5621 .setup = mlxsw_sp_rif_subport_setup,
5622 .configure = mlxsw_sp_rif_subport_configure,
5623 .deconfigure = mlxsw_sp_rif_subport_deconfigure,
5624 .fid_get = mlxsw_sp_rif_subport_fid_get,
5627 static int mlxsw_sp_rif_vlan_fid_op(struct mlxsw_sp_rif *rif,
5628 enum mlxsw_reg_ritr_if_type type,
5629 u16 vid_fid, bool enable)
5631 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5632 char ritr_pl[MLXSW_REG_RITR_LEN];
5634 mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
5636 mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
5637 mlxsw_reg_ritr_fid_set(ritr_pl, type, vid_fid);
5639 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5642 static u8 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
5644 return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
5647 static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif)
5649 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5650 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
5653 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, true);
5657 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5658 mlxsw_sp_router_port(mlxsw_sp), true);
5660 goto err_fid_mc_flood_set;
5662 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5663 mlxsw_sp_router_port(mlxsw_sp), true);
5665 goto err_fid_bc_flood_set;
5667 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5668 mlxsw_sp_fid_index(rif->fid), true);
5670 goto err_rif_fdb_op;
5672 mlxsw_sp_fid_rif_set(rif->fid, rif);
5676 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5677 mlxsw_sp_router_port(mlxsw_sp), false);
5678 err_fid_bc_flood_set:
5679 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5680 mlxsw_sp_router_port(mlxsw_sp), false);
5681 err_fid_mc_flood_set:
5682 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
5686 static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
5688 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
5689 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5690 struct mlxsw_sp_fid *fid = rif->fid;
5692 mlxsw_sp_fid_rif_set(fid, NULL);
5693 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5694 mlxsw_sp_fid_index(fid), false);
5695 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5696 mlxsw_sp_router_port(mlxsw_sp), false);
5697 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5698 mlxsw_sp_router_port(mlxsw_sp), false);
5699 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
5702 static struct mlxsw_sp_fid *
5703 mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif)
5705 u16 vid = is_vlan_dev(rif->dev) ? vlan_dev_vlan_id(rif->dev) : 1;
5707 return mlxsw_sp_fid_8021q_get(rif->mlxsw_sp, vid);
5710 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_vlan_ops = {
5711 .type = MLXSW_SP_RIF_TYPE_VLAN,
5712 .rif_size = sizeof(struct mlxsw_sp_rif),
5713 .configure = mlxsw_sp_rif_vlan_configure,
5714 .deconfigure = mlxsw_sp_rif_vlan_deconfigure,
5715 .fid_get = mlxsw_sp_rif_vlan_fid_get,
5718 static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif)
5720 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5721 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
5724 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index,
5729 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5730 mlxsw_sp_router_port(mlxsw_sp), true);
5732 goto err_fid_mc_flood_set;
5734 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5735 mlxsw_sp_router_port(mlxsw_sp), true);
5737 goto err_fid_bc_flood_set;
5739 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5740 mlxsw_sp_fid_index(rif->fid), true);
5742 goto err_rif_fdb_op;
5744 mlxsw_sp_fid_rif_set(rif->fid, rif);
5748 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5749 mlxsw_sp_router_port(mlxsw_sp), false);
5750 err_fid_bc_flood_set:
5751 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5752 mlxsw_sp_router_port(mlxsw_sp), false);
5753 err_fid_mc_flood_set:
5754 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
5758 static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
5760 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
5761 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5762 struct mlxsw_sp_fid *fid = rif->fid;
5764 mlxsw_sp_fid_rif_set(fid, NULL);
5765 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5766 mlxsw_sp_fid_index(fid), false);
5767 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5768 mlxsw_sp_router_port(mlxsw_sp), false);
5769 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5770 mlxsw_sp_router_port(mlxsw_sp), false);
5771 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
5774 static struct mlxsw_sp_fid *
5775 mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif)
5777 return mlxsw_sp_fid_8021d_get(rif->mlxsw_sp, rif->dev->ifindex);
5780 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
5781 .type = MLXSW_SP_RIF_TYPE_FID,
5782 .rif_size = sizeof(struct mlxsw_sp_rif),
5783 .configure = mlxsw_sp_rif_fid_configure,
5784 .deconfigure = mlxsw_sp_rif_fid_deconfigure,
5785 .fid_get = mlxsw_sp_rif_fid_fid_get,
5788 static struct mlxsw_sp_rif_ipip_lb *
5789 mlxsw_sp_rif_ipip_lb_rif(struct mlxsw_sp_rif *rif)
5791 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
5795 mlxsw_sp_rif_ipip_lb_setup(struct mlxsw_sp_rif *rif,
5796 const struct mlxsw_sp_rif_params *params)
5798 struct mlxsw_sp_rif_params_ipip_lb *params_lb;
5799 struct mlxsw_sp_rif_ipip_lb *rif_lb;
5801 params_lb = container_of(params, struct mlxsw_sp_rif_params_ipip_lb,
5803 rif_lb = mlxsw_sp_rif_ipip_lb_rif(rif);
5804 rif_lb->lb_config = params_lb->lb_config;
5808 mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif,
5809 struct mlxsw_sp_vr *ul_vr, bool enable)
5811 struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config;
5812 struct mlxsw_sp_rif *rif = &lb_rif->common;
5813 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5814 char ritr_pl[MLXSW_REG_RITR_LEN];
5817 switch (lb_cf.ul_protocol) {
5818 case MLXSW_SP_L3_PROTO_IPV4:
5819 saddr4 = be32_to_cpu(lb_cf.saddr.addr4);
5820 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
5821 rif->rif_index, rif->vr_id, rif->dev->mtu);
5822 mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt,
5823 MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET,
5824 ul_vr->id, saddr4, lb_cf.okey);
5827 case MLXSW_SP_L3_PROTO_IPV6:
5828 return -EAFNOSUPPORT;
5831 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5835 mlxsw_sp_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif)
5837 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
5838 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(rif->dev);
5839 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5840 struct mlxsw_sp_vr *ul_vr;
5843 ul_vr = mlxsw_sp_vr_get(mlxsw_sp, ul_tb_id);
5845 return PTR_ERR(ul_vr);
5847 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr, true);
5849 goto err_loopback_op;
5851 lb_rif->ul_vr_id = ul_vr->id;
5856 mlxsw_sp_vr_put(ul_vr);
5860 static void mlxsw_sp_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
5862 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
5863 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5864 struct mlxsw_sp_vr *ul_vr;
5866 ul_vr = &mlxsw_sp->router->vrs[lb_rif->ul_vr_id];
5867 mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr, false);
5870 mlxsw_sp_vr_put(ul_vr);
5873 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_ipip_lb_ops = {
5874 .type = MLXSW_SP_RIF_TYPE_IPIP_LB,
5875 .rif_size = sizeof(struct mlxsw_sp_rif_ipip_lb),
5876 .setup = mlxsw_sp_rif_ipip_lb_setup,
5877 .configure = mlxsw_sp_rif_ipip_lb_configure,
5878 .deconfigure = mlxsw_sp_rif_ipip_lb_deconfigure,
5881 static const struct mlxsw_sp_rif_ops *mlxsw_sp_rif_ops_arr[] = {
5882 [MLXSW_SP_RIF_TYPE_SUBPORT] = &mlxsw_sp_rif_subport_ops,
5883 [MLXSW_SP_RIF_TYPE_VLAN] = &mlxsw_sp_rif_vlan_ops,
5884 [MLXSW_SP_RIF_TYPE_FID] = &mlxsw_sp_rif_fid_ops,
5885 [MLXSW_SP_RIF_TYPE_IPIP_LB] = &mlxsw_sp_rif_ipip_lb_ops,
5888 static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
5890 u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
5892 mlxsw_sp->router->rifs = kcalloc(max_rifs,
5893 sizeof(struct mlxsw_sp_rif *),
5895 if (!mlxsw_sp->router->rifs)
5898 mlxsw_sp->router->rif_ops_arr = mlxsw_sp_rif_ops_arr;
5903 static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
5907 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
5908 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
5910 kfree(mlxsw_sp->router->rifs);
5913 static int mlxsw_sp_ipips_init(struct mlxsw_sp *mlxsw_sp)
5915 mlxsw_sp->router->ipip_ops_arr = mlxsw_sp_ipip_ops_arr;
5916 INIT_LIST_HEAD(&mlxsw_sp->router->ipip_list);
5920 static void mlxsw_sp_ipips_fini(struct mlxsw_sp *mlxsw_sp)
5922 WARN_ON(!list_empty(&mlxsw_sp->router->ipip_list));
5925 static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
5927 struct mlxsw_sp_router *router;
5929 /* Flush pending FIB notifications and then flush the device's
5930 * table before requesting another dump. The FIB notification
5931 * block is unregistered, so no need to take RTNL.
5933 mlxsw_core_flush_owq();
5934 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
5935 mlxsw_sp_router_fib_flush(router->mlxsw_sp);
5938 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
5940 char rgcr_pl[MLXSW_REG_RGCR_LEN];
5944 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
5946 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
5948 mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
5949 mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
5950 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
5956 static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
5958 char rgcr_pl[MLXSW_REG_RGCR_LEN];
5960 mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
5961 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
5964 int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
5966 struct mlxsw_sp_router *router;
5969 router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
5972 mlxsw_sp->router = router;
5973 router->mlxsw_sp = mlxsw_sp;
5975 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
5976 err = __mlxsw_sp_router_init(mlxsw_sp);
5978 goto err_router_init;
5980 err = mlxsw_sp_rifs_init(mlxsw_sp);
5984 err = mlxsw_sp_ipips_init(mlxsw_sp);
5986 goto err_ipips_init;
5988 err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
5989 &mlxsw_sp_nexthop_ht_params);
5991 goto err_nexthop_ht_init;
5993 err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
5994 &mlxsw_sp_nexthop_group_ht_params);
5996 goto err_nexthop_group_ht_init;
5998 err = mlxsw_sp_lpm_init(mlxsw_sp);
6002 err = mlxsw_sp_vrs_init(mlxsw_sp);
6006 err = mlxsw_sp_neigh_init(mlxsw_sp);
6008 goto err_neigh_init;
6010 mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
6011 err = register_fib_notifier(&mlxsw_sp->router->fib_nb,
6012 mlxsw_sp_router_fib_dump_flush);
6014 goto err_register_fib_notifier;
6018 err_register_fib_notifier:
6019 mlxsw_sp_neigh_fini(mlxsw_sp);
6021 mlxsw_sp_vrs_fini(mlxsw_sp);
6023 mlxsw_sp_lpm_fini(mlxsw_sp);
6025 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
6026 err_nexthop_group_ht_init:
6027 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
6028 err_nexthop_ht_init:
6029 mlxsw_sp_ipips_fini(mlxsw_sp);
6031 mlxsw_sp_rifs_fini(mlxsw_sp);
6033 __mlxsw_sp_router_fini(mlxsw_sp);
6035 kfree(mlxsw_sp->router);
6039 void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
6041 unregister_fib_notifier(&mlxsw_sp->router->fib_nb);
6042 mlxsw_sp_neigh_fini(mlxsw_sp);
6043 mlxsw_sp_vrs_fini(mlxsw_sp);
6044 mlxsw_sp_lpm_fini(mlxsw_sp);
6045 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
6046 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
6047 mlxsw_sp_ipips_fini(mlxsw_sp);
6048 mlxsw_sp_rifs_fini(mlxsw_sp);
6049 __mlxsw_sp_router_fini(mlxsw_sp);
6050 kfree(mlxsw_sp->router);