1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2016-2018 Mellanox Technologies. All rights reserved */
4 #include <linux/kernel.h>
5 #include <linux/types.h>
6 #include <linux/rhashtable.h>
7 #include <linux/bitops.h>
9 #include <linux/notifier.h>
10 #include <linux/inetdevice.h>
11 #include <linux/netdevice.h>
12 #include <linux/if_bridge.h>
13 #include <linux/socket.h>
14 #include <linux/route.h>
15 #include <linux/gcd.h>
16 #include <linux/if_macvlan.h>
17 #include <linux/refcount.h>
18 #include <linux/jhash.h>
19 #include <linux/net_namespace.h>
20 #include <linux/mutex.h>
21 #include <linux/genalloc.h>
22 #include <net/netevent.h>
23 #include <net/neighbour.h>
25 #include <net/inet_dscp.h>
26 #include <net/ip_fib.h>
27 #include <net/ip6_fib.h>
28 #include <net/nexthop.h>
29 #include <net/fib_rules.h>
30 #include <net/ip_tunnels.h>
31 #include <net/l3mdev.h>
32 #include <net/addrconf.h>
33 #include <net/ndisc.h>
35 #include <net/fib_notifier.h>
36 #include <net/switchdev.h>
41 #include "spectrum_cnt.h"
42 #include "spectrum_dpipe.h"
43 #include "spectrum_ipip.h"
44 #include "spectrum_mr.h"
45 #include "spectrum_mr_tcam.h"
46 #include "spectrum_router.h"
47 #include "spectrum_span.h"
51 struct mlxsw_sp_lpm_tree;
52 struct mlxsw_sp_rif_ops;
54 struct mlxsw_sp_crif_key {
55 struct net_device *dev;
58 struct mlxsw_sp_crif {
59 struct mlxsw_sp_crif_key key;
60 struct rhash_head ht_node;
62 struct list_head nexthop_list;
63 struct mlxsw_sp_rif *rif;
66 static const struct rhashtable_params mlxsw_sp_crif_ht_params = {
67 .key_offset = offsetof(struct mlxsw_sp_crif, key),
68 .key_len = sizeof_field(struct mlxsw_sp_crif, key),
69 .head_offset = offsetof(struct mlxsw_sp_crif, ht_node),
73 struct mlxsw_sp_crif *crif; /* NULL for underlay RIF */
74 netdevice_tracker dev_tracker;
75 struct list_head neigh_list;
76 struct mlxsw_sp_fid *fid;
77 unsigned char addr[ETH_ALEN];
83 const struct mlxsw_sp_rif_ops *ops;
84 struct mlxsw_sp *mlxsw_sp;
86 unsigned int counter_ingress;
87 bool counter_ingress_valid;
88 unsigned int counter_egress;
89 bool counter_egress_valid;
92 static struct net_device *mlxsw_sp_rif_dev(const struct mlxsw_sp_rif *rif)
96 return rif->crif->key.dev;
99 struct mlxsw_sp_rif_params {
100 struct net_device *dev;
110 struct mlxsw_sp_rif_subport {
111 struct mlxsw_sp_rif common;
112 refcount_t ref_count;
121 struct mlxsw_sp_rif_ipip_lb {
122 struct mlxsw_sp_rif common;
123 struct mlxsw_sp_rif_ipip_lb_config lb_config;
124 u16 ul_vr_id; /* Spectrum-1. */
125 u16 ul_rif_id; /* Spectrum-2+. */
128 struct mlxsw_sp_rif_params_ipip_lb {
129 struct mlxsw_sp_rif_params common;
130 struct mlxsw_sp_rif_ipip_lb_config lb_config;
133 struct mlxsw_sp_rif_ops {
134 enum mlxsw_sp_rif_type type;
137 void (*setup)(struct mlxsw_sp_rif *rif,
138 const struct mlxsw_sp_rif_params *params);
139 int (*configure)(struct mlxsw_sp_rif *rif,
140 struct netlink_ext_ack *extack);
141 void (*deconfigure)(struct mlxsw_sp_rif *rif);
142 struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif,
143 const struct mlxsw_sp_rif_params *params,
144 struct netlink_ext_ack *extack);
145 void (*fdb_del)(struct mlxsw_sp_rif *rif, const char *mac);
148 struct mlxsw_sp_rif_mac_profile {
149 unsigned char mac_prefix[ETH_ALEN];
150 refcount_t ref_count;
154 struct mlxsw_sp_router_ops {
155 int (*init)(struct mlxsw_sp *mlxsw_sp);
156 int (*ipips_init)(struct mlxsw_sp *mlxsw_sp);
159 static struct mlxsw_sp_rif *
160 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
161 const struct net_device *dev);
162 static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif);
163 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree);
164 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
165 struct mlxsw_sp_lpm_tree *lpm_tree);
166 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
167 const struct mlxsw_sp_fib *fib,
169 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
170 const struct mlxsw_sp_fib *fib);
172 static unsigned int *
173 mlxsw_sp_rif_p_counter_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;
179 case MLXSW_SP_RIF_COUNTER_INGRESS:
180 return &rif->counter_ingress;
186 mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif,
187 enum mlxsw_sp_rif_counter_dir dir)
190 case MLXSW_SP_RIF_COUNTER_EGRESS:
191 return rif->counter_egress_valid;
192 case MLXSW_SP_RIF_COUNTER_INGRESS:
193 return rif->counter_ingress_valid;
199 mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
200 enum mlxsw_sp_rif_counter_dir dir,
204 case MLXSW_SP_RIF_COUNTER_EGRESS:
205 rif->counter_egress_valid = valid;
207 case MLXSW_SP_RIF_COUNTER_INGRESS:
208 rif->counter_ingress_valid = valid;
213 static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
214 unsigned int counter_index, bool enable,
215 enum mlxsw_sp_rif_counter_dir dir)
217 char ritr_pl[MLXSW_REG_RITR_LEN];
218 bool is_egress = false;
221 if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
223 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
224 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
228 mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
230 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
233 int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
234 struct mlxsw_sp_rif *rif,
235 enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
237 char ricnt_pl[MLXSW_REG_RICNT_LEN];
238 unsigned int *p_counter_index;
242 valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
246 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
247 if (!p_counter_index)
249 mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
250 MLXSW_REG_RICNT_OPCODE_NOP);
251 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
254 *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
258 struct mlxsw_sp_rif_counter_set_basic {
259 u64 good_unicast_packets;
260 u64 good_multicast_packets;
261 u64 good_broadcast_packets;
262 u64 good_unicast_bytes;
263 u64 good_multicast_bytes;
264 u64 good_broadcast_bytes;
272 mlxsw_sp_rif_counter_fetch_clear(struct mlxsw_sp_rif *rif,
273 enum mlxsw_sp_rif_counter_dir dir,
274 struct mlxsw_sp_rif_counter_set_basic *set)
276 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
277 char ricnt_pl[MLXSW_REG_RICNT_LEN];
278 unsigned int *p_counter_index;
281 if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
284 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
285 if (!p_counter_index)
288 mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
289 MLXSW_REG_RICNT_OPCODE_CLEAR);
290 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
297 #define MLXSW_SP_RIF_COUNTER_EXTRACT(NAME) \
298 (set->NAME = mlxsw_reg_ricnt_ ## NAME ## _get(ricnt_pl))
300 MLXSW_SP_RIF_COUNTER_EXTRACT(good_unicast_packets);
301 MLXSW_SP_RIF_COUNTER_EXTRACT(good_multicast_packets);
302 MLXSW_SP_RIF_COUNTER_EXTRACT(good_broadcast_packets);
303 MLXSW_SP_RIF_COUNTER_EXTRACT(good_unicast_bytes);
304 MLXSW_SP_RIF_COUNTER_EXTRACT(good_multicast_bytes);
305 MLXSW_SP_RIF_COUNTER_EXTRACT(good_broadcast_bytes);
306 MLXSW_SP_RIF_COUNTER_EXTRACT(error_packets);
307 MLXSW_SP_RIF_COUNTER_EXTRACT(discard_packets);
308 MLXSW_SP_RIF_COUNTER_EXTRACT(error_bytes);
309 MLXSW_SP_RIF_COUNTER_EXTRACT(discard_bytes);
311 #undef MLXSW_SP_RIF_COUNTER_EXTRACT
316 static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
317 unsigned int counter_index)
319 char ricnt_pl[MLXSW_REG_RICNT_LEN];
321 mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
322 MLXSW_REG_RICNT_OPCODE_CLEAR);
323 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
326 int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp_rif *rif,
327 enum mlxsw_sp_rif_counter_dir dir)
329 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
330 unsigned int *p_counter_index;
333 if (mlxsw_sp_rif_counter_valid_get(rif, dir))
336 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
337 if (!p_counter_index)
340 err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
345 err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
347 goto err_counter_clear;
349 err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
350 *p_counter_index, true, dir);
352 goto err_counter_edit;
353 mlxsw_sp_rif_counter_valid_set(rif, dir, true);
358 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
363 void mlxsw_sp_rif_counter_free(struct mlxsw_sp_rif *rif,
364 enum mlxsw_sp_rif_counter_dir dir)
366 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
367 unsigned int *p_counter_index;
369 if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
372 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
373 if (WARN_ON(!p_counter_index))
375 mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
376 *p_counter_index, false, dir);
377 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
379 mlxsw_sp_rif_counter_valid_set(rif, dir, false);
382 static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
384 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
385 struct devlink *devlink;
387 devlink = priv_to_devlink(mlxsw_sp->core);
388 if (!devlink_dpipe_table_counter_enabled(devlink,
389 MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
391 mlxsw_sp_rif_counter_alloc(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
394 static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
396 mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
399 #define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
401 struct mlxsw_sp_prefix_usage {
402 DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
405 #define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
406 for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
409 mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
410 struct mlxsw_sp_prefix_usage *prefix_usage2)
412 return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
416 mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
417 struct mlxsw_sp_prefix_usage *prefix_usage2)
419 memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
423 mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
424 unsigned char prefix_len)
426 set_bit(prefix_len, prefix_usage->b);
430 mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
431 unsigned char prefix_len)
433 clear_bit(prefix_len, prefix_usage->b);
436 struct mlxsw_sp_fib_key {
437 unsigned char addr[sizeof(struct in6_addr)];
438 unsigned char prefix_len;
441 enum mlxsw_sp_fib_entry_type {
442 MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
443 MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
444 MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
445 MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE,
446 MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE,
448 /* This is a special case of local delivery, where a packet should be
449 * decapsulated on reception. Note that there is no corresponding ENCAP,
450 * because that's a type of next hop, not of FIB entry. (There can be
451 * several next hops in a REMOTE entry, and some of them may be
452 * encapsulating entries.)
454 MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP,
455 MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP,
458 struct mlxsw_sp_nexthop_group_info;
459 struct mlxsw_sp_nexthop_group;
460 struct mlxsw_sp_fib_entry;
462 struct mlxsw_sp_fib_node {
463 struct mlxsw_sp_fib_entry *fib_entry;
464 struct list_head list;
465 struct rhash_head ht_node;
466 struct mlxsw_sp_fib *fib;
467 struct mlxsw_sp_fib_key key;
470 struct mlxsw_sp_fib_entry_decap {
471 struct mlxsw_sp_ipip_entry *ipip_entry;
475 struct mlxsw_sp_fib_entry {
476 struct mlxsw_sp_fib_node *fib_node;
477 enum mlxsw_sp_fib_entry_type type;
478 struct list_head nexthop_group_node;
479 struct mlxsw_sp_nexthop_group *nh_group;
480 struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */
483 struct mlxsw_sp_fib4_entry {
484 struct mlxsw_sp_fib_entry common;
491 struct mlxsw_sp_fib6_entry {
492 struct mlxsw_sp_fib_entry common;
493 struct list_head rt6_list;
497 struct mlxsw_sp_rt6 {
498 struct list_head list;
499 struct fib6_info *rt;
502 struct mlxsw_sp_lpm_tree {
504 refcount_t ref_count;
505 enum mlxsw_sp_l3proto proto;
506 unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
507 struct mlxsw_sp_prefix_usage prefix_usage;
510 struct mlxsw_sp_fib {
511 struct rhashtable ht;
512 struct list_head node_list;
513 struct mlxsw_sp_vr *vr;
514 struct mlxsw_sp_lpm_tree *lpm_tree;
515 enum mlxsw_sp_l3proto proto;
519 u16 id; /* virtual router ID */
520 u32 tb_id; /* kernel fib table id */
521 unsigned int rif_count;
522 struct mlxsw_sp_fib *fib4;
523 struct mlxsw_sp_fib *fib6;
524 struct mlxsw_sp_mr_table *mr_table[MLXSW_SP_L3_PROTO_MAX];
525 struct mlxsw_sp_rif *ul_rif;
526 refcount_t ul_rif_refcnt;
529 static const struct rhashtable_params mlxsw_sp_fib_ht_params;
531 static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp *mlxsw_sp,
532 struct mlxsw_sp_vr *vr,
533 enum mlxsw_sp_l3proto proto)
535 struct mlxsw_sp_lpm_tree *lpm_tree;
536 struct mlxsw_sp_fib *fib;
539 lpm_tree = mlxsw_sp->router->lpm.proto_trees[proto];
540 fib = kzalloc(sizeof(*fib), GFP_KERNEL);
542 return ERR_PTR(-ENOMEM);
543 err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
545 goto err_rhashtable_init;
546 INIT_LIST_HEAD(&fib->node_list);
549 fib->lpm_tree = lpm_tree;
550 mlxsw_sp_lpm_tree_hold(lpm_tree);
551 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, lpm_tree->id);
553 goto err_lpm_tree_bind;
557 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
563 static void mlxsw_sp_fib_destroy(struct mlxsw_sp *mlxsw_sp,
564 struct mlxsw_sp_fib *fib)
566 mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
567 mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree);
568 WARN_ON(!list_empty(&fib->node_list));
569 rhashtable_destroy(&fib->ht);
573 static struct mlxsw_sp_lpm_tree *
574 mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
576 static struct mlxsw_sp_lpm_tree *lpm_tree;
579 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
580 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
581 if (refcount_read(&lpm_tree->ref_count) == 0)
587 static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
588 struct mlxsw_sp_lpm_tree *lpm_tree)
590 char ralta_pl[MLXSW_REG_RALTA_LEN];
592 mlxsw_reg_ralta_pack(ralta_pl, true,
593 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
595 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
598 static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
599 struct mlxsw_sp_lpm_tree *lpm_tree)
601 char ralta_pl[MLXSW_REG_RALTA_LEN];
603 mlxsw_reg_ralta_pack(ralta_pl, false,
604 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
606 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
610 mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
611 struct mlxsw_sp_prefix_usage *prefix_usage,
612 struct mlxsw_sp_lpm_tree *lpm_tree)
614 char ralst_pl[MLXSW_REG_RALST_LEN];
617 u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
619 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
622 mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
623 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
626 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
627 MLXSW_REG_RALST_BIN_NO_CHILD);
628 last_prefix = prefix;
630 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
633 static struct mlxsw_sp_lpm_tree *
634 mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
635 struct mlxsw_sp_prefix_usage *prefix_usage,
636 enum mlxsw_sp_l3proto proto)
638 struct mlxsw_sp_lpm_tree *lpm_tree;
641 lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
643 return ERR_PTR(-EBUSY);
644 lpm_tree->proto = proto;
645 err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
649 err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
652 goto err_left_struct_set;
653 memcpy(&lpm_tree->prefix_usage, prefix_usage,
654 sizeof(lpm_tree->prefix_usage));
655 memset(&lpm_tree->prefix_ref_count, 0,
656 sizeof(lpm_tree->prefix_ref_count));
657 refcount_set(&lpm_tree->ref_count, 1);
661 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
665 static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
666 struct mlxsw_sp_lpm_tree *lpm_tree)
668 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
671 static struct mlxsw_sp_lpm_tree *
672 mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
673 struct mlxsw_sp_prefix_usage *prefix_usage,
674 enum mlxsw_sp_l3proto proto)
676 struct mlxsw_sp_lpm_tree *lpm_tree;
679 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
680 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
681 if (refcount_read(&lpm_tree->ref_count) &&
682 lpm_tree->proto == proto &&
683 mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
685 mlxsw_sp_lpm_tree_hold(lpm_tree);
689 return mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage, proto);
692 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree)
694 refcount_inc(&lpm_tree->ref_count);
697 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
698 struct mlxsw_sp_lpm_tree *lpm_tree)
700 if (!refcount_dec_and_test(&lpm_tree->ref_count))
702 mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
705 #define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
707 static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
709 struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
710 struct mlxsw_sp_lpm_tree *lpm_tree;
714 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
717 max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
718 mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
719 mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
720 sizeof(struct mlxsw_sp_lpm_tree),
722 if (!mlxsw_sp->router->lpm.trees)
725 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
726 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
727 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
730 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
731 MLXSW_SP_L3_PROTO_IPV4);
732 if (IS_ERR(lpm_tree)) {
733 err = PTR_ERR(lpm_tree);
734 goto err_ipv4_tree_get;
736 mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4] = lpm_tree;
738 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
739 MLXSW_SP_L3_PROTO_IPV6);
740 if (IS_ERR(lpm_tree)) {
741 err = PTR_ERR(lpm_tree);
742 goto err_ipv6_tree_get;
744 mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6] = lpm_tree;
749 lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4];
750 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
752 kfree(mlxsw_sp->router->lpm.trees);
756 static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
758 struct mlxsw_sp_lpm_tree *lpm_tree;
760 lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6];
761 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
763 lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4];
764 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
766 kfree(mlxsw_sp->router->lpm.trees);
769 static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
771 return !!vr->fib4 || !!vr->fib6 ||
772 !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] ||
773 !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV6];
776 static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
778 int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
779 struct mlxsw_sp_vr *vr;
782 for (i = 0; i < max_vrs; i++) {
783 vr = &mlxsw_sp->router->vrs[i];
784 if (!mlxsw_sp_vr_is_used(vr))
790 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
791 const struct mlxsw_sp_fib *fib, u8 tree_id)
793 char raltb_pl[MLXSW_REG_RALTB_LEN];
795 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
796 (enum mlxsw_reg_ralxx_protocol) fib->proto,
798 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
801 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
802 const struct mlxsw_sp_fib *fib)
804 char raltb_pl[MLXSW_REG_RALTB_LEN];
806 /* Bind to tree 0 which is default */
807 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
808 (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
809 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
812 static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
814 /* For our purpose, squash main, default and local tables into one */
815 if (tb_id == RT_TABLE_LOCAL || tb_id == RT_TABLE_DEFAULT)
816 tb_id = RT_TABLE_MAIN;
820 static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
823 int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
824 struct mlxsw_sp_vr *vr;
827 tb_id = mlxsw_sp_fix_tb_id(tb_id);
829 for (i = 0; i < max_vrs; i++) {
830 vr = &mlxsw_sp->router->vrs[i];
831 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
837 int mlxsw_sp_router_tb_id_vr_id(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
840 struct mlxsw_sp_vr *vr;
843 mutex_lock(&mlxsw_sp->router->lock);
844 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
851 mutex_unlock(&mlxsw_sp->router->lock);
855 static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
856 enum mlxsw_sp_l3proto proto)
859 case MLXSW_SP_L3_PROTO_IPV4:
861 case MLXSW_SP_L3_PROTO_IPV6:
867 static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
869 struct netlink_ext_ack *extack)
871 struct mlxsw_sp_mr_table *mr4_table, *mr6_table;
872 struct mlxsw_sp_fib *fib4;
873 struct mlxsw_sp_fib *fib6;
874 struct mlxsw_sp_vr *vr;
877 vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
879 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported virtual routers");
880 return ERR_PTR(-EBUSY);
882 fib4 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
884 return ERR_CAST(fib4);
885 fib6 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
888 goto err_fib6_create;
890 mr4_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
891 MLXSW_SP_L3_PROTO_IPV4);
892 if (IS_ERR(mr4_table)) {
893 err = PTR_ERR(mr4_table);
894 goto err_mr4_table_create;
896 mr6_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
897 MLXSW_SP_L3_PROTO_IPV6);
898 if (IS_ERR(mr6_table)) {
899 err = PTR_ERR(mr6_table);
900 goto err_mr6_table_create;
905 vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = mr4_table;
906 vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = mr6_table;
910 err_mr6_table_create:
911 mlxsw_sp_mr_table_destroy(mr4_table);
912 err_mr4_table_create:
913 mlxsw_sp_fib_destroy(mlxsw_sp, fib6);
915 mlxsw_sp_fib_destroy(mlxsw_sp, fib4);
919 static void mlxsw_sp_vr_destroy(struct mlxsw_sp *mlxsw_sp,
920 struct mlxsw_sp_vr *vr)
922 mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]);
923 vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = NULL;
924 mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]);
925 vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = NULL;
926 mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib6);
928 mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib4);
932 static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
933 struct netlink_ext_ack *extack)
935 struct mlxsw_sp_vr *vr;
937 tb_id = mlxsw_sp_fix_tb_id(tb_id);
938 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
940 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id, extack);
944 static void mlxsw_sp_vr_put(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr)
946 if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
947 list_empty(&vr->fib6->node_list) &&
948 mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]) &&
949 mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]))
950 mlxsw_sp_vr_destroy(mlxsw_sp, vr);
954 mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr,
955 enum mlxsw_sp_l3proto proto, u8 tree_id)
957 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
959 if (!mlxsw_sp_vr_is_used(vr))
961 if (fib->lpm_tree->id == tree_id)
966 static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
967 struct mlxsw_sp_fib *fib,
968 struct mlxsw_sp_lpm_tree *new_tree)
970 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
973 fib->lpm_tree = new_tree;
974 mlxsw_sp_lpm_tree_hold(new_tree);
975 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
978 mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
982 mlxsw_sp_lpm_tree_put(mlxsw_sp, new_tree);
983 fib->lpm_tree = old_tree;
987 static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
988 struct mlxsw_sp_fib *fib,
989 struct mlxsw_sp_lpm_tree *new_tree)
991 int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
992 enum mlxsw_sp_l3proto proto = fib->proto;
993 struct mlxsw_sp_lpm_tree *old_tree;
994 u8 old_id, new_id = new_tree->id;
995 struct mlxsw_sp_vr *vr;
998 old_tree = mlxsw_sp->router->lpm.proto_trees[proto];
999 old_id = old_tree->id;
1001 for (i = 0; i < max_vrs; i++) {
1002 vr = &mlxsw_sp->router->vrs[i];
1003 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id))
1005 err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
1006 mlxsw_sp_vr_fib(vr, proto),
1009 goto err_tree_replace;
1012 memcpy(new_tree->prefix_ref_count, old_tree->prefix_ref_count,
1013 sizeof(new_tree->prefix_ref_count));
1014 mlxsw_sp->router->lpm.proto_trees[proto] = new_tree;
1015 mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
1020 for (i--; i >= 0; i--) {
1021 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id))
1023 mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
1024 mlxsw_sp_vr_fib(vr, proto),
1030 static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
1032 struct mlxsw_sp_vr *vr;
1036 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
1039 max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
1040 mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
1042 if (!mlxsw_sp->router->vrs)
1045 for (i = 0; i < max_vrs; i++) {
1046 vr = &mlxsw_sp->router->vrs[i];
1053 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
1055 static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
1057 /* At this stage we're guaranteed not to have new incoming
1058 * FIB notifications and the work queue is free from FIBs
1059 * sitting on top of mlxsw netdevs. However, we can still
1060 * have other FIBs queued. Flush the queue before flushing
1061 * the device's tables. No need for locks, as we're the only
1064 mlxsw_core_flush_owq();
1065 mlxsw_sp_router_fib_flush(mlxsw_sp);
1066 kfree(mlxsw_sp->router->vrs);
1069 u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev)
1071 struct net_device *d;
1075 d = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
1077 tb_id = l3mdev_fib_table(d) ? : RT_TABLE_MAIN;
1079 tb_id = RT_TABLE_MAIN;
1086 mlxsw_sp_crif_init(struct mlxsw_sp_crif *crif, struct net_device *dev)
1088 crif->key.dev = dev;
1089 INIT_LIST_HEAD(&crif->nexthop_list);
1092 static struct mlxsw_sp_crif *
1093 mlxsw_sp_crif_alloc(struct net_device *dev)
1095 struct mlxsw_sp_crif *crif;
1097 crif = kzalloc(sizeof(*crif), GFP_KERNEL);
1101 mlxsw_sp_crif_init(crif, dev);
1105 static void mlxsw_sp_crif_free(struct mlxsw_sp_crif *crif)
1107 if (WARN_ON(crif->rif))
1110 WARN_ON(!list_empty(&crif->nexthop_list));
1114 static int mlxsw_sp_crif_insert(struct mlxsw_sp_router *router,
1115 struct mlxsw_sp_crif *crif)
1117 return rhashtable_insert_fast(&router->crif_ht, &crif->ht_node,
1118 mlxsw_sp_crif_ht_params);
1121 static void mlxsw_sp_crif_remove(struct mlxsw_sp_router *router,
1122 struct mlxsw_sp_crif *crif)
1124 rhashtable_remove_fast(&router->crif_ht, &crif->ht_node,
1125 mlxsw_sp_crif_ht_params);
1128 static struct mlxsw_sp_crif *
1129 mlxsw_sp_crif_lookup(struct mlxsw_sp_router *router,
1130 const struct net_device *dev)
1132 struct mlxsw_sp_crif_key key = {
1133 .dev = (struct net_device *)dev,
1136 return rhashtable_lookup_fast(&router->crif_ht, &key,
1137 mlxsw_sp_crif_ht_params);
1140 static struct mlxsw_sp_rif *
1141 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
1142 const struct mlxsw_sp_rif_params *params,
1143 struct netlink_ext_ack *extack);
1145 static struct mlxsw_sp_rif_ipip_lb *
1146 mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp,
1147 enum mlxsw_sp_ipip_type ipipt,
1148 struct net_device *ol_dev,
1149 struct netlink_ext_ack *extack)
1151 struct mlxsw_sp_rif_params_ipip_lb lb_params;
1152 const struct mlxsw_sp_ipip_ops *ipip_ops;
1153 struct mlxsw_sp_rif *rif;
1155 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1156 lb_params = (struct mlxsw_sp_rif_params_ipip_lb) {
1157 .common.dev = ol_dev,
1158 .common.lag = false,
1159 .common.double_entry = ipip_ops->double_rif_entry,
1160 .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev),
1163 rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common, extack);
1165 return ERR_CAST(rif);
1166 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
1169 static struct mlxsw_sp_ipip_entry *
1170 mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp,
1171 enum mlxsw_sp_ipip_type ipipt,
1172 struct net_device *ol_dev)
1174 const struct mlxsw_sp_ipip_ops *ipip_ops;
1175 struct mlxsw_sp_ipip_entry *ipip_entry;
1176 struct mlxsw_sp_ipip_entry *ret = NULL;
1179 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1180 ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL);
1182 return ERR_PTR(-ENOMEM);
1184 ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt,
1186 if (IS_ERR(ipip_entry->ol_lb)) {
1187 ret = ERR_CAST(ipip_entry->ol_lb);
1188 goto err_ol_ipip_lb_create;
1191 ipip_entry->ipipt = ipipt;
1192 ipip_entry->ol_dev = ol_dev;
1193 ipip_entry->parms = ipip_ops->parms_init(ol_dev);
1195 err = ipip_ops->rem_ip_addr_set(mlxsw_sp, ipip_entry);
1198 goto err_rem_ip_addr_set;
1203 err_rem_ip_addr_set:
1204 mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
1205 err_ol_ipip_lb_create:
1210 static void mlxsw_sp_ipip_entry_dealloc(struct mlxsw_sp *mlxsw_sp,
1211 struct mlxsw_sp_ipip_entry *ipip_entry)
1213 const struct mlxsw_sp_ipip_ops *ipip_ops =
1214 mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1216 ipip_ops->rem_ip_addr_unset(mlxsw_sp, ipip_entry);
1217 mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
1222 mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp,
1223 const enum mlxsw_sp_l3proto ul_proto,
1224 union mlxsw_sp_l3addr saddr,
1226 struct mlxsw_sp_ipip_entry *ipip_entry)
1228 u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1229 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1230 union mlxsw_sp_l3addr tun_saddr;
1232 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1235 tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1236 return tun_ul_tb_id == ul_tb_id &&
1237 mlxsw_sp_l3addr_eq(&tun_saddr, &saddr);
1240 static int mlxsw_sp_ipip_decap_parsing_depth_inc(struct mlxsw_sp *mlxsw_sp,
1241 enum mlxsw_sp_ipip_type ipipt)
1243 const struct mlxsw_sp_ipip_ops *ipip_ops;
1245 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1247 /* Not all tunnels require to increase the default pasing depth
1250 if (ipip_ops->inc_parsing_depth)
1251 return mlxsw_sp_parsing_depth_inc(mlxsw_sp);
1256 static void mlxsw_sp_ipip_decap_parsing_depth_dec(struct mlxsw_sp *mlxsw_sp,
1257 enum mlxsw_sp_ipip_type ipipt)
1259 const struct mlxsw_sp_ipip_ops *ipip_ops =
1260 mlxsw_sp->router->ipip_ops_arr[ipipt];
1262 if (ipip_ops->inc_parsing_depth)
1263 mlxsw_sp_parsing_depth_dec(mlxsw_sp);
1267 mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp,
1268 struct mlxsw_sp_fib_entry *fib_entry,
1269 struct mlxsw_sp_ipip_entry *ipip_entry)
1274 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
1279 err = mlxsw_sp_ipip_decap_parsing_depth_inc(mlxsw_sp,
1282 goto err_parsing_depth_inc;
1284 ipip_entry->decap_fib_entry = fib_entry;
1285 fib_entry->decap.ipip_entry = ipip_entry;
1286 fib_entry->decap.tunnel_index = tunnel_index;
1290 err_parsing_depth_inc:
1291 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
1292 fib_entry->decap.tunnel_index);
1296 static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp,
1297 struct mlxsw_sp_fib_entry *fib_entry)
1299 enum mlxsw_sp_ipip_type ipipt = fib_entry->decap.ipip_entry->ipipt;
1301 /* Unlink this node from the IPIP entry that it's the decap entry of. */
1302 fib_entry->decap.ipip_entry->decap_fib_entry = NULL;
1303 fib_entry->decap.ipip_entry = NULL;
1304 mlxsw_sp_ipip_decap_parsing_depth_dec(mlxsw_sp, ipipt);
1305 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
1306 1, fib_entry->decap.tunnel_index);
1309 static struct mlxsw_sp_fib_node *
1310 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
1311 size_t addr_len, unsigned char prefix_len);
1312 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1313 struct mlxsw_sp_fib_entry *fib_entry);
1316 mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp,
1317 struct mlxsw_sp_ipip_entry *ipip_entry)
1319 struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry;
1321 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
1322 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1324 mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1328 mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp,
1329 struct mlxsw_sp_ipip_entry *ipip_entry,
1330 struct mlxsw_sp_fib_entry *decap_fib_entry)
1332 if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry,
1335 decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
1337 if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry))
1338 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1341 static struct mlxsw_sp_fib_entry *
1342 mlxsw_sp_router_ip2me_fib_entry_find(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
1343 enum mlxsw_sp_l3proto proto,
1344 const union mlxsw_sp_l3addr *addr,
1345 enum mlxsw_sp_fib_entry_type type)
1347 struct mlxsw_sp_fib_node *fib_node;
1348 unsigned char addr_prefix_len;
1349 struct mlxsw_sp_fib *fib;
1350 struct mlxsw_sp_vr *vr;
1355 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
1358 fib = mlxsw_sp_vr_fib(vr, proto);
1361 case MLXSW_SP_L3_PROTO_IPV4:
1362 addr4 = be32_to_cpu(addr->addr4);
1365 addr_prefix_len = 32;
1367 case MLXSW_SP_L3_PROTO_IPV6:
1368 addrp = &addr->addr6;
1370 addr_prefix_len = 128;
1377 fib_node = mlxsw_sp_fib_node_lookup(fib, addrp, addr_len,
1379 if (!fib_node || fib_node->fib_entry->type != type)
1382 return fib_node->fib_entry;
1385 /* Given an IPIP entry, find the corresponding decap route. */
1386 static struct mlxsw_sp_fib_entry *
1387 mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp,
1388 struct mlxsw_sp_ipip_entry *ipip_entry)
1390 static struct mlxsw_sp_fib_node *fib_node;
1391 const struct mlxsw_sp_ipip_ops *ipip_ops;
1392 unsigned char saddr_prefix_len;
1393 union mlxsw_sp_l3addr saddr;
1394 struct mlxsw_sp_fib *ul_fib;
1395 struct mlxsw_sp_vr *ul_vr;
1401 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1403 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1404 ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id);
1408 ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto);
1409 saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto,
1410 ipip_entry->ol_dev);
1412 switch (ipip_ops->ul_proto) {
1413 case MLXSW_SP_L3_PROTO_IPV4:
1414 saddr4 = be32_to_cpu(saddr.addr4);
1417 saddr_prefix_len = 32;
1419 case MLXSW_SP_L3_PROTO_IPV6:
1420 saddrp = &saddr.addr6;
1422 saddr_prefix_len = 128;
1429 fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len,
1432 fib_node->fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP)
1435 return fib_node->fib_entry;
1438 static struct mlxsw_sp_ipip_entry *
1439 mlxsw_sp_ipip_entry_create(struct mlxsw_sp *mlxsw_sp,
1440 enum mlxsw_sp_ipip_type ipipt,
1441 struct net_device *ol_dev)
1443 struct mlxsw_sp_ipip_entry *ipip_entry;
1445 ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev);
1446 if (IS_ERR(ipip_entry))
1449 list_add_tail(&ipip_entry->ipip_list_node,
1450 &mlxsw_sp->router->ipip_list);
1456 mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1457 struct mlxsw_sp_ipip_entry *ipip_entry)
1459 list_del(&ipip_entry->ipip_list_node);
1460 mlxsw_sp_ipip_entry_dealloc(mlxsw_sp, ipip_entry);
1464 mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp,
1465 const struct net_device *ul_dev,
1466 enum mlxsw_sp_l3proto ul_proto,
1467 union mlxsw_sp_l3addr ul_dip,
1468 struct mlxsw_sp_ipip_entry *ipip_entry)
1470 u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1471 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1473 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1476 return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip,
1477 ul_tb_id, ipip_entry);
1480 /* Given decap parameters, find the corresponding IPIP entry. */
1481 static struct mlxsw_sp_ipip_entry *
1482 mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp, int ul_dev_ifindex,
1483 enum mlxsw_sp_l3proto ul_proto,
1484 union mlxsw_sp_l3addr ul_dip)
1486 struct mlxsw_sp_ipip_entry *ipip_entry = NULL;
1487 struct net_device *ul_dev;
1491 ul_dev = dev_get_by_index_rcu(mlxsw_sp_net(mlxsw_sp), ul_dev_ifindex);
1495 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1497 if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev,
1511 static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp,
1512 const struct net_device *dev,
1513 enum mlxsw_sp_ipip_type *p_type)
1515 struct mlxsw_sp_router *router = mlxsw_sp->router;
1516 const struct mlxsw_sp_ipip_ops *ipip_ops;
1517 enum mlxsw_sp_ipip_type ipipt;
1519 for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) {
1520 ipip_ops = router->ipip_ops_arr[ipipt];
1521 if (dev->type == ipip_ops->dev_type) {
1530 static bool mlxsw_sp_netdev_is_ipip_ol(const struct mlxsw_sp *mlxsw_sp,
1531 const struct net_device *dev)
1533 return mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL);
1536 static struct mlxsw_sp_ipip_entry *
1537 mlxsw_sp_ipip_entry_find_by_ol_dev(struct mlxsw_sp *mlxsw_sp,
1538 const struct net_device *ol_dev)
1540 struct mlxsw_sp_ipip_entry *ipip_entry;
1542 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1544 if (ipip_entry->ol_dev == ol_dev)
1550 static struct mlxsw_sp_ipip_entry *
1551 mlxsw_sp_ipip_entry_find_by_ul_dev(const struct mlxsw_sp *mlxsw_sp,
1552 const struct net_device *ul_dev,
1553 struct mlxsw_sp_ipip_entry *start)
1555 struct mlxsw_sp_ipip_entry *ipip_entry;
1557 ipip_entry = list_prepare_entry(start, &mlxsw_sp->router->ipip_list,
1559 list_for_each_entry_continue(ipip_entry, &mlxsw_sp->router->ipip_list,
1561 struct net_device *ol_dev = ipip_entry->ol_dev;
1562 struct net_device *ipip_ul_dev;
1565 ipip_ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
1568 if (ipip_ul_dev == ul_dev)
1575 static bool mlxsw_sp_netdev_is_ipip_ul(struct mlxsw_sp *mlxsw_sp,
1576 const struct net_device *dev)
1578 return mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp, dev, NULL);
1581 static bool mlxsw_sp_netdevice_ipip_can_offload(struct mlxsw_sp *mlxsw_sp,
1582 const struct net_device *ol_dev,
1583 enum mlxsw_sp_ipip_type ipipt)
1585 const struct mlxsw_sp_ipip_ops *ops
1586 = mlxsw_sp->router->ipip_ops_arr[ipipt];
1588 return ops->can_offload(mlxsw_sp, ol_dev);
1591 static int mlxsw_sp_netdevice_ipip_ol_reg_event(struct mlxsw_sp *mlxsw_sp,
1592 struct net_device *ol_dev)
1594 enum mlxsw_sp_ipip_type ipipt = MLXSW_SP_IPIP_TYPE_MAX;
1595 struct mlxsw_sp_ipip_entry *ipip_entry;
1596 enum mlxsw_sp_l3proto ul_proto;
1597 union mlxsw_sp_l3addr saddr;
1600 mlxsw_sp_netdev_ipip_type(mlxsw_sp, ol_dev, &ipipt);
1601 if (mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev, ipipt)) {
1602 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev);
1603 ul_proto = mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto;
1604 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev);
1605 if (!mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto,
1608 ipip_entry = mlxsw_sp_ipip_entry_create(mlxsw_sp, ipipt,
1610 if (IS_ERR(ipip_entry))
1611 return PTR_ERR(ipip_entry);
1618 static void mlxsw_sp_netdevice_ipip_ol_unreg_event(struct mlxsw_sp *mlxsw_sp,
1619 struct net_device *ol_dev)
1621 struct mlxsw_sp_ipip_entry *ipip_entry;
1623 ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1625 mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry);
1629 mlxsw_sp_ipip_entry_ol_up_event(struct mlxsw_sp *mlxsw_sp,
1630 struct mlxsw_sp_ipip_entry *ipip_entry)
1632 struct mlxsw_sp_fib_entry *decap_fib_entry;
1634 decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry);
1635 if (decap_fib_entry)
1636 mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry,
1641 mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif, u16 ul_vr_id,
1642 u16 ul_rif_id, bool enable)
1644 struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config;
1645 struct net_device *dev = mlxsw_sp_rif_dev(&lb_rif->common);
1646 enum mlxsw_reg_ritr_loopback_ipip_options ipip_options;
1647 struct mlxsw_sp_rif *rif = &lb_rif->common;
1648 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
1649 char ritr_pl[MLXSW_REG_RITR_LEN];
1650 struct in6_addr *saddr6;
1653 ipip_options = MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET;
1654 switch (lb_cf.ul_protocol) {
1655 case MLXSW_SP_L3_PROTO_IPV4:
1656 saddr4 = be32_to_cpu(lb_cf.saddr.addr4);
1657 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
1658 rif->rif_index, rif->vr_id, dev->mtu);
1659 mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt,
1660 ipip_options, ul_vr_id,
1665 case MLXSW_SP_L3_PROTO_IPV6:
1666 saddr6 = &lb_cf.saddr.addr6;
1667 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
1668 rif->rif_index, rif->vr_id, dev->mtu);
1669 mlxsw_reg_ritr_loopback_ipip6_pack(ritr_pl, lb_cf.lb_ipipt,
1670 ipip_options, ul_vr_id,
1676 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
1679 static int mlxsw_sp_netdevice_ipip_ol_update_mtu(struct mlxsw_sp *mlxsw_sp,
1680 struct net_device *ol_dev)
1682 struct mlxsw_sp_ipip_entry *ipip_entry;
1683 struct mlxsw_sp_rif_ipip_lb *lb_rif;
1686 ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1688 lb_rif = ipip_entry->ol_lb;
1689 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, lb_rif->ul_vr_id,
1690 lb_rif->ul_rif_id, true);
1693 lb_rif->common.mtu = ol_dev->mtu;
1700 static void mlxsw_sp_netdevice_ipip_ol_up_event(struct mlxsw_sp *mlxsw_sp,
1701 struct net_device *ol_dev)
1703 struct mlxsw_sp_ipip_entry *ipip_entry;
1705 ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1707 mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry);
1711 mlxsw_sp_ipip_entry_ol_down_event(struct mlxsw_sp *mlxsw_sp,
1712 struct mlxsw_sp_ipip_entry *ipip_entry)
1714 if (ipip_entry->decap_fib_entry)
1715 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1718 static void mlxsw_sp_netdevice_ipip_ol_down_event(struct mlxsw_sp *mlxsw_sp,
1719 struct net_device *ol_dev)
1721 struct mlxsw_sp_ipip_entry *ipip_entry;
1723 ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1725 mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry);
1728 static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp,
1729 struct mlxsw_sp_rif *rif);
1731 static void mlxsw_sp_rif_migrate_destroy(struct mlxsw_sp *mlxsw_sp,
1732 struct mlxsw_sp_rif *old_rif,
1733 struct mlxsw_sp_rif *new_rif,
1736 struct mlxsw_sp_crif *crif = old_rif->crif;
1737 struct mlxsw_sp_crif mock_crif = {};
1740 mlxsw_sp_nexthop_rif_update(mlxsw_sp, new_rif);
1742 /* Plant a mock CRIF so that destroying the old RIF doesn't unoffload
1743 * our nexthops and IPIP tunnels, and doesn't sever the crif->rif link.
1745 mlxsw_sp_crif_init(&mock_crif, crif->key.dev);
1746 old_rif->crif = &mock_crif;
1747 mock_crif.rif = old_rif;
1748 mlxsw_sp_rif_destroy(old_rif);
1752 mlxsw_sp_ipip_entry_ol_lb_update(struct mlxsw_sp *mlxsw_sp,
1753 struct mlxsw_sp_ipip_entry *ipip_entry,
1755 struct netlink_ext_ack *extack)
1757 struct mlxsw_sp_rif_ipip_lb *old_lb_rif = ipip_entry->ol_lb;
1758 struct mlxsw_sp_rif_ipip_lb *new_lb_rif;
1760 new_lb_rif = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp,
1764 if (IS_ERR(new_lb_rif))
1765 return PTR_ERR(new_lb_rif);
1766 ipip_entry->ol_lb = new_lb_rif;
1768 mlxsw_sp_rif_migrate_destroy(mlxsw_sp, &old_lb_rif->common,
1769 &new_lb_rif->common, keep_encap);
1774 * __mlxsw_sp_ipip_entry_update_tunnel - Update offload related to IPIP entry.
1775 * @mlxsw_sp: mlxsw_sp.
1776 * @ipip_entry: IPIP entry.
1777 * @recreate_loopback: Recreates the associated loopback RIF.
1778 * @keep_encap: Updates next hops that use the tunnel netdevice. This is only
1779 * relevant when recreate_loopback is true.
1780 * @update_nexthops: Updates next hops, keeping the current loopback RIF. This
1781 * is only relevant when recreate_loopback is false.
1784 * Return: Non-zero value on failure.
1786 int __mlxsw_sp_ipip_entry_update_tunnel(struct mlxsw_sp *mlxsw_sp,
1787 struct mlxsw_sp_ipip_entry *ipip_entry,
1788 bool recreate_loopback,
1790 bool update_nexthops,
1791 struct netlink_ext_ack *extack)
1795 /* RIFs can't be edited, so to update loopback, we need to destroy and
1796 * recreate it. That creates a window of opportunity where RALUE and
1797 * RATR registers end up referencing a RIF that's already gone. RATRs
1798 * are handled in mlxsw_sp_ipip_entry_ol_lb_update(), and to take care
1799 * of RALUE, demote the decap route back.
1801 if (ipip_entry->decap_fib_entry)
1802 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1804 if (recreate_loopback) {
1805 err = mlxsw_sp_ipip_entry_ol_lb_update(mlxsw_sp, ipip_entry,
1806 keep_encap, extack);
1809 } else if (update_nexthops) {
1810 mlxsw_sp_nexthop_rif_update(mlxsw_sp,
1811 &ipip_entry->ol_lb->common);
1814 if (ipip_entry->ol_dev->flags & IFF_UP)
1815 mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry);
1820 static int mlxsw_sp_netdevice_ipip_ol_vrf_event(struct mlxsw_sp *mlxsw_sp,
1821 struct net_device *ol_dev,
1822 struct netlink_ext_ack *extack)
1824 struct mlxsw_sp_ipip_entry *ipip_entry =
1825 mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1830 return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1831 true, false, false, extack);
1835 mlxsw_sp_netdevice_ipip_ul_vrf_event(struct mlxsw_sp *mlxsw_sp,
1836 struct mlxsw_sp_ipip_entry *ipip_entry,
1837 struct net_device *ul_dev,
1839 struct netlink_ext_ack *extack)
1841 u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1842 enum mlxsw_sp_l3proto ul_proto;
1843 union mlxsw_sp_l3addr saddr;
1845 /* Moving underlay to a different VRF might cause local address
1846 * conflict, and the conflicting tunnels need to be demoted.
1848 ul_proto = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt]->ul_proto;
1849 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1850 if (mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto,
1853 *demote_this = true;
1857 return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1858 true, true, false, extack);
1862 mlxsw_sp_netdevice_ipip_ul_up_event(struct mlxsw_sp *mlxsw_sp,
1863 struct mlxsw_sp_ipip_entry *ipip_entry,
1864 struct net_device *ul_dev)
1866 return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1867 false, false, true, NULL);
1871 mlxsw_sp_netdevice_ipip_ul_down_event(struct mlxsw_sp *mlxsw_sp,
1872 struct mlxsw_sp_ipip_entry *ipip_entry,
1873 struct net_device *ul_dev)
1875 /* A down underlay device causes encapsulated packets to not be
1876 * forwarded, but decap still works. So refresh next hops without
1877 * touching anything else.
1879 return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1880 false, false, true, NULL);
1884 mlxsw_sp_netdevice_ipip_ol_change_event(struct mlxsw_sp *mlxsw_sp,
1885 struct net_device *ol_dev,
1886 struct netlink_ext_ack *extack)
1888 const struct mlxsw_sp_ipip_ops *ipip_ops;
1889 struct mlxsw_sp_ipip_entry *ipip_entry;
1892 ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1894 /* A change might make a tunnel eligible for offloading, but
1895 * that is currently not implemented. What falls to slow path
1900 /* A change might make a tunnel not eligible for offloading. */
1901 if (!mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev,
1902 ipip_entry->ipipt)) {
1903 mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1907 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1908 err = ipip_ops->ol_netdev_change(mlxsw_sp, ipip_entry, extack);
1912 void mlxsw_sp_ipip_entry_demote_tunnel(struct mlxsw_sp *mlxsw_sp,
1913 struct mlxsw_sp_ipip_entry *ipip_entry)
1915 struct net_device *ol_dev = ipip_entry->ol_dev;
1917 if (ol_dev->flags & IFF_UP)
1918 mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry);
1919 mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry);
1922 /* The configuration where several tunnels have the same local address in the
1923 * same underlay table needs special treatment in the HW. That is currently not
1924 * implemented in the driver. This function finds and demotes the first tunnel
1925 * with a given source address, except the one passed in the argument
1929 mlxsw_sp_ipip_demote_tunnel_by_saddr(struct mlxsw_sp *mlxsw_sp,
1930 enum mlxsw_sp_l3proto ul_proto,
1931 union mlxsw_sp_l3addr saddr,
1933 const struct mlxsw_sp_ipip_entry *except)
1935 struct mlxsw_sp_ipip_entry *ipip_entry, *tmp;
1937 list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list,
1939 if (ipip_entry != except &&
1940 mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr,
1941 ul_tb_id, ipip_entry)) {
1942 mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1950 static void mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(struct mlxsw_sp *mlxsw_sp,
1951 struct net_device *ul_dev)
1953 struct mlxsw_sp_ipip_entry *ipip_entry, *tmp;
1955 list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list,
1957 struct net_device *ol_dev = ipip_entry->ol_dev;
1958 struct net_device *ipip_ul_dev;
1961 ipip_ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
1963 if (ipip_ul_dev == ul_dev)
1964 mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1968 static int mlxsw_sp_netdevice_ipip_ol_event(struct mlxsw_sp *mlxsw_sp,
1969 struct net_device *ol_dev,
1970 unsigned long event,
1971 struct netdev_notifier_info *info)
1973 struct netdev_notifier_changeupper_info *chup;
1974 struct netlink_ext_ack *extack;
1978 case NETDEV_REGISTER:
1979 err = mlxsw_sp_netdevice_ipip_ol_reg_event(mlxsw_sp, ol_dev);
1981 case NETDEV_UNREGISTER:
1982 mlxsw_sp_netdevice_ipip_ol_unreg_event(mlxsw_sp, ol_dev);
1985 mlxsw_sp_netdevice_ipip_ol_up_event(mlxsw_sp, ol_dev);
1988 mlxsw_sp_netdevice_ipip_ol_down_event(mlxsw_sp, ol_dev);
1990 case NETDEV_CHANGEUPPER:
1991 chup = container_of(info, typeof(*chup), info);
1992 extack = info->extack;
1993 if (netif_is_l3_master(chup->upper_dev))
1994 err = mlxsw_sp_netdevice_ipip_ol_vrf_event(mlxsw_sp,
1999 extack = info->extack;
2000 err = mlxsw_sp_netdevice_ipip_ol_change_event(mlxsw_sp,
2003 case NETDEV_CHANGEMTU:
2004 err = mlxsw_sp_netdevice_ipip_ol_update_mtu(mlxsw_sp, ol_dev);
2011 __mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp,
2012 struct mlxsw_sp_ipip_entry *ipip_entry,
2013 struct net_device *ul_dev,
2015 unsigned long event,
2016 struct netdev_notifier_info *info)
2018 struct netdev_notifier_changeupper_info *chup;
2019 struct netlink_ext_ack *extack;
2022 case NETDEV_CHANGEUPPER:
2023 chup = container_of(info, typeof(*chup), info);
2024 extack = info->extack;
2025 if (netif_is_l3_master(chup->upper_dev))
2026 return mlxsw_sp_netdevice_ipip_ul_vrf_event(mlxsw_sp,
2034 return mlxsw_sp_netdevice_ipip_ul_up_event(mlxsw_sp, ipip_entry,
2037 return mlxsw_sp_netdevice_ipip_ul_down_event(mlxsw_sp,
2045 mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp,
2046 struct net_device *ul_dev,
2047 unsigned long event,
2048 struct netdev_notifier_info *info)
2050 struct mlxsw_sp_ipip_entry *ipip_entry = NULL;
2053 while ((ipip_entry = mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp,
2056 struct mlxsw_sp_ipip_entry *prev;
2057 bool demote_this = false;
2059 err = __mlxsw_sp_netdevice_ipip_ul_event(mlxsw_sp, ipip_entry,
2060 ul_dev, &demote_this,
2063 mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(mlxsw_sp,
2069 if (list_is_first(&ipip_entry->ipip_list_node,
2070 &mlxsw_sp->router->ipip_list))
2073 /* This can't be cached from previous iteration,
2074 * because that entry could be gone now.
2076 prev = list_prev_entry(ipip_entry,
2078 mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
2086 int mlxsw_sp_router_nve_promote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
2087 enum mlxsw_sp_l3proto ul_proto,
2088 const union mlxsw_sp_l3addr *ul_sip,
2091 enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2092 struct mlxsw_sp_router *router = mlxsw_sp->router;
2093 struct mlxsw_sp_fib_entry *fib_entry;
2096 mutex_lock(&mlxsw_sp->router->lock);
2098 if (WARN_ON_ONCE(router->nve_decap_config.valid)) {
2103 router->nve_decap_config.ul_tb_id = ul_tb_id;
2104 router->nve_decap_config.tunnel_index = tunnel_index;
2105 router->nve_decap_config.ul_proto = ul_proto;
2106 router->nve_decap_config.ul_sip = *ul_sip;
2107 router->nve_decap_config.valid = true;
2109 /* It is valid to create a tunnel with a local IP and only later
2110 * assign this IP address to a local interface
2112 fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id,
2118 fib_entry->decap.tunnel_index = tunnel_index;
2119 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
2121 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2123 goto err_fib_entry_update;
2127 err_fib_entry_update:
2128 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2129 mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2131 mutex_unlock(&mlxsw_sp->router->lock);
2135 void mlxsw_sp_router_nve_demote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
2136 enum mlxsw_sp_l3proto ul_proto,
2137 const union mlxsw_sp_l3addr *ul_sip)
2139 enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
2140 struct mlxsw_sp_router *router = mlxsw_sp->router;
2141 struct mlxsw_sp_fib_entry *fib_entry;
2143 mutex_lock(&mlxsw_sp->router->lock);
2145 if (WARN_ON_ONCE(!router->nve_decap_config.valid))
2148 router->nve_decap_config.valid = false;
2150 fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id,
2156 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2157 mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2159 mutex_unlock(&mlxsw_sp->router->lock);
2162 static bool mlxsw_sp_router_nve_is_decap(struct mlxsw_sp *mlxsw_sp,
2164 enum mlxsw_sp_l3proto ul_proto,
2165 const union mlxsw_sp_l3addr *ul_sip)
2167 struct mlxsw_sp_router *router = mlxsw_sp->router;
2169 return router->nve_decap_config.valid &&
2170 router->nve_decap_config.ul_tb_id == ul_tb_id &&
2171 router->nve_decap_config.ul_proto == ul_proto &&
2172 !memcmp(&router->nve_decap_config.ul_sip, ul_sip,
2176 struct mlxsw_sp_neigh_key {
2177 struct neighbour *n;
2180 struct mlxsw_sp_neigh_entry {
2181 struct list_head rif_list_node;
2182 struct rhash_head ht_node;
2183 struct mlxsw_sp_neigh_key key;
2186 unsigned char ha[ETH_ALEN];
2187 struct list_head nexthop_list; /* list of nexthops using
2190 struct list_head nexthop_neighs_list_node;
2191 unsigned int counter_index;
2195 static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
2196 .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
2197 .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
2198 .key_len = sizeof(struct mlxsw_sp_neigh_key),
2201 struct mlxsw_sp_neigh_entry *
2202 mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif,
2203 struct mlxsw_sp_neigh_entry *neigh_entry)
2206 if (list_empty(&rif->neigh_list))
2209 return list_first_entry(&rif->neigh_list,
2210 typeof(*neigh_entry),
2213 if (list_is_last(&neigh_entry->rif_list_node, &rif->neigh_list))
2215 return list_next_entry(neigh_entry, rif_list_node);
2218 int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry)
2220 return neigh_entry->key.n->tbl->family;
2224 mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry)
2226 return neigh_entry->ha;
2229 u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
2231 struct neighbour *n;
2233 n = neigh_entry->key.n;
2234 return ntohl(*((__be32 *) n->primary_key));
2238 mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
2240 struct neighbour *n;
2242 n = neigh_entry->key.n;
2243 return (struct in6_addr *) &n->primary_key;
2246 int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp,
2247 struct mlxsw_sp_neigh_entry *neigh_entry,
2250 if (!neigh_entry->counter_valid)
2253 return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index,
2257 static struct mlxsw_sp_neigh_entry *
2258 mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
2261 struct mlxsw_sp_neigh_entry *neigh_entry;
2263 neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
2267 neigh_entry->key.n = n;
2268 neigh_entry->rif = rif;
2269 INIT_LIST_HEAD(&neigh_entry->nexthop_list);
2274 static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
2280 mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
2281 struct mlxsw_sp_neigh_entry *neigh_entry)
2283 return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
2284 &neigh_entry->ht_node,
2285 mlxsw_sp_neigh_ht_params);
2289 mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
2290 struct mlxsw_sp_neigh_entry *neigh_entry)
2292 rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
2293 &neigh_entry->ht_node,
2294 mlxsw_sp_neigh_ht_params);
2298 mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp,
2299 struct mlxsw_sp_neigh_entry *neigh_entry)
2301 struct devlink *devlink;
2302 const char *table_name;
2304 switch (mlxsw_sp_neigh_entry_type(neigh_entry)) {
2306 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4;
2309 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6;
2316 devlink = priv_to_devlink(mlxsw_sp->core);
2317 return devlink_dpipe_table_counter_enabled(devlink, table_name);
2321 mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp,
2322 struct mlxsw_sp_neigh_entry *neigh_entry)
2324 if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry))
2327 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index))
2330 neigh_entry->counter_valid = true;
2334 mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp,
2335 struct mlxsw_sp_neigh_entry *neigh_entry)
2337 if (!neigh_entry->counter_valid)
2339 mlxsw_sp_flow_counter_free(mlxsw_sp,
2340 neigh_entry->counter_index);
2341 neigh_entry->counter_valid = false;
2344 static struct mlxsw_sp_neigh_entry *
2345 mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
2347 struct mlxsw_sp_neigh_entry *neigh_entry;
2348 struct mlxsw_sp_rif *rif;
2351 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
2353 return ERR_PTR(-EINVAL);
2355 neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
2357 return ERR_PTR(-ENOMEM);
2359 err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
2361 goto err_neigh_entry_insert;
2363 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
2364 atomic_inc(&mlxsw_sp->router->neighs_update.neigh_count);
2365 list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
2369 err_neigh_entry_insert:
2370 mlxsw_sp_neigh_entry_free(neigh_entry);
2371 return ERR_PTR(err);
2375 mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
2376 struct mlxsw_sp_neigh_entry *neigh_entry)
2378 list_del(&neigh_entry->rif_list_node);
2379 atomic_dec(&mlxsw_sp->router->neighs_update.neigh_count);
2380 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
2381 mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
2382 mlxsw_sp_neigh_entry_free(neigh_entry);
2385 static struct mlxsw_sp_neigh_entry *
2386 mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
2388 struct mlxsw_sp_neigh_key key;
2391 return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
2392 &key, mlxsw_sp_neigh_ht_params);
2396 mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
2398 unsigned long interval;
2400 #if IS_ENABLED(CONFIG_IPV6)
2401 interval = min_t(unsigned long,
2402 NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
2403 NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
2405 interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
2407 mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
2410 static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
2414 u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
2415 struct net_device *dev;
2416 struct neighbour *n;
2421 mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
2423 if (WARN_ON_ONCE(rif >= max_rifs))
2425 if (!mlxsw_sp->router->rifs[rif]) {
2426 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
2431 dev = mlxsw_sp_rif_dev(mlxsw_sp->router->rifs[rif]);
2432 n = neigh_lookup(&arp_tbl, &dipn, dev);
2436 netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
2437 neigh_event_send(n, NULL);
2441 #if IS_ENABLED(CONFIG_IPV6)
2442 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2446 struct net_device *dev;
2447 struct neighbour *n;
2448 struct in6_addr dip;
2451 mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
2454 if (!mlxsw_sp->router->rifs[rif]) {
2455 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
2459 dev = mlxsw_sp_rif_dev(mlxsw_sp->router->rifs[rif]);
2460 n = neigh_lookup(&nd_tbl, &dip, dev);
2464 netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
2465 neigh_event_send(n, NULL);
2469 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2476 static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
2483 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
2485 /* Hardware starts counting at 0, so add 1. */
2488 /* Each record consists of several neighbour entries. */
2489 for (i = 0; i < num_entries; i++) {
2492 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
2493 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
2499 static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2503 /* One record contains one entry. */
2504 mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
2508 static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
2509 char *rauhtd_pl, int rec_index)
2511 switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
2512 case MLXSW_REG_RAUHTD_TYPE_IPV4:
2513 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
2516 case MLXSW_REG_RAUHTD_TYPE_IPV6:
2517 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
2523 static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
2525 u8 num_rec, last_rec_index, num_entries;
2527 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
2528 last_rec_index = num_rec - 1;
2530 if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
2532 if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
2533 MLXSW_REG_RAUHTD_TYPE_IPV6)
2536 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
2538 if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
2544 __mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
2546 enum mlxsw_reg_rauhtd_type type)
2551 /* Ensure the RIF we read from the device does not change mid-dump. */
2552 mutex_lock(&mlxsw_sp->router->lock);
2554 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
2555 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
2558 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour table\n");
2561 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
2562 for (i = 0; i < num_rec; i++)
2563 mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
2565 } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
2566 mutex_unlock(&mlxsw_sp->router->lock);
2571 static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
2573 enum mlxsw_reg_rauhtd_type type;
2577 if (!atomic_read(&mlxsw_sp->router->neighs_update.neigh_count))
2580 rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
2584 type = MLXSW_REG_RAUHTD_TYPE_IPV4;
2585 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
2589 type = MLXSW_REG_RAUHTD_TYPE_IPV6;
2590 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
2596 static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
2598 struct mlxsw_sp_neigh_entry *neigh_entry;
2600 mutex_lock(&mlxsw_sp->router->lock);
2601 list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
2602 nexthop_neighs_list_node)
2603 /* If this neigh have nexthops, make the kernel think this neigh
2604 * is active regardless of the traffic.
2606 neigh_event_send(neigh_entry->key.n, NULL);
2607 mutex_unlock(&mlxsw_sp->router->lock);
2611 mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
2613 unsigned long interval = mlxsw_sp->router->neighs_update.interval;
2615 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
2616 msecs_to_jiffies(interval));
2619 static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
2621 struct mlxsw_sp_router *router;
2624 router = container_of(work, struct mlxsw_sp_router,
2625 neighs_update.dw.work);
2626 err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
2628 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
2630 mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
2632 mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
2635 static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
2637 struct mlxsw_sp_neigh_entry *neigh_entry;
2638 struct mlxsw_sp_router *router;
2640 router = container_of(work, struct mlxsw_sp_router,
2641 nexthop_probe_dw.work);
2642 /* Iterate over nexthop neighbours, find those who are unresolved and
2643 * send arp on them. This solves the chicken-egg problem when
2644 * the nexthop wouldn't get offloaded until the neighbor is resolved
2645 * but it wouldn't get resolved ever in case traffic is flowing in HW
2646 * using different nexthop.
2648 mutex_lock(&router->lock);
2649 list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
2650 nexthop_neighs_list_node)
2651 if (!neigh_entry->connected)
2652 neigh_event_send(neigh_entry->key.n, NULL);
2653 mutex_unlock(&router->lock);
2655 mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
2656 MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
2660 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
2661 struct mlxsw_sp_neigh_entry *neigh_entry,
2662 bool removing, bool dead);
2664 static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
2666 return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
2667 MLXSW_REG_RAUHT_OP_WRITE_DELETE;
2671 mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
2672 struct mlxsw_sp_neigh_entry *neigh_entry,
2673 enum mlxsw_reg_rauht_op op)
2675 struct neighbour *n = neigh_entry->key.n;
2676 u32 dip = ntohl(*((__be32 *) n->primary_key));
2677 char rauht_pl[MLXSW_REG_RAUHT_LEN];
2679 mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
2681 if (neigh_entry->counter_valid)
2682 mlxsw_reg_rauht_pack_counter(rauht_pl,
2683 neigh_entry->counter_index);
2684 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
2688 mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
2689 struct mlxsw_sp_neigh_entry *neigh_entry,
2690 enum mlxsw_reg_rauht_op op)
2692 struct neighbour *n = neigh_entry->key.n;
2693 char rauht_pl[MLXSW_REG_RAUHT_LEN];
2694 const char *dip = n->primary_key;
2696 mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
2698 if (neigh_entry->counter_valid)
2699 mlxsw_reg_rauht_pack_counter(rauht_pl,
2700 neigh_entry->counter_index);
2701 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
2704 bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry)
2706 struct neighbour *n = neigh_entry->key.n;
2708 /* Packets with a link-local destination address are trapped
2709 * after LPM lookup and never reach the neighbour table, so
2710 * there is no need to program such neighbours to the device.
2712 if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
2713 IPV6_ADDR_LINKLOCAL)
2719 mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
2720 struct mlxsw_sp_neigh_entry *neigh_entry,
2723 enum mlxsw_reg_rauht_op op = mlxsw_sp_rauht_op(adding);
2726 if (!adding && !neigh_entry->connected)
2728 neigh_entry->connected = adding;
2729 if (neigh_entry->key.n->tbl->family == AF_INET) {
2730 err = mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
2734 } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
2735 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry))
2737 err = mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
2747 neigh_entry->key.n->flags |= NTF_OFFLOADED;
2749 neigh_entry->key.n->flags &= ~NTF_OFFLOADED;
2753 mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp,
2754 struct mlxsw_sp_neigh_entry *neigh_entry,
2758 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
2760 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
2761 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true);
2764 struct mlxsw_sp_netevent_work {
2765 struct work_struct work;
2766 struct mlxsw_sp *mlxsw_sp;
2767 struct neighbour *n;
2770 static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
2772 struct mlxsw_sp_netevent_work *net_work =
2773 container_of(work, struct mlxsw_sp_netevent_work, work);
2774 struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2775 struct mlxsw_sp_neigh_entry *neigh_entry;
2776 struct neighbour *n = net_work->n;
2777 unsigned char ha[ETH_ALEN];
2778 bool entry_connected;
2781 /* If these parameters are changed after we release the lock,
2782 * then we are guaranteed to receive another event letting us
2785 read_lock_bh(&n->lock);
2786 memcpy(ha, n->ha, ETH_ALEN);
2787 nud_state = n->nud_state;
2789 read_unlock_bh(&n->lock);
2791 mutex_lock(&mlxsw_sp->router->lock);
2792 mlxsw_sp_span_respin(mlxsw_sp);
2794 entry_connected = nud_state & NUD_VALID && !dead;
2795 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
2796 if (!entry_connected && !neigh_entry)
2799 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
2800 if (IS_ERR(neigh_entry))
2804 if (neigh_entry->connected && entry_connected &&
2805 !memcmp(neigh_entry->ha, ha, ETH_ALEN))
2808 memcpy(neigh_entry->ha, ha, ETH_ALEN);
2809 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
2810 mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected,
2813 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
2814 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2817 mutex_unlock(&mlxsw_sp->router->lock);
2822 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp);
2824 static void mlxsw_sp_router_mp_hash_event_work(struct work_struct *work)
2826 struct mlxsw_sp_netevent_work *net_work =
2827 container_of(work, struct mlxsw_sp_netevent_work, work);
2828 struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2830 mlxsw_sp_mp_hash_init(mlxsw_sp);
2834 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp);
2836 static void mlxsw_sp_router_update_priority_work(struct work_struct *work)
2838 struct mlxsw_sp_netevent_work *net_work =
2839 container_of(work, struct mlxsw_sp_netevent_work, work);
2840 struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2842 __mlxsw_sp_router_init(mlxsw_sp);
2846 static int mlxsw_sp_router_schedule_work(struct net *net,
2847 struct mlxsw_sp_router *router,
2848 struct neighbour *n,
2849 void (*cb)(struct work_struct *))
2851 struct mlxsw_sp_netevent_work *net_work;
2853 if (!net_eq(net, mlxsw_sp_net(router->mlxsw_sp)))
2856 net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC);
2860 INIT_WORK(&net_work->work, cb);
2861 net_work->mlxsw_sp = router->mlxsw_sp;
2863 mlxsw_core_schedule_work(&net_work->work);
2867 static bool mlxsw_sp_dev_lower_is_port(struct net_device *dev)
2869 struct mlxsw_sp_port *mlxsw_sp_port;
2872 mlxsw_sp_port = mlxsw_sp_port_dev_lower_find_rcu(dev);
2874 return !!mlxsw_sp_port;
2877 static int mlxsw_sp_router_schedule_neigh_work(struct mlxsw_sp_router *router,
2878 struct neighbour *n)
2882 net = neigh_parms_net(n->parms);
2884 /* Take a reference to ensure the neighbour won't be destructed until we
2885 * drop the reference in delayed work.
2888 return mlxsw_sp_router_schedule_work(net, router, n,
2889 mlxsw_sp_router_neigh_event_work);
2892 static int mlxsw_sp_router_netevent_event(struct notifier_block *nb,
2893 unsigned long event, void *ptr)
2895 struct mlxsw_sp_router *router;
2896 unsigned long interval;
2897 struct neigh_parms *p;
2898 struct neighbour *n;
2900 router = container_of(nb, struct mlxsw_sp_router, netevent_nb);
2903 case NETEVENT_DELAY_PROBE_TIME_UPDATE:
2906 /* We don't care about changes in the default table. */
2907 if (!p->dev || (p->tbl->family != AF_INET &&
2908 p->tbl->family != AF_INET6))
2911 /* We are in atomic context and can't take RTNL mutex,
2912 * so use RCU variant to walk the device chain.
2914 if (!mlxsw_sp_dev_lower_is_port(p->dev))
2917 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
2918 router->neighs_update.interval = interval;
2920 case NETEVENT_NEIGH_UPDATE:
2923 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
2926 if (!mlxsw_sp_dev_lower_is_port(n->dev))
2929 return mlxsw_sp_router_schedule_neigh_work(router, n);
2931 case NETEVENT_IPV4_MPATH_HASH_UPDATE:
2932 case NETEVENT_IPV6_MPATH_HASH_UPDATE:
2933 return mlxsw_sp_router_schedule_work(ptr, router, NULL,
2934 mlxsw_sp_router_mp_hash_event_work);
2936 case NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE:
2937 return mlxsw_sp_router_schedule_work(ptr, router, NULL,
2938 mlxsw_sp_router_update_priority_work);
2944 static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
2948 err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
2949 &mlxsw_sp_neigh_ht_params);
2953 /* Initialize the polling interval according to the default
2956 mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
2958 /* Create the delayed works for the activity_update */
2959 INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
2960 mlxsw_sp_router_neighs_update_work);
2961 INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
2962 mlxsw_sp_router_probe_unresolved_nexthops);
2963 atomic_set(&mlxsw_sp->router->neighs_update.neigh_count, 0);
2964 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
2965 mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
2969 static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
2971 cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
2972 cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
2973 rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
2976 static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
2977 struct mlxsw_sp_rif *rif)
2979 struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
2981 list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
2983 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
2984 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2988 struct mlxsw_sp_neigh_rif_made_sync {
2989 struct mlxsw_sp *mlxsw_sp;
2990 struct mlxsw_sp_rif *rif;
2994 static void mlxsw_sp_neigh_rif_made_sync_each(struct neighbour *n, void *data)
2996 struct mlxsw_sp_neigh_rif_made_sync *rms = data;
3001 if (n->dev != mlxsw_sp_rif_dev(rms->rif))
3003 rc = mlxsw_sp_router_schedule_neigh_work(rms->mlxsw_sp->router, n);
3004 if (rc != NOTIFY_DONE)
3008 static int mlxsw_sp_neigh_rif_made_sync(struct mlxsw_sp *mlxsw_sp,
3009 struct mlxsw_sp_rif *rif)
3011 struct mlxsw_sp_neigh_rif_made_sync rms = {
3012 .mlxsw_sp = mlxsw_sp,
3016 neigh_for_each(&arp_tbl, mlxsw_sp_neigh_rif_made_sync_each, &rms);
3020 #if IS_ENABLED(CONFIG_IPV6)
3021 neigh_for_each(&nd_tbl, mlxsw_sp_neigh_rif_made_sync_each, &rms);
3030 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
3034 enum mlxsw_sp_nexthop_type {
3035 MLXSW_SP_NEXTHOP_TYPE_ETH,
3036 MLXSW_SP_NEXTHOP_TYPE_IPIP,
3039 enum mlxsw_sp_nexthop_action {
3040 /* Nexthop forwards packets to an egress RIF */
3041 MLXSW_SP_NEXTHOP_ACTION_FORWARD,
3042 /* Nexthop discards packets */
3043 MLXSW_SP_NEXTHOP_ACTION_DISCARD,
3044 /* Nexthop traps packets */
3045 MLXSW_SP_NEXTHOP_ACTION_TRAP,
3048 struct mlxsw_sp_nexthop_key {
3049 struct fib_nh *fib_nh;
3052 struct mlxsw_sp_nexthop {
3053 struct list_head neigh_list_node; /* member of neigh entry list */
3054 struct list_head crif_list_node;
3055 struct list_head router_list_node;
3056 struct mlxsw_sp_nexthop_group_info *nhgi; /* pointer back to the group
3057 * this nexthop belongs to
3059 struct rhash_head ht_node;
3060 struct neigh_table *neigh_tbl;
3061 struct mlxsw_sp_nexthop_key key;
3062 unsigned char gw_addr[sizeof(struct in6_addr)];
3066 int num_adj_entries;
3067 struct mlxsw_sp_crif *crif;
3068 u8 should_offload:1, /* set indicates this nexthop should be written
3069 * to the adjacency table.
3071 offloaded:1, /* set indicates this nexthop was written to the
3074 update:1; /* set indicates this nexthop should be updated in the
3075 * adjacency table (f.e., its MAC changed).
3077 enum mlxsw_sp_nexthop_action action;
3078 enum mlxsw_sp_nexthop_type type;
3080 struct mlxsw_sp_neigh_entry *neigh_entry;
3081 struct mlxsw_sp_ipip_entry *ipip_entry;
3083 unsigned int counter_index;
3087 static struct net_device *
3088 mlxsw_sp_nexthop_dev(const struct mlxsw_sp_nexthop *nh)
3092 return nh->crif->key.dev;
3095 enum mlxsw_sp_nexthop_group_type {
3096 MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4,
3097 MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6,
3098 MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ,
3101 struct mlxsw_sp_nexthop_group_info {
3102 struct mlxsw_sp_nexthop_group *nh_grp;
3106 int sum_norm_weight;
3107 u8 adj_index_valid:1,
3108 gateway:1, /* routes using the group use a gateway */
3110 struct list_head list; /* member in nh_res_grp_list */
3111 struct mlxsw_sp_nexthop nexthops[] __counted_by(count);
3114 static struct mlxsw_sp_rif *
3115 mlxsw_sp_nhgi_rif(const struct mlxsw_sp_nexthop_group_info *nhgi)
3117 struct mlxsw_sp_crif *crif = nhgi->nexthops[0].crif;
3124 struct mlxsw_sp_nexthop_group_vr_key {
3126 enum mlxsw_sp_l3proto proto;
3129 struct mlxsw_sp_nexthop_group_vr_entry {
3130 struct list_head list; /* member in vr_list */
3131 struct rhash_head ht_node; /* member in vr_ht */
3132 refcount_t ref_count;
3133 struct mlxsw_sp_nexthop_group_vr_key key;
3136 struct mlxsw_sp_nexthop_group {
3137 struct rhash_head ht_node;
3138 struct list_head fib_list; /* list of fib entries that use this group */
3141 struct fib_info *fi;
3147 struct mlxsw_sp_nexthop_group_info *nhgi;
3148 struct list_head vr_list;
3149 struct rhashtable vr_ht;
3150 enum mlxsw_sp_nexthop_group_type type;
3154 void mlxsw_sp_nexthop_counter_alloc(struct mlxsw_sp *mlxsw_sp,
3155 struct mlxsw_sp_nexthop *nh)
3157 struct devlink *devlink;
3159 devlink = priv_to_devlink(mlxsw_sp->core);
3160 if (!devlink_dpipe_table_counter_enabled(devlink,
3161 MLXSW_SP_DPIPE_TABLE_NAME_ADJ))
3164 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &nh->counter_index))
3167 nh->counter_valid = true;
3170 void mlxsw_sp_nexthop_counter_free(struct mlxsw_sp *mlxsw_sp,
3171 struct mlxsw_sp_nexthop *nh)
3173 if (!nh->counter_valid)
3175 mlxsw_sp_flow_counter_free(mlxsw_sp, nh->counter_index);
3176 nh->counter_valid = false;
3179 int mlxsw_sp_nexthop_counter_get(struct mlxsw_sp *mlxsw_sp,
3180 struct mlxsw_sp_nexthop *nh, u64 *p_counter)
3182 if (!nh->counter_valid)
3185 return mlxsw_sp_flow_counter_get(mlxsw_sp, nh->counter_index,
3189 struct mlxsw_sp_nexthop *mlxsw_sp_nexthop_next(struct mlxsw_sp_router *router,
3190 struct mlxsw_sp_nexthop *nh)
3193 if (list_empty(&router->nexthop_list))
3196 return list_first_entry(&router->nexthop_list,
3197 typeof(*nh), router_list_node);
3199 if (list_is_last(&nh->router_list_node, &router->nexthop_list))
3201 return list_next_entry(nh, router_list_node);
3204 bool mlxsw_sp_nexthop_is_forward(const struct mlxsw_sp_nexthop *nh)
3206 return nh->offloaded && nh->action == MLXSW_SP_NEXTHOP_ACTION_FORWARD;
3209 unsigned char *mlxsw_sp_nexthop_ha(struct mlxsw_sp_nexthop *nh)
3211 if (nh->type != MLXSW_SP_NEXTHOP_TYPE_ETH ||
3212 !mlxsw_sp_nexthop_is_forward(nh))
3214 return nh->neigh_entry->ha;
3217 int mlxsw_sp_nexthop_indexes(struct mlxsw_sp_nexthop *nh, u32 *p_adj_index,
3218 u32 *p_adj_size, u32 *p_adj_hash_index)
3220 struct mlxsw_sp_nexthop_group_info *nhgi = nh->nhgi;
3221 u32 adj_hash_index = 0;
3224 if (!nh->offloaded || !nhgi->adj_index_valid)
3227 *p_adj_index = nhgi->adj_index;
3228 *p_adj_size = nhgi->ecmp_size;
3230 for (i = 0; i < nhgi->count; i++) {
3231 struct mlxsw_sp_nexthop *nh_iter = &nhgi->nexthops[i];
3235 if (nh_iter->offloaded)
3236 adj_hash_index += nh_iter->num_adj_entries;
3239 *p_adj_hash_index = adj_hash_index;
3243 struct mlxsw_sp_rif *mlxsw_sp_nexthop_rif(struct mlxsw_sp_nexthop *nh)
3245 if (WARN_ON(!nh->crif))
3247 return nh->crif->rif;
3250 bool mlxsw_sp_nexthop_group_has_ipip(struct mlxsw_sp_nexthop *nh)
3252 struct mlxsw_sp_nexthop_group_info *nhgi = nh->nhgi;
3255 for (i = 0; i < nhgi->count; i++) {
3256 struct mlxsw_sp_nexthop *nh_iter = &nhgi->nexthops[i];
3258 if (nh_iter->type == MLXSW_SP_NEXTHOP_TYPE_IPIP)
3264 static const struct rhashtable_params mlxsw_sp_nexthop_group_vr_ht_params = {
3265 .key_offset = offsetof(struct mlxsw_sp_nexthop_group_vr_entry, key),
3266 .head_offset = offsetof(struct mlxsw_sp_nexthop_group_vr_entry, ht_node),
3267 .key_len = sizeof(struct mlxsw_sp_nexthop_group_vr_key),
3268 .automatic_shrinking = true,
3271 static struct mlxsw_sp_nexthop_group_vr_entry *
3272 mlxsw_sp_nexthop_group_vr_entry_lookup(struct mlxsw_sp_nexthop_group *nh_grp,
3273 const struct mlxsw_sp_fib *fib)
3275 struct mlxsw_sp_nexthop_group_vr_key key;
3277 memset(&key, 0, sizeof(key));
3278 key.vr_id = fib->vr->id;
3279 key.proto = fib->proto;
3280 return rhashtable_lookup_fast(&nh_grp->vr_ht, &key,
3281 mlxsw_sp_nexthop_group_vr_ht_params);
3285 mlxsw_sp_nexthop_group_vr_entry_create(struct mlxsw_sp_nexthop_group *nh_grp,
3286 const struct mlxsw_sp_fib *fib)
3288 struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3291 vr_entry = kzalloc(sizeof(*vr_entry), GFP_KERNEL);
3295 vr_entry->key.vr_id = fib->vr->id;
3296 vr_entry->key.proto = fib->proto;
3297 refcount_set(&vr_entry->ref_count, 1);
3299 err = rhashtable_insert_fast(&nh_grp->vr_ht, &vr_entry->ht_node,
3300 mlxsw_sp_nexthop_group_vr_ht_params);
3302 goto err_hashtable_insert;
3304 list_add(&vr_entry->list, &nh_grp->vr_list);
3308 err_hashtable_insert:
3314 mlxsw_sp_nexthop_group_vr_entry_destroy(struct mlxsw_sp_nexthop_group *nh_grp,
3315 struct mlxsw_sp_nexthop_group_vr_entry *vr_entry)
3317 list_del(&vr_entry->list);
3318 rhashtable_remove_fast(&nh_grp->vr_ht, &vr_entry->ht_node,
3319 mlxsw_sp_nexthop_group_vr_ht_params);
3324 mlxsw_sp_nexthop_group_vr_link(struct mlxsw_sp_nexthop_group *nh_grp,
3325 const struct mlxsw_sp_fib *fib)
3327 struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3329 vr_entry = mlxsw_sp_nexthop_group_vr_entry_lookup(nh_grp, fib);
3331 refcount_inc(&vr_entry->ref_count);
3335 return mlxsw_sp_nexthop_group_vr_entry_create(nh_grp, fib);
3339 mlxsw_sp_nexthop_group_vr_unlink(struct mlxsw_sp_nexthop_group *nh_grp,
3340 const struct mlxsw_sp_fib *fib)
3342 struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3344 vr_entry = mlxsw_sp_nexthop_group_vr_entry_lookup(nh_grp, fib);
3345 if (WARN_ON_ONCE(!vr_entry))
3348 if (!refcount_dec_and_test(&vr_entry->ref_count))
3351 mlxsw_sp_nexthop_group_vr_entry_destroy(nh_grp, vr_entry);
3354 struct mlxsw_sp_nexthop_group_cmp_arg {
3355 enum mlxsw_sp_nexthop_group_type type;
3357 struct fib_info *fi;
3358 struct mlxsw_sp_fib6_entry *fib6_entry;
3364 mlxsw_sp_nexthop6_group_has_nexthop(const struct mlxsw_sp_nexthop_group *nh_grp,
3365 const struct in6_addr *gw, int ifindex,
3370 for (i = 0; i < nh_grp->nhgi->count; i++) {
3371 const struct mlxsw_sp_nexthop *nh;
3373 nh = &nh_grp->nhgi->nexthops[i];
3374 if (nh->ifindex == ifindex && nh->nh_weight == weight &&
3375 ipv6_addr_equal(gw, (struct in6_addr *) nh->gw_addr))
3383 mlxsw_sp_nexthop6_group_cmp(const struct mlxsw_sp_nexthop_group *nh_grp,
3384 const struct mlxsw_sp_fib6_entry *fib6_entry)
3386 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3388 if (nh_grp->nhgi->count != fib6_entry->nrt6)
3391 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3392 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
3393 struct in6_addr *gw;
3394 int ifindex, weight;
3396 ifindex = fib6_nh->fib_nh_dev->ifindex;
3397 weight = fib6_nh->fib_nh_weight;
3398 gw = &fib6_nh->fib_nh_gw6;
3399 if (!mlxsw_sp_nexthop6_group_has_nexthop(nh_grp, gw, ifindex,
3408 mlxsw_sp_nexthop_group_cmp(struct rhashtable_compare_arg *arg, const void *ptr)
3410 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = arg->key;
3411 const struct mlxsw_sp_nexthop_group *nh_grp = ptr;
3413 if (nh_grp->type != cmp_arg->type)
3416 switch (cmp_arg->type) {
3417 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3418 return cmp_arg->fi != nh_grp->ipv4.fi;
3419 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3420 return !mlxsw_sp_nexthop6_group_cmp(nh_grp,
3421 cmp_arg->fib6_entry);
3422 case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3423 return cmp_arg->id != nh_grp->obj.id;
3430 static u32 mlxsw_sp_nexthop_group_hash_obj(const void *data, u32 len, u32 seed)
3432 const struct mlxsw_sp_nexthop_group *nh_grp = data;
3433 const struct mlxsw_sp_nexthop *nh;
3434 struct fib_info *fi;
3438 switch (nh_grp->type) {
3439 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3440 fi = nh_grp->ipv4.fi;
3441 return jhash(&fi, sizeof(fi), seed);
3442 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3443 val = nh_grp->nhgi->count;
3444 for (i = 0; i < nh_grp->nhgi->count; i++) {
3445 nh = &nh_grp->nhgi->nexthops[i];
3446 val ^= jhash(&nh->ifindex, sizeof(nh->ifindex), seed);
3447 val ^= jhash(&nh->gw_addr, sizeof(nh->gw_addr), seed);
3449 return jhash(&val, sizeof(val), seed);
3450 case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3451 return jhash(&nh_grp->obj.id, sizeof(nh_grp->obj.id), seed);
3459 mlxsw_sp_nexthop6_group_hash(struct mlxsw_sp_fib6_entry *fib6_entry, u32 seed)
3461 unsigned int val = fib6_entry->nrt6;
3462 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3464 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3465 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
3466 struct net_device *dev = fib6_nh->fib_nh_dev;
3467 struct in6_addr *gw = &fib6_nh->fib_nh_gw6;
3469 val ^= jhash(&dev->ifindex, sizeof(dev->ifindex), seed);
3470 val ^= jhash(gw, sizeof(*gw), seed);
3473 return jhash(&val, sizeof(val), seed);
3477 mlxsw_sp_nexthop_group_hash(const void *data, u32 len, u32 seed)
3479 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = data;
3481 switch (cmp_arg->type) {
3482 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3483 return jhash(&cmp_arg->fi, sizeof(cmp_arg->fi), seed);
3484 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3485 return mlxsw_sp_nexthop6_group_hash(cmp_arg->fib6_entry, seed);
3486 case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3487 return jhash(&cmp_arg->id, sizeof(cmp_arg->id), seed);
3494 static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
3495 .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
3496 .hashfn = mlxsw_sp_nexthop_group_hash,
3497 .obj_hashfn = mlxsw_sp_nexthop_group_hash_obj,
3498 .obj_cmpfn = mlxsw_sp_nexthop_group_cmp,
3501 static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
3502 struct mlxsw_sp_nexthop_group *nh_grp)
3504 if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6 &&
3505 !nh_grp->nhgi->gateway)
3508 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
3510 mlxsw_sp_nexthop_group_ht_params);
3513 static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
3514 struct mlxsw_sp_nexthop_group *nh_grp)
3516 if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6 &&
3517 !nh_grp->nhgi->gateway)
3520 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
3522 mlxsw_sp_nexthop_group_ht_params);
3525 static struct mlxsw_sp_nexthop_group *
3526 mlxsw_sp_nexthop4_group_lookup(struct mlxsw_sp *mlxsw_sp,
3527 struct fib_info *fi)
3529 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
3531 cmp_arg.type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4;
3533 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
3535 mlxsw_sp_nexthop_group_ht_params);
3538 static struct mlxsw_sp_nexthop_group *
3539 mlxsw_sp_nexthop6_group_lookup(struct mlxsw_sp *mlxsw_sp,
3540 struct mlxsw_sp_fib6_entry *fib6_entry)
3542 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
3544 cmp_arg.type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6;
3545 cmp_arg.fib6_entry = fib6_entry;
3546 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
3548 mlxsw_sp_nexthop_group_ht_params);
3551 static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
3552 .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
3553 .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
3554 .key_len = sizeof(struct mlxsw_sp_nexthop_key),
3557 static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
3558 struct mlxsw_sp_nexthop *nh)
3560 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
3561 &nh->ht_node, mlxsw_sp_nexthop_ht_params);
3564 static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
3565 struct mlxsw_sp_nexthop *nh)
3567 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
3568 mlxsw_sp_nexthop_ht_params);
3571 static struct mlxsw_sp_nexthop *
3572 mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
3573 struct mlxsw_sp_nexthop_key key)
3575 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
3576 mlxsw_sp_nexthop_ht_params);
3579 static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
3580 enum mlxsw_sp_l3proto proto,
3582 u32 adj_index, u16 ecmp_size,
3586 char raleu_pl[MLXSW_REG_RALEU_LEN];
3588 mlxsw_reg_raleu_pack(raleu_pl,
3589 (enum mlxsw_reg_ralxx_protocol) proto, vr_id,
3590 adj_index, ecmp_size, new_adj_index,
3592 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
3595 static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
3596 struct mlxsw_sp_nexthop_group *nh_grp,
3597 u32 old_adj_index, u16 old_ecmp_size)
3599 struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
3600 struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3603 list_for_each_entry(vr_entry, &nh_grp->vr_list, list) {
3604 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp,
3605 vr_entry->key.proto,
3606 vr_entry->key.vr_id,
3612 goto err_mass_update_vr;
3617 list_for_each_entry_continue_reverse(vr_entry, &nh_grp->vr_list, list)
3618 mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, vr_entry->key.proto,
3619 vr_entry->key.vr_id,
3622 old_adj_index, old_ecmp_size);
3626 static int __mlxsw_sp_nexthop_eth_update(struct mlxsw_sp *mlxsw_sp,
3628 struct mlxsw_sp_nexthop *nh,
3629 bool force, char *ratr_pl)
3631 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
3632 struct mlxsw_sp_rif *rif = mlxsw_sp_nexthop_rif(nh);
3633 enum mlxsw_reg_ratr_op op;
3636 rif_index = rif ? rif->rif_index :
3637 mlxsw_sp->router->lb_crif->rif->rif_index;
3638 op = force ? MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY :
3639 MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY_ON_ACTIVITY;
3640 mlxsw_reg_ratr_pack(ratr_pl, op, true, MLXSW_REG_RATR_TYPE_ETHERNET,
3641 adj_index, rif_index);
3642 switch (nh->action) {
3643 case MLXSW_SP_NEXTHOP_ACTION_FORWARD:
3644 mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
3646 case MLXSW_SP_NEXTHOP_ACTION_DISCARD:
3647 mlxsw_reg_ratr_trap_action_set(ratr_pl,
3648 MLXSW_REG_RATR_TRAP_ACTION_DISCARD_ERRORS);
3650 case MLXSW_SP_NEXTHOP_ACTION_TRAP:
3651 mlxsw_reg_ratr_trap_action_set(ratr_pl,
3652 MLXSW_REG_RATR_TRAP_ACTION_TRAP);
3653 mlxsw_reg_ratr_trap_id_set(ratr_pl, MLXSW_TRAP_ID_RTR_EGRESS0);
3659 if (nh->counter_valid)
3660 mlxsw_reg_ratr_counter_pack(ratr_pl, nh->counter_index, true);
3662 mlxsw_reg_ratr_counter_pack(ratr_pl, 0, false);
3664 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
3667 int mlxsw_sp_nexthop_eth_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
3668 struct mlxsw_sp_nexthop *nh, bool force,
3673 for (i = 0; i < nh->num_adj_entries; i++) {
3676 err = __mlxsw_sp_nexthop_eth_update(mlxsw_sp, adj_index + i,
3677 nh, force, ratr_pl);
3685 static int __mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
3687 struct mlxsw_sp_nexthop *nh,
3688 bool force, char *ratr_pl)
3690 const struct mlxsw_sp_ipip_ops *ipip_ops;
3692 ipip_ops = mlxsw_sp->router->ipip_ops_arr[nh->ipip_entry->ipipt];
3693 return ipip_ops->nexthop_update(mlxsw_sp, adj_index, nh->ipip_entry,
3697 static int mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
3699 struct mlxsw_sp_nexthop *nh, bool force,
3704 for (i = 0; i < nh->num_adj_entries; i++) {
3707 err = __mlxsw_sp_nexthop_ipip_update(mlxsw_sp, adj_index + i,
3708 nh, force, ratr_pl);
3716 static int mlxsw_sp_nexthop_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
3717 struct mlxsw_sp_nexthop *nh, bool force,
3720 /* When action is discard or trap, the nexthop must be
3721 * programmed as an Ethernet nexthop.
3723 if (nh->type == MLXSW_SP_NEXTHOP_TYPE_ETH ||
3724 nh->action == MLXSW_SP_NEXTHOP_ACTION_DISCARD ||
3725 nh->action == MLXSW_SP_NEXTHOP_ACTION_TRAP)
3726 return mlxsw_sp_nexthop_eth_update(mlxsw_sp, adj_index, nh,
3729 return mlxsw_sp_nexthop_ipip_update(mlxsw_sp, adj_index, nh,
3734 mlxsw_sp_nexthop_group_update(struct mlxsw_sp *mlxsw_sp,
3735 struct mlxsw_sp_nexthop_group_info *nhgi,
3738 char ratr_pl[MLXSW_REG_RATR_LEN];
3739 u32 adj_index = nhgi->adj_index; /* base */
3740 struct mlxsw_sp_nexthop *nh;
3743 for (i = 0; i < nhgi->count; i++) {
3744 nh = &nhgi->nexthops[i];
3746 if (!nh->should_offload) {
3751 if (nh->update || reallocate) {
3754 err = mlxsw_sp_nexthop_update(mlxsw_sp, adj_index, nh,
3761 adj_index += nh->num_adj_entries;
3767 mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
3768 struct mlxsw_sp_nexthop_group *nh_grp)
3770 struct mlxsw_sp_fib_entry *fib_entry;
3773 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
3774 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
3781 struct mlxsw_sp_adj_grp_size_range {
3782 u16 start; /* Inclusive */
3783 u16 end; /* Inclusive */
3786 /* Ordered by range start value */
3787 static const struct mlxsw_sp_adj_grp_size_range
3788 mlxsw_sp1_adj_grp_size_ranges[] = {
3789 { .start = 1, .end = 64 },
3790 { .start = 512, .end = 512 },
3791 { .start = 1024, .end = 1024 },
3792 { .start = 2048, .end = 2048 },
3793 { .start = 4096, .end = 4096 },
3796 /* Ordered by range start value */
3797 static const struct mlxsw_sp_adj_grp_size_range
3798 mlxsw_sp2_adj_grp_size_ranges[] = {
3799 { .start = 1, .end = 128 },
3800 { .start = 256, .end = 256 },
3801 { .start = 512, .end = 512 },
3802 { .start = 1024, .end = 1024 },
3803 { .start = 2048, .end = 2048 },
3804 { .start = 4096, .end = 4096 },
3807 static void mlxsw_sp_adj_grp_size_round_up(const struct mlxsw_sp *mlxsw_sp,
3808 u16 *p_adj_grp_size)
3812 for (i = 0; i < mlxsw_sp->router->adj_grp_size_ranges_count; i++) {
3813 const struct mlxsw_sp_adj_grp_size_range *size_range;
3815 size_range = &mlxsw_sp->router->adj_grp_size_ranges[i];
3817 if (*p_adj_grp_size >= size_range->start &&
3818 *p_adj_grp_size <= size_range->end)
3821 if (*p_adj_grp_size <= size_range->end) {
3822 *p_adj_grp_size = size_range->end;
3828 static void mlxsw_sp_adj_grp_size_round_down(const struct mlxsw_sp *mlxsw_sp,
3829 u16 *p_adj_grp_size,
3830 unsigned int alloc_size)
3834 for (i = mlxsw_sp->router->adj_grp_size_ranges_count - 1; i >= 0; i--) {
3835 const struct mlxsw_sp_adj_grp_size_range *size_range;
3837 size_range = &mlxsw_sp->router->adj_grp_size_ranges[i];
3839 if (alloc_size >= size_range->end) {
3840 *p_adj_grp_size = size_range->end;
3846 static int mlxsw_sp_fix_adj_grp_size(struct mlxsw_sp *mlxsw_sp,
3847 u16 *p_adj_grp_size)
3849 unsigned int alloc_size;
3852 /* Round up the requested group size to the next size supported
3853 * by the device and make sure the request can be satisfied.
3855 mlxsw_sp_adj_grp_size_round_up(mlxsw_sp, p_adj_grp_size);
3856 err = mlxsw_sp_kvdl_alloc_count_query(mlxsw_sp,
3857 MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
3858 *p_adj_grp_size, &alloc_size);
3861 /* It is possible the allocation results in more allocated
3862 * entries than requested. Try to use as much of them as
3865 mlxsw_sp_adj_grp_size_round_down(mlxsw_sp, p_adj_grp_size, alloc_size);
3871 mlxsw_sp_nexthop_group_normalize(struct mlxsw_sp_nexthop_group_info *nhgi)
3873 int i, g = 0, sum_norm_weight = 0;
3874 struct mlxsw_sp_nexthop *nh;
3876 for (i = 0; i < nhgi->count; i++) {
3877 nh = &nhgi->nexthops[i];
3879 if (!nh->should_offload)
3882 g = gcd(nh->nh_weight, g);
3887 for (i = 0; i < nhgi->count; i++) {
3888 nh = &nhgi->nexthops[i];
3890 if (!nh->should_offload)
3892 nh->norm_nh_weight = nh->nh_weight / g;
3893 sum_norm_weight += nh->norm_nh_weight;
3896 nhgi->sum_norm_weight = sum_norm_weight;
3900 mlxsw_sp_nexthop_group_rebalance(struct mlxsw_sp_nexthop_group_info *nhgi)
3902 int i, weight = 0, lower_bound = 0;
3903 int total = nhgi->sum_norm_weight;
3904 u16 ecmp_size = nhgi->ecmp_size;
3906 for (i = 0; i < nhgi->count; i++) {
3907 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
3910 if (!nh->should_offload)
3912 weight += nh->norm_nh_weight;
3913 upper_bound = DIV_ROUND_CLOSEST(ecmp_size * weight, total);
3914 nh->num_adj_entries = upper_bound - lower_bound;
3915 lower_bound = upper_bound;
3919 static struct mlxsw_sp_nexthop *
3920 mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
3921 const struct mlxsw_sp_rt6 *mlxsw_sp_rt6);
3924 mlxsw_sp_nexthop4_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3925 struct mlxsw_sp_nexthop_group *nh_grp)
3929 for (i = 0; i < nh_grp->nhgi->count; i++) {
3930 struct mlxsw_sp_nexthop *nh = &nh_grp->nhgi->nexthops[i];
3933 nh->key.fib_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
3935 nh->key.fib_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
3940 __mlxsw_sp_nexthop6_group_offload_refresh(struct mlxsw_sp_nexthop_group *nh_grp,
3941 struct mlxsw_sp_fib6_entry *fib6_entry)
3943 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3945 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3946 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
3947 struct mlxsw_sp_nexthop *nh;
3949 nh = mlxsw_sp_rt6_nexthop(nh_grp, mlxsw_sp_rt6);
3950 if (nh && nh->offloaded)
3951 fib6_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
3953 fib6_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
3958 mlxsw_sp_nexthop6_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3959 struct mlxsw_sp_nexthop_group *nh_grp)
3961 struct mlxsw_sp_fib6_entry *fib6_entry;
3963 /* Unfortunately, in IPv6 the route and the nexthop are described by
3964 * the same struct, so we need to iterate over all the routes using the
3965 * nexthop group and set / clear the offload indication for them.
3967 list_for_each_entry(fib6_entry, &nh_grp->fib_list,
3968 common.nexthop_group_node)
3969 __mlxsw_sp_nexthop6_group_offload_refresh(nh_grp, fib6_entry);
3973 mlxsw_sp_nexthop_bucket_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3974 const struct mlxsw_sp_nexthop *nh,
3977 struct mlxsw_sp_nexthop_group *nh_grp = nh->nhgi->nh_grp;
3978 bool offload = false, trap = false;
3980 if (nh->offloaded) {
3981 if (nh->action == MLXSW_SP_NEXTHOP_ACTION_TRAP)
3986 nexthop_bucket_set_hw_flags(mlxsw_sp_net(mlxsw_sp), nh_grp->obj.id,
3987 bucket_index, offload, trap);
3991 mlxsw_sp_nexthop_obj_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3992 struct mlxsw_sp_nexthop_group *nh_grp)
3996 /* Do not update the flags if the nexthop group is being destroyed
3998 * 1. The nexthop objects is being deleted, in which case the flags are
4000 * 2. The nexthop group was replaced by a newer group, in which case
4001 * the flags of the nexthop object were already updated based on the
4004 if (nh_grp->can_destroy)
4007 nexthop_set_hw_flags(mlxsw_sp_net(mlxsw_sp), nh_grp->obj.id,
4008 nh_grp->nhgi->adj_index_valid, false);
4010 /* Update flags of individual nexthop buckets in case of a resilient
4013 if (!nh_grp->nhgi->is_resilient)
4016 for (i = 0; i < nh_grp->nhgi->count; i++) {
4017 struct mlxsw_sp_nexthop *nh = &nh_grp->nhgi->nexthops[i];
4019 mlxsw_sp_nexthop_bucket_offload_refresh(mlxsw_sp, nh, i);
4024 mlxsw_sp_nexthop_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
4025 struct mlxsw_sp_nexthop_group *nh_grp)
4027 switch (nh_grp->type) {
4028 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
4029 mlxsw_sp_nexthop4_group_offload_refresh(mlxsw_sp, nh_grp);
4031 case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
4032 mlxsw_sp_nexthop6_group_offload_refresh(mlxsw_sp, nh_grp);
4034 case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
4035 mlxsw_sp_nexthop_obj_group_offload_refresh(mlxsw_sp, nh_grp);
4041 mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
4042 struct mlxsw_sp_nexthop_group *nh_grp)
4044 struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
4045 u16 ecmp_size, old_ecmp_size;
4046 struct mlxsw_sp_nexthop *nh;
4047 bool offload_change = false;
4049 bool old_adj_index_valid;
4054 return mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
4056 for (i = 0; i < nhgi->count; i++) {
4057 nh = &nhgi->nexthops[i];
4059 if (nh->should_offload != nh->offloaded) {
4060 offload_change = true;
4061 if (nh->should_offload)
4065 if (!offload_change) {
4066 /* Nothing was added or removed, so no need to reallocate. Just
4067 * update MAC on existing adjacency indexes.
4069 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nhgi, false);
4071 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
4074 /* Flags of individual nexthop buckets might need to be
4077 mlxsw_sp_nexthop_group_offload_refresh(mlxsw_sp, nh_grp);
4080 mlxsw_sp_nexthop_group_normalize(nhgi);
4081 if (!nhgi->sum_norm_weight) {
4082 /* No neigh of this group is connected so we just set
4083 * the trap and let everthing flow through kernel.
4089 ecmp_size = nhgi->sum_norm_weight;
4090 err = mlxsw_sp_fix_adj_grp_size(mlxsw_sp, &ecmp_size);
4092 /* No valid allocation size available. */
4095 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4096 ecmp_size, &adj_index);
4098 /* We ran out of KVD linear space, just set the
4099 * trap and let everything flow through kernel.
4101 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
4104 old_adj_index_valid = nhgi->adj_index_valid;
4105 old_adj_index = nhgi->adj_index;
4106 old_ecmp_size = nhgi->ecmp_size;
4107 nhgi->adj_index_valid = 1;
4108 nhgi->adj_index = adj_index;
4109 nhgi->ecmp_size = ecmp_size;
4110 mlxsw_sp_nexthop_group_rebalance(nhgi);
4111 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nhgi, true);
4113 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
4117 mlxsw_sp_nexthop_group_offload_refresh(mlxsw_sp, nh_grp);
4119 if (!old_adj_index_valid) {
4120 /* The trap was set for fib entries, so we have to call
4121 * fib entry update to unset it and use adjacency index.
4123 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
4125 dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
4131 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
4132 old_adj_index, old_ecmp_size);
4133 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4134 old_ecmp_size, old_adj_index);
4136 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
4143 old_adj_index_valid = nhgi->adj_index_valid;
4144 nhgi->adj_index_valid = 0;
4145 for (i = 0; i < nhgi->count; i++) {
4146 nh = &nhgi->nexthops[i];
4149 err2 = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
4151 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
4152 mlxsw_sp_nexthop_group_offload_refresh(mlxsw_sp, nh_grp);
4153 if (old_adj_index_valid)
4154 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4155 nhgi->ecmp_size, nhgi->adj_index);
4159 static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
4163 nh->action = MLXSW_SP_NEXTHOP_ACTION_FORWARD;
4164 nh->should_offload = 1;
4165 } else if (nh->nhgi->is_resilient) {
4166 nh->action = MLXSW_SP_NEXTHOP_ACTION_TRAP;
4167 nh->should_offload = 1;
4169 nh->should_offload = 0;
4175 mlxsw_sp_nexthop_dead_neigh_replace(struct mlxsw_sp *mlxsw_sp,
4176 struct mlxsw_sp_neigh_entry *neigh_entry)
4178 struct neighbour *n, *old_n = neigh_entry->key.n;
4179 struct mlxsw_sp_nexthop *nh;
4180 struct net_device *dev;
4181 bool entry_connected;
4185 nh = list_first_entry(&neigh_entry->nexthop_list,
4186 struct mlxsw_sp_nexthop, neigh_list_node);
4187 dev = mlxsw_sp_nexthop_dev(nh);
4189 n = neigh_lookup(nh->neigh_tbl, &nh->gw_addr, dev);
4191 n = neigh_create(nh->neigh_tbl, &nh->gw_addr, dev);
4194 neigh_event_send(n, NULL);
4197 mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
4198 neigh_entry->key.n = n;
4199 err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
4201 goto err_neigh_entry_insert;
4203 read_lock_bh(&n->lock);
4204 nud_state = n->nud_state;
4206 read_unlock_bh(&n->lock);
4207 entry_connected = nud_state & NUD_VALID && !dead;
4209 list_for_each_entry(nh, &neigh_entry->nexthop_list,
4211 neigh_release(old_n);
4213 __mlxsw_sp_nexthop_neigh_update(nh, !entry_connected);
4214 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4221 err_neigh_entry_insert:
4222 neigh_entry->key.n = old_n;
4223 mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
4229 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
4230 struct mlxsw_sp_neigh_entry *neigh_entry,
4231 bool removing, bool dead)
4233 struct mlxsw_sp_nexthop *nh;
4235 if (list_empty(&neigh_entry->nexthop_list))
4241 err = mlxsw_sp_nexthop_dead_neigh_replace(mlxsw_sp,
4244 dev_err(mlxsw_sp->bus_info->dev, "Failed to replace dead neigh\n");
4248 list_for_each_entry(nh, &neigh_entry->nexthop_list,
4250 __mlxsw_sp_nexthop_neigh_update(nh, removing);
4251 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4255 static void mlxsw_sp_nexthop_crif_init(struct mlxsw_sp_nexthop *nh,
4256 struct mlxsw_sp_crif *crif)
4262 list_add(&nh->crif_list_node, &crif->nexthop_list);
4265 static void mlxsw_sp_nexthop_crif_fini(struct mlxsw_sp_nexthop *nh)
4270 list_del(&nh->crif_list_node);
4274 static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
4275 struct mlxsw_sp_nexthop *nh)
4277 struct mlxsw_sp_neigh_entry *neigh_entry;
4278 struct net_device *dev;
4279 struct neighbour *n;
4283 if (WARN_ON(!nh->crif->rif))
4286 if (!nh->nhgi->gateway || nh->neigh_entry)
4288 dev = mlxsw_sp_nexthop_dev(nh);
4290 /* Take a reference of neigh here ensuring that neigh would
4291 * not be destructed before the nexthop entry is finished.
4292 * The reference is taken either in neigh_lookup() or
4293 * in neigh_create() in case n is not found.
4295 n = neigh_lookup(nh->neigh_tbl, &nh->gw_addr, dev);
4297 n = neigh_create(nh->neigh_tbl, &nh->gw_addr, dev);
4300 neigh_event_send(n, NULL);
4302 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
4304 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
4305 if (IS_ERR(neigh_entry)) {
4307 goto err_neigh_entry_create;
4311 /* If that is the first nexthop connected to that neigh, add to
4312 * nexthop_neighs_list
4314 if (list_empty(&neigh_entry->nexthop_list))
4315 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
4316 &mlxsw_sp->router->nexthop_neighs_list);
4318 nh->neigh_entry = neigh_entry;
4319 list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
4320 read_lock_bh(&n->lock);
4321 nud_state = n->nud_state;
4323 read_unlock_bh(&n->lock);
4324 __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
4328 err_neigh_entry_create:
4333 static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
4334 struct mlxsw_sp_nexthop *nh)
4336 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
4337 struct neighbour *n;
4341 n = neigh_entry->key.n;
4343 __mlxsw_sp_nexthop_neigh_update(nh, true);
4344 list_del(&nh->neigh_list_node);
4345 nh->neigh_entry = NULL;
4347 /* If that is the last nexthop connected to that neigh, remove from
4348 * nexthop_neighs_list
4350 if (list_empty(&neigh_entry->nexthop_list))
4351 list_del(&neigh_entry->nexthop_neighs_list_node);
4353 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
4354 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
4359 static bool mlxsw_sp_ipip_netdev_ul_up(struct net_device *ol_dev)
4361 struct net_device *ul_dev;
4365 ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
4366 is_up = ul_dev ? (ul_dev->flags & IFF_UP) : true;
4372 static void mlxsw_sp_nexthop_ipip_init(struct mlxsw_sp *mlxsw_sp,
4373 struct mlxsw_sp_nexthop *nh,
4374 struct mlxsw_sp_ipip_entry *ipip_entry)
4376 struct mlxsw_sp_crif *crif;
4379 if (!nh->nhgi->gateway || nh->ipip_entry)
4382 crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, ipip_entry->ol_dev);
4386 nh->ipip_entry = ipip_entry;
4387 removing = !mlxsw_sp_ipip_netdev_ul_up(ipip_entry->ol_dev);
4388 __mlxsw_sp_nexthop_neigh_update(nh, removing);
4389 mlxsw_sp_nexthop_crif_init(nh, crif);
4392 static void mlxsw_sp_nexthop_ipip_fini(struct mlxsw_sp *mlxsw_sp,
4393 struct mlxsw_sp_nexthop *nh)
4395 struct mlxsw_sp_ipip_entry *ipip_entry = nh->ipip_entry;
4400 __mlxsw_sp_nexthop_neigh_update(nh, true);
4401 nh->ipip_entry = NULL;
4404 static bool mlxsw_sp_nexthop4_ipip_type(const struct mlxsw_sp *mlxsw_sp,
4405 const struct fib_nh *fib_nh,
4406 enum mlxsw_sp_ipip_type *p_ipipt)
4408 struct net_device *dev = fib_nh->fib_nh_dev;
4411 fib_nh->nh_parent->fib_type == RTN_UNICAST &&
4412 mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, p_ipipt);
4415 static int mlxsw_sp_nexthop_type_init(struct mlxsw_sp *mlxsw_sp,
4416 struct mlxsw_sp_nexthop *nh,
4417 const struct net_device *dev)
4419 const struct mlxsw_sp_ipip_ops *ipip_ops;
4420 struct mlxsw_sp_ipip_entry *ipip_entry;
4421 struct mlxsw_sp_crif *crif;
4424 ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, dev);
4426 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
4427 if (ipip_ops->can_offload(mlxsw_sp, dev)) {
4428 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
4429 mlxsw_sp_nexthop_ipip_init(mlxsw_sp, nh, ipip_entry);
4434 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
4435 crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, dev);
4439 mlxsw_sp_nexthop_crif_init(nh, crif);
4444 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
4446 goto err_neigh_init;
4451 mlxsw_sp_nexthop_crif_fini(nh);
4455 static int mlxsw_sp_nexthop_type_rif_made(struct mlxsw_sp *mlxsw_sp,
4456 struct mlxsw_sp_nexthop *nh)
4459 case MLXSW_SP_NEXTHOP_TYPE_ETH:
4460 return mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
4461 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
4468 static void mlxsw_sp_nexthop_type_rif_gone(struct mlxsw_sp *mlxsw_sp,
4469 struct mlxsw_sp_nexthop *nh)
4472 case MLXSW_SP_NEXTHOP_TYPE_ETH:
4473 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
4475 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
4476 mlxsw_sp_nexthop_ipip_fini(mlxsw_sp, nh);
4481 static void mlxsw_sp_nexthop_type_fini(struct mlxsw_sp *mlxsw_sp,
4482 struct mlxsw_sp_nexthop *nh)
4484 mlxsw_sp_nexthop_type_rif_gone(mlxsw_sp, nh);
4485 mlxsw_sp_nexthop_crif_fini(nh);
4488 static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
4489 struct mlxsw_sp_nexthop_group *nh_grp,
4490 struct mlxsw_sp_nexthop *nh,
4491 struct fib_nh *fib_nh)
4493 struct net_device *dev = fib_nh->fib_nh_dev;
4494 struct in_device *in_dev;
4497 nh->nhgi = nh_grp->nhgi;
4498 nh->key.fib_nh = fib_nh;
4499 #ifdef CONFIG_IP_ROUTE_MULTIPATH
4500 nh->nh_weight = fib_nh->fib_nh_weight;
4504 memcpy(&nh->gw_addr, &fib_nh->fib_nh_gw4, sizeof(fib_nh->fib_nh_gw4));
4505 nh->neigh_tbl = &arp_tbl;
4506 err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
4510 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
4511 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
4515 nh->ifindex = dev->ifindex;
4518 in_dev = __in_dev_get_rcu(dev);
4519 if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
4520 fib_nh->fib_nh_flags & RTNH_F_LINKDOWN) {
4526 err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
4528 goto err_nexthop_neigh_init;
4532 err_nexthop_neigh_init:
4533 list_del(&nh->router_list_node);
4534 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
4535 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
4539 static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
4540 struct mlxsw_sp_nexthop *nh)
4542 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4543 list_del(&nh->router_list_node);
4544 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
4545 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
4548 static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
4549 unsigned long event, struct fib_nh *fib_nh)
4551 struct mlxsw_sp_nexthop_key key;
4552 struct mlxsw_sp_nexthop *nh;
4554 key.fib_nh = fib_nh;
4555 nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
4560 case FIB_EVENT_NH_ADD:
4561 mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, fib_nh->fib_nh_dev);
4563 case FIB_EVENT_NH_DEL:
4564 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4568 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4571 static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp,
4572 struct mlxsw_sp_rif *rif)
4574 struct net_device *dev = mlxsw_sp_rif_dev(rif);
4575 struct mlxsw_sp_nexthop *nh;
4578 list_for_each_entry(nh, &rif->crif->nexthop_list, crif_list_node) {
4580 case MLXSW_SP_NEXTHOP_TYPE_ETH:
4583 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
4584 removing = !mlxsw_sp_ipip_netdev_ul_up(dev);
4591 __mlxsw_sp_nexthop_neigh_update(nh, removing);
4592 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4596 static int mlxsw_sp_nexthop_rif_made_sync(struct mlxsw_sp *mlxsw_sp,
4597 struct mlxsw_sp_rif *rif)
4599 struct mlxsw_sp_nexthop *nh, *tmp;
4603 list_for_each_entry_safe(nh, tmp, &rif->crif->nexthop_list,
4605 err = mlxsw_sp_nexthop_type_rif_made(mlxsw_sp, nh);
4607 goto err_nexthop_type_rif;
4608 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4614 err_nexthop_type_rif:
4615 list_for_each_entry_safe(nh, tmp, &rif->crif->nexthop_list,
4619 mlxsw_sp_nexthop_type_rif_gone(mlxsw_sp, nh);
4620 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4625 static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
4626 struct mlxsw_sp_rif *rif)
4628 struct mlxsw_sp_nexthop *nh, *tmp;
4630 list_for_each_entry_safe(nh, tmp, &rif->crif->nexthop_list,
4632 mlxsw_sp_nexthop_type_rif_gone(mlxsw_sp, nh);
4633 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4637 static int mlxsw_sp_adj_trap_entry_init(struct mlxsw_sp *mlxsw_sp)
4639 enum mlxsw_reg_ratr_trap_action trap_action;
4640 char ratr_pl[MLXSW_REG_RATR_LEN];
4643 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4644 &mlxsw_sp->router->adj_trap_index);
4648 trap_action = MLXSW_REG_RATR_TRAP_ACTION_TRAP;
4649 mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY, true,
4650 MLXSW_REG_RATR_TYPE_ETHERNET,
4651 mlxsw_sp->router->adj_trap_index,
4652 mlxsw_sp->router->lb_crif->rif->rif_index);
4653 mlxsw_reg_ratr_trap_action_set(ratr_pl, trap_action);
4654 mlxsw_reg_ratr_trap_id_set(ratr_pl, MLXSW_TRAP_ID_RTR_EGRESS0);
4655 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
4657 goto err_ratr_write;
4662 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4663 mlxsw_sp->router->adj_trap_index);
4667 static void mlxsw_sp_adj_trap_entry_fini(struct mlxsw_sp *mlxsw_sp)
4669 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4670 mlxsw_sp->router->adj_trap_index);
4673 static int mlxsw_sp_nexthop_group_inc(struct mlxsw_sp *mlxsw_sp)
4677 if (refcount_inc_not_zero(&mlxsw_sp->router->num_groups))
4680 err = mlxsw_sp_adj_trap_entry_init(mlxsw_sp);
4684 refcount_set(&mlxsw_sp->router->num_groups, 1);
4689 static void mlxsw_sp_nexthop_group_dec(struct mlxsw_sp *mlxsw_sp)
4691 if (!refcount_dec_and_test(&mlxsw_sp->router->num_groups))
4694 mlxsw_sp_adj_trap_entry_fini(mlxsw_sp);
4698 mlxsw_sp_nh_grp_activity_get(struct mlxsw_sp *mlxsw_sp,
4699 const struct mlxsw_sp_nexthop_group *nh_grp,
4700 unsigned long *activity)
4705 ratrad_pl = kmalloc(MLXSW_REG_RATRAD_LEN, GFP_KERNEL);
4709 mlxsw_reg_ratrad_pack(ratrad_pl, nh_grp->nhgi->adj_index,
4710 nh_grp->nhgi->count);
4711 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ratrad), ratrad_pl);
4715 for (i = 0; i < nh_grp->nhgi->count; i++) {
4716 if (!mlxsw_reg_ratrad_activity_vector_get(ratrad_pl, i))
4718 bitmap_set(activity, i, 1);
4725 #define MLXSW_SP_NH_GRP_ACTIVITY_UPDATE_INTERVAL 1000 /* ms */
4728 mlxsw_sp_nh_grp_activity_update(struct mlxsw_sp *mlxsw_sp,
4729 const struct mlxsw_sp_nexthop_group *nh_grp)
4731 unsigned long *activity;
4733 activity = bitmap_zalloc(nh_grp->nhgi->count, GFP_KERNEL);
4737 mlxsw_sp_nh_grp_activity_get(mlxsw_sp, nh_grp, activity);
4738 nexthop_res_grp_activity_update(mlxsw_sp_net(mlxsw_sp), nh_grp->obj.id,
4739 nh_grp->nhgi->count, activity);
4741 bitmap_free(activity);
4745 mlxsw_sp_nh_grp_activity_work_schedule(struct mlxsw_sp *mlxsw_sp)
4747 unsigned int interval = MLXSW_SP_NH_GRP_ACTIVITY_UPDATE_INTERVAL;
4749 mlxsw_core_schedule_dw(&mlxsw_sp->router->nh_grp_activity_dw,
4750 msecs_to_jiffies(interval));
4753 static void mlxsw_sp_nh_grp_activity_work(struct work_struct *work)
4755 struct mlxsw_sp_nexthop_group_info *nhgi;
4756 struct mlxsw_sp_router *router;
4757 bool reschedule = false;
4759 router = container_of(work, struct mlxsw_sp_router,
4760 nh_grp_activity_dw.work);
4762 mutex_lock(&router->lock);
4764 list_for_each_entry(nhgi, &router->nh_res_grp_list, list) {
4765 mlxsw_sp_nh_grp_activity_update(router->mlxsw_sp, nhgi->nh_grp);
4769 mutex_unlock(&router->lock);
4773 mlxsw_sp_nh_grp_activity_work_schedule(router->mlxsw_sp);
4777 mlxsw_sp_nexthop_obj_single_validate(struct mlxsw_sp *mlxsw_sp,
4778 const struct nh_notifier_single_info *nh,
4779 struct netlink_ext_ack *extack)
4784 NL_SET_ERR_MSG_MOD(extack, "FDB nexthops are not supported");
4785 else if (nh->has_encap)
4786 NL_SET_ERR_MSG_MOD(extack, "Encapsulating nexthops are not supported");
4794 mlxsw_sp_nexthop_obj_group_entry_validate(struct mlxsw_sp *mlxsw_sp,
4795 const struct nh_notifier_single_info *nh,
4796 struct netlink_ext_ack *extack)
4800 err = mlxsw_sp_nexthop_obj_single_validate(mlxsw_sp, nh, extack);
4804 /* Device only nexthops with an IPIP device are programmed as
4805 * encapsulating adjacency entries.
4807 if (!nh->gw_family && !nh->is_reject &&
4808 !mlxsw_sp_netdev_ipip_type(mlxsw_sp, nh->dev, NULL)) {
4809 NL_SET_ERR_MSG_MOD(extack, "Nexthop group entry does not have a gateway");
4817 mlxsw_sp_nexthop_obj_group_validate(struct mlxsw_sp *mlxsw_sp,
4818 const struct nh_notifier_grp_info *nh_grp,
4819 struct netlink_ext_ack *extack)
4823 if (nh_grp->is_fdb) {
4824 NL_SET_ERR_MSG_MOD(extack, "FDB nexthop groups are not supported");
4828 for (i = 0; i < nh_grp->num_nh; i++) {
4829 const struct nh_notifier_single_info *nh;
4832 nh = &nh_grp->nh_entries[i].nh;
4833 err = mlxsw_sp_nexthop_obj_group_entry_validate(mlxsw_sp, nh,
4843 mlxsw_sp_nexthop_obj_res_group_size_validate(struct mlxsw_sp *mlxsw_sp,
4844 const struct nh_notifier_res_table_info *nh_res_table,
4845 struct netlink_ext_ack *extack)
4847 unsigned int alloc_size;
4848 bool valid_size = false;
4851 if (nh_res_table->num_nh_buckets < 32) {
4852 NL_SET_ERR_MSG_MOD(extack, "Minimum number of buckets is 32");
4856 for (i = 0; i < mlxsw_sp->router->adj_grp_size_ranges_count; i++) {
4857 const struct mlxsw_sp_adj_grp_size_range *size_range;
4859 size_range = &mlxsw_sp->router->adj_grp_size_ranges[i];
4861 if (nh_res_table->num_nh_buckets >= size_range->start &&
4862 nh_res_table->num_nh_buckets <= size_range->end) {
4869 NL_SET_ERR_MSG_MOD(extack, "Invalid number of buckets");
4873 err = mlxsw_sp_kvdl_alloc_count_query(mlxsw_sp,
4874 MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4875 nh_res_table->num_nh_buckets,
4877 if (err || nh_res_table->num_nh_buckets != alloc_size) {
4878 NL_SET_ERR_MSG_MOD(extack, "Number of buckets does not fit allocation size of any KVDL partition");
4886 mlxsw_sp_nexthop_obj_res_group_validate(struct mlxsw_sp *mlxsw_sp,
4887 const struct nh_notifier_res_table_info *nh_res_table,
4888 struct netlink_ext_ack *extack)
4893 err = mlxsw_sp_nexthop_obj_res_group_size_validate(mlxsw_sp,
4899 for (i = 0; i < nh_res_table->num_nh_buckets; i++) {
4900 const struct nh_notifier_single_info *nh;
4903 nh = &nh_res_table->nhs[i];
4904 err = mlxsw_sp_nexthop_obj_group_entry_validate(mlxsw_sp, nh,
4913 static int mlxsw_sp_nexthop_obj_validate(struct mlxsw_sp *mlxsw_sp,
4914 unsigned long event,
4915 struct nh_notifier_info *info)
4917 struct nh_notifier_single_info *nh;
4919 if (event != NEXTHOP_EVENT_REPLACE &&
4920 event != NEXTHOP_EVENT_RES_TABLE_PRE_REPLACE &&
4921 event != NEXTHOP_EVENT_BUCKET_REPLACE)
4924 switch (info->type) {
4925 case NH_NOTIFIER_INFO_TYPE_SINGLE:
4926 return mlxsw_sp_nexthop_obj_single_validate(mlxsw_sp, info->nh,
4928 case NH_NOTIFIER_INFO_TYPE_GRP:
4929 return mlxsw_sp_nexthop_obj_group_validate(mlxsw_sp,
4932 case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
4933 return mlxsw_sp_nexthop_obj_res_group_validate(mlxsw_sp,
4936 case NH_NOTIFIER_INFO_TYPE_RES_BUCKET:
4937 nh = &info->nh_res_bucket->new_nh;
4938 return mlxsw_sp_nexthop_obj_group_entry_validate(mlxsw_sp, nh,
4941 NL_SET_ERR_MSG_MOD(info->extack, "Unsupported nexthop type");
4946 static bool mlxsw_sp_nexthop_obj_is_gateway(struct mlxsw_sp *mlxsw_sp,
4947 const struct nh_notifier_info *info)
4949 const struct net_device *dev;
4951 switch (info->type) {
4952 case NH_NOTIFIER_INFO_TYPE_SINGLE:
4953 dev = info->nh->dev;
4954 return info->nh->gw_family || info->nh->is_reject ||
4955 mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL);
4956 case NH_NOTIFIER_INFO_TYPE_GRP:
4957 case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
4958 /* Already validated earlier. */
4965 static void mlxsw_sp_nexthop_obj_blackhole_init(struct mlxsw_sp *mlxsw_sp,
4966 struct mlxsw_sp_nexthop *nh)
4968 nh->action = MLXSW_SP_NEXTHOP_ACTION_DISCARD;
4969 nh->should_offload = 1;
4970 /* While nexthops that discard packets do not forward packets
4971 * via an egress RIF, they still need to be programmed using a
4972 * valid RIF, so use the loopback RIF created during init.
4974 nh->crif = mlxsw_sp->router->lb_crif;
4977 static void mlxsw_sp_nexthop_obj_blackhole_fini(struct mlxsw_sp *mlxsw_sp,
4978 struct mlxsw_sp_nexthop *nh)
4981 nh->should_offload = 0;
4985 mlxsw_sp_nexthop_obj_init(struct mlxsw_sp *mlxsw_sp,
4986 struct mlxsw_sp_nexthop_group *nh_grp,
4987 struct mlxsw_sp_nexthop *nh,
4988 struct nh_notifier_single_info *nh_obj, int weight)
4990 struct net_device *dev = nh_obj->dev;
4993 nh->nhgi = nh_grp->nhgi;
4994 nh->nh_weight = weight;
4996 switch (nh_obj->gw_family) {
4998 memcpy(&nh->gw_addr, &nh_obj->ipv4, sizeof(nh_obj->ipv4));
4999 nh->neigh_tbl = &arp_tbl;
5002 memcpy(&nh->gw_addr, &nh_obj->ipv6, sizeof(nh_obj->ipv6));
5003 #if IS_ENABLED(CONFIG_IPV6)
5004 nh->neigh_tbl = &nd_tbl;
5009 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
5010 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
5011 nh->ifindex = dev->ifindex;
5013 err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
5017 if (nh_obj->is_reject)
5018 mlxsw_sp_nexthop_obj_blackhole_init(mlxsw_sp, nh);
5020 /* In a resilient nexthop group, all the nexthops must be written to
5021 * the adjacency table. Even if they do not have a valid neighbour or
5024 if (nh_grp->nhgi->is_resilient && !nh->should_offload) {
5025 nh->action = MLXSW_SP_NEXTHOP_ACTION_TRAP;
5026 nh->should_offload = 1;
5032 list_del(&nh->router_list_node);
5033 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
5037 static void mlxsw_sp_nexthop_obj_fini(struct mlxsw_sp *mlxsw_sp,
5038 struct mlxsw_sp_nexthop *nh)
5040 if (nh->action == MLXSW_SP_NEXTHOP_ACTION_DISCARD)
5041 mlxsw_sp_nexthop_obj_blackhole_fini(mlxsw_sp, nh);
5042 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
5043 list_del(&nh->router_list_node);
5044 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
5045 nh->should_offload = 0;
5049 mlxsw_sp_nexthop_obj_group_info_init(struct mlxsw_sp *mlxsw_sp,
5050 struct mlxsw_sp_nexthop_group *nh_grp,
5051 struct nh_notifier_info *info)
5053 struct mlxsw_sp_nexthop_group_info *nhgi;
5054 struct mlxsw_sp_nexthop *nh;
5055 bool is_resilient = false;
5059 switch (info->type) {
5060 case NH_NOTIFIER_INFO_TYPE_SINGLE:
5063 case NH_NOTIFIER_INFO_TYPE_GRP:
5064 nhs = info->nh_grp->num_nh;
5066 case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
5067 nhs = info->nh_res_table->num_nh_buckets;
5068 is_resilient = true;
5074 nhgi = kzalloc(struct_size(nhgi, nexthops, nhs), GFP_KERNEL);
5077 nh_grp->nhgi = nhgi;
5078 nhgi->nh_grp = nh_grp;
5079 nhgi->gateway = mlxsw_sp_nexthop_obj_is_gateway(mlxsw_sp, info);
5080 nhgi->is_resilient = is_resilient;
5082 for (i = 0; i < nhgi->count; i++) {
5083 struct nh_notifier_single_info *nh_obj;
5086 nh = &nhgi->nexthops[i];
5087 switch (info->type) {
5088 case NH_NOTIFIER_INFO_TYPE_SINGLE:
5092 case NH_NOTIFIER_INFO_TYPE_GRP:
5093 nh_obj = &info->nh_grp->nh_entries[i].nh;
5094 weight = info->nh_grp->nh_entries[i].weight;
5096 case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
5097 nh_obj = &info->nh_res_table->nhs[i];
5102 goto err_nexthop_obj_init;
5104 err = mlxsw_sp_nexthop_obj_init(mlxsw_sp, nh_grp, nh, nh_obj,
5107 goto err_nexthop_obj_init;
5109 err = mlxsw_sp_nexthop_group_inc(mlxsw_sp);
5112 err = mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5114 NL_SET_ERR_MSG_MOD(info->extack, "Failed to write adjacency entries to the device");
5115 goto err_group_refresh;
5118 /* Add resilient nexthop groups to a list so that the activity of their
5119 * nexthop buckets will be periodically queried and cleared.
5121 if (nhgi->is_resilient) {
5122 if (list_empty(&mlxsw_sp->router->nh_res_grp_list))
5123 mlxsw_sp_nh_grp_activity_work_schedule(mlxsw_sp);
5124 list_add(&nhgi->list, &mlxsw_sp->router->nh_res_grp_list);
5130 mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5133 err_nexthop_obj_init:
5134 for (i--; i >= 0; i--) {
5135 nh = &nhgi->nexthops[i];
5136 mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5143 mlxsw_sp_nexthop_obj_group_info_fini(struct mlxsw_sp *mlxsw_sp,
5144 struct mlxsw_sp_nexthop_group *nh_grp)
5146 struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
5147 struct mlxsw_sp_router *router = mlxsw_sp->router;
5150 if (nhgi->is_resilient) {
5151 list_del(&nhgi->list);
5152 if (list_empty(&mlxsw_sp->router->nh_res_grp_list))
5153 cancel_delayed_work(&router->nh_grp_activity_dw);
5156 mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5157 for (i = nhgi->count - 1; i >= 0; i--) {
5158 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
5160 mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5162 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5163 WARN_ON_ONCE(nhgi->adj_index_valid);
5167 static struct mlxsw_sp_nexthop_group *
5168 mlxsw_sp_nexthop_obj_group_create(struct mlxsw_sp *mlxsw_sp,
5169 struct nh_notifier_info *info)
5171 struct mlxsw_sp_nexthop_group *nh_grp;
5174 nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
5176 return ERR_PTR(-ENOMEM);
5177 INIT_LIST_HEAD(&nh_grp->vr_list);
5178 err = rhashtable_init(&nh_grp->vr_ht,
5179 &mlxsw_sp_nexthop_group_vr_ht_params);
5181 goto err_nexthop_group_vr_ht_init;
5182 INIT_LIST_HEAD(&nh_grp->fib_list);
5183 nh_grp->type = MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ;
5184 nh_grp->obj.id = info->id;
5186 err = mlxsw_sp_nexthop_obj_group_info_init(mlxsw_sp, nh_grp, info);
5188 goto err_nexthop_group_info_init;
5190 nh_grp->can_destroy = false;
5194 err_nexthop_group_info_init:
5195 rhashtable_destroy(&nh_grp->vr_ht);
5196 err_nexthop_group_vr_ht_init:
5198 return ERR_PTR(err);
5202 mlxsw_sp_nexthop_obj_group_destroy(struct mlxsw_sp *mlxsw_sp,
5203 struct mlxsw_sp_nexthop_group *nh_grp)
5205 if (!nh_grp->can_destroy)
5207 mlxsw_sp_nexthop_obj_group_info_fini(mlxsw_sp, nh_grp);
5208 WARN_ON_ONCE(!list_empty(&nh_grp->fib_list));
5209 WARN_ON_ONCE(!list_empty(&nh_grp->vr_list));
5210 rhashtable_destroy(&nh_grp->vr_ht);
5214 static struct mlxsw_sp_nexthop_group *
5215 mlxsw_sp_nexthop_obj_group_lookup(struct mlxsw_sp *mlxsw_sp, u32 id)
5217 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
5219 cmp_arg.type = MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ;
5221 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
5223 mlxsw_sp_nexthop_group_ht_params);
5226 static int mlxsw_sp_nexthop_obj_group_add(struct mlxsw_sp *mlxsw_sp,
5227 struct mlxsw_sp_nexthop_group *nh_grp)
5229 return mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
5233 mlxsw_sp_nexthop_obj_group_replace(struct mlxsw_sp *mlxsw_sp,
5234 struct mlxsw_sp_nexthop_group *nh_grp,
5235 struct mlxsw_sp_nexthop_group *old_nh_grp,
5236 struct netlink_ext_ack *extack)
5238 struct mlxsw_sp_nexthop_group_info *old_nhgi = old_nh_grp->nhgi;
5239 struct mlxsw_sp_nexthop_group_info *new_nhgi = nh_grp->nhgi;
5242 old_nh_grp->nhgi = new_nhgi;
5243 new_nhgi->nh_grp = old_nh_grp;
5244 nh_grp->nhgi = old_nhgi;
5245 old_nhgi->nh_grp = nh_grp;
5247 if (old_nhgi->adj_index_valid && new_nhgi->adj_index_valid) {
5248 /* Both the old adjacency index and the new one are valid.
5249 * Routes are currently using the old one. Tell the device to
5250 * replace the old adjacency index with the new one.
5252 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, old_nh_grp,
5253 old_nhgi->adj_index,
5254 old_nhgi->ecmp_size);
5256 NL_SET_ERR_MSG_MOD(extack, "Failed to replace old adjacency index with new one");
5259 } else if (old_nhgi->adj_index_valid && !new_nhgi->adj_index_valid) {
5260 /* The old adjacency index is valid, while the new one is not.
5261 * Iterate over all the routes using the group and change them
5262 * to trap packets to the CPU.
5264 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, old_nh_grp);
5266 NL_SET_ERR_MSG_MOD(extack, "Failed to update routes to trap packets");
5269 } else if (!old_nhgi->adj_index_valid && new_nhgi->adj_index_valid) {
5270 /* The old adjacency index is invalid, while the new one is.
5271 * Iterate over all the routes using the group and change them
5272 * to forward packets using the new valid index.
5274 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, old_nh_grp);
5276 NL_SET_ERR_MSG_MOD(extack, "Failed to update routes to forward packets");
5281 /* Make sure the flags are set / cleared based on the new nexthop group
5284 mlxsw_sp_nexthop_obj_group_offload_refresh(mlxsw_sp, old_nh_grp);
5286 /* At this point 'nh_grp' is just a shell that is not used by anyone
5287 * and its nexthop group info is the old info that was just replaced
5288 * with the new one. Remove it.
5290 nh_grp->can_destroy = true;
5291 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5296 old_nhgi->nh_grp = old_nh_grp;
5297 nh_grp->nhgi = new_nhgi;
5298 new_nhgi->nh_grp = nh_grp;
5299 old_nh_grp->nhgi = old_nhgi;
5303 static int mlxsw_sp_nexthop_obj_new(struct mlxsw_sp *mlxsw_sp,
5304 struct nh_notifier_info *info)
5306 struct mlxsw_sp_nexthop_group *nh_grp, *old_nh_grp;
5307 struct netlink_ext_ack *extack = info->extack;
5310 nh_grp = mlxsw_sp_nexthop_obj_group_create(mlxsw_sp, info);
5312 return PTR_ERR(nh_grp);
5314 old_nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, info->id);
5316 err = mlxsw_sp_nexthop_obj_group_add(mlxsw_sp, nh_grp);
5318 err = mlxsw_sp_nexthop_obj_group_replace(mlxsw_sp, nh_grp,
5319 old_nh_grp, extack);
5322 nh_grp->can_destroy = true;
5323 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5329 static void mlxsw_sp_nexthop_obj_del(struct mlxsw_sp *mlxsw_sp,
5330 struct nh_notifier_info *info)
5332 struct mlxsw_sp_nexthop_group *nh_grp;
5334 nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, info->id);
5338 nh_grp->can_destroy = true;
5339 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
5341 /* If the group still has routes using it, then defer the delete
5342 * operation until the last route using it is deleted.
5344 if (!list_empty(&nh_grp->fib_list))
5346 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5349 static int mlxsw_sp_nexthop_obj_bucket_query(struct mlxsw_sp *mlxsw_sp,
5350 u32 adj_index, char *ratr_pl)
5352 MLXSW_REG_ZERO(ratr, ratr_pl);
5353 mlxsw_reg_ratr_op_set(ratr_pl, MLXSW_REG_RATR_OP_QUERY_READ);
5354 mlxsw_reg_ratr_adjacency_index_low_set(ratr_pl, adj_index);
5355 mlxsw_reg_ratr_adjacency_index_high_set(ratr_pl, adj_index >> 16);
5357 return mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
5360 static int mlxsw_sp_nexthop_obj_bucket_compare(char *ratr_pl, char *ratr_pl_new)
5362 /* Clear the opcode and activity on both the old and new payload as
5363 * they are irrelevant for the comparison.
5365 mlxsw_reg_ratr_op_set(ratr_pl, MLXSW_REG_RATR_OP_QUERY_READ);
5366 mlxsw_reg_ratr_a_set(ratr_pl, 0);
5367 mlxsw_reg_ratr_op_set(ratr_pl_new, MLXSW_REG_RATR_OP_QUERY_READ);
5368 mlxsw_reg_ratr_a_set(ratr_pl_new, 0);
5370 /* If the contents of the adjacency entry are consistent with the
5371 * replacement request, then replacement was successful.
5373 if (!memcmp(ratr_pl, ratr_pl_new, MLXSW_REG_RATR_LEN))
5380 mlxsw_sp_nexthop_obj_bucket_adj_update(struct mlxsw_sp *mlxsw_sp,
5381 struct mlxsw_sp_nexthop *nh,
5382 struct nh_notifier_info *info)
5384 u16 bucket_index = info->nh_res_bucket->bucket_index;
5385 struct netlink_ext_ack *extack = info->extack;
5386 bool force = info->nh_res_bucket->force;
5387 char ratr_pl_new[MLXSW_REG_RATR_LEN];
5388 char ratr_pl[MLXSW_REG_RATR_LEN];
5392 /* No point in trying an atomic replacement if the idle timer interval
5393 * is smaller than the interval in which we query and clear activity.
5395 if (!force && info->nh_res_bucket->idle_timer_ms <
5396 MLXSW_SP_NH_GRP_ACTIVITY_UPDATE_INTERVAL)
5399 adj_index = nh->nhgi->adj_index + bucket_index;
5400 err = mlxsw_sp_nexthop_update(mlxsw_sp, adj_index, nh, force, ratr_pl);
5402 NL_SET_ERR_MSG_MOD(extack, "Failed to overwrite nexthop bucket");
5407 err = mlxsw_sp_nexthop_obj_bucket_query(mlxsw_sp, adj_index,
5410 NL_SET_ERR_MSG_MOD(extack, "Failed to query nexthop bucket state after replacement. State might be inconsistent");
5414 err = mlxsw_sp_nexthop_obj_bucket_compare(ratr_pl, ratr_pl_new);
5416 NL_SET_ERR_MSG_MOD(extack, "Nexthop bucket was not replaced because it was active during replacement");
5423 mlxsw_sp_nexthop_bucket_offload_refresh(mlxsw_sp, nh, bucket_index);
5428 static int mlxsw_sp_nexthop_obj_bucket_replace(struct mlxsw_sp *mlxsw_sp,
5429 struct nh_notifier_info *info)
5431 u16 bucket_index = info->nh_res_bucket->bucket_index;
5432 struct netlink_ext_ack *extack = info->extack;
5433 struct mlxsw_sp_nexthop_group_info *nhgi;
5434 struct nh_notifier_single_info *nh_obj;
5435 struct mlxsw_sp_nexthop_group *nh_grp;
5436 struct mlxsw_sp_nexthop *nh;
5439 nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, info->id);
5441 NL_SET_ERR_MSG_MOD(extack, "Nexthop group was not found");
5445 nhgi = nh_grp->nhgi;
5447 if (bucket_index >= nhgi->count) {
5448 NL_SET_ERR_MSG_MOD(extack, "Nexthop bucket index out of range");
5452 nh = &nhgi->nexthops[bucket_index];
5453 mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5455 nh_obj = &info->nh_res_bucket->new_nh;
5456 err = mlxsw_sp_nexthop_obj_init(mlxsw_sp, nh_grp, nh, nh_obj, 1);
5458 NL_SET_ERR_MSG_MOD(extack, "Failed to initialize nexthop object for nexthop bucket replacement");
5459 goto err_nexthop_obj_init;
5462 err = mlxsw_sp_nexthop_obj_bucket_adj_update(mlxsw_sp, nh, info);
5464 goto err_nexthop_obj_bucket_adj_update;
5468 err_nexthop_obj_bucket_adj_update:
5469 mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5470 err_nexthop_obj_init:
5471 nh_obj = &info->nh_res_bucket->old_nh;
5472 mlxsw_sp_nexthop_obj_init(mlxsw_sp, nh_grp, nh, nh_obj, 1);
5473 /* The old adjacency entry was not overwritten */
5479 static int mlxsw_sp_nexthop_obj_event(struct notifier_block *nb,
5480 unsigned long event, void *ptr)
5482 struct nh_notifier_info *info = ptr;
5483 struct mlxsw_sp_router *router;
5486 router = container_of(nb, struct mlxsw_sp_router, nexthop_nb);
5487 err = mlxsw_sp_nexthop_obj_validate(router->mlxsw_sp, event, info);
5491 mutex_lock(&router->lock);
5494 case NEXTHOP_EVENT_REPLACE:
5495 err = mlxsw_sp_nexthop_obj_new(router->mlxsw_sp, info);
5497 case NEXTHOP_EVENT_DEL:
5498 mlxsw_sp_nexthop_obj_del(router->mlxsw_sp, info);
5500 case NEXTHOP_EVENT_BUCKET_REPLACE:
5501 err = mlxsw_sp_nexthop_obj_bucket_replace(router->mlxsw_sp,
5508 mutex_unlock(&router->lock);
5511 return notifier_from_errno(err);
5514 static bool mlxsw_sp_fi_is_gateway(const struct mlxsw_sp *mlxsw_sp,
5515 struct fib_info *fi)
5517 const struct fib_nh *nh = fib_info_nh(fi, 0);
5519 return nh->fib_nh_gw_family ||
5520 mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, nh, NULL);
5524 mlxsw_sp_nexthop4_group_info_init(struct mlxsw_sp *mlxsw_sp,
5525 struct mlxsw_sp_nexthop_group *nh_grp)
5527 unsigned int nhs = fib_info_num_path(nh_grp->ipv4.fi);
5528 struct mlxsw_sp_nexthop_group_info *nhgi;
5529 struct mlxsw_sp_nexthop *nh;
5532 nhgi = kzalloc(struct_size(nhgi, nexthops, nhs), GFP_KERNEL);
5535 nh_grp->nhgi = nhgi;
5536 nhgi->nh_grp = nh_grp;
5537 nhgi->gateway = mlxsw_sp_fi_is_gateway(mlxsw_sp, nh_grp->ipv4.fi);
5539 for (i = 0; i < nhgi->count; i++) {
5540 struct fib_nh *fib_nh;
5542 nh = &nhgi->nexthops[i];
5543 fib_nh = fib_info_nh(nh_grp->ipv4.fi, i);
5544 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
5546 goto err_nexthop4_init;
5548 err = mlxsw_sp_nexthop_group_inc(mlxsw_sp);
5551 err = mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5553 goto err_group_refresh;
5558 mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5562 for (i--; i >= 0; i--) {
5563 nh = &nhgi->nexthops[i];
5564 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
5571 mlxsw_sp_nexthop4_group_info_fini(struct mlxsw_sp *mlxsw_sp,
5572 struct mlxsw_sp_nexthop_group *nh_grp)
5574 struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
5577 mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5578 for (i = nhgi->count - 1; i >= 0; i--) {
5579 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
5581 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
5583 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5584 WARN_ON_ONCE(nhgi->adj_index_valid);
5588 static struct mlxsw_sp_nexthop_group *
5589 mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
5591 struct mlxsw_sp_nexthop_group *nh_grp;
5594 nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
5596 return ERR_PTR(-ENOMEM);
5597 INIT_LIST_HEAD(&nh_grp->vr_list);
5598 err = rhashtable_init(&nh_grp->vr_ht,
5599 &mlxsw_sp_nexthop_group_vr_ht_params);
5601 goto err_nexthop_group_vr_ht_init;
5602 INIT_LIST_HEAD(&nh_grp->fib_list);
5603 nh_grp->type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4;
5604 nh_grp->ipv4.fi = fi;
5607 err = mlxsw_sp_nexthop4_group_info_init(mlxsw_sp, nh_grp);
5609 goto err_nexthop_group_info_init;
5611 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
5613 goto err_nexthop_group_insert;
5615 nh_grp->can_destroy = true;
5619 err_nexthop_group_insert:
5620 mlxsw_sp_nexthop4_group_info_fini(mlxsw_sp, nh_grp);
5621 err_nexthop_group_info_init:
5623 rhashtable_destroy(&nh_grp->vr_ht);
5624 err_nexthop_group_vr_ht_init:
5626 return ERR_PTR(err);
5630 mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
5631 struct mlxsw_sp_nexthop_group *nh_grp)
5633 if (!nh_grp->can_destroy)
5635 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
5636 mlxsw_sp_nexthop4_group_info_fini(mlxsw_sp, nh_grp);
5637 fib_info_put(nh_grp->ipv4.fi);
5638 WARN_ON_ONCE(!list_empty(&nh_grp->vr_list));
5639 rhashtable_destroy(&nh_grp->vr_ht);
5643 static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
5644 struct mlxsw_sp_fib_entry *fib_entry,
5645 struct fib_info *fi)
5647 struct mlxsw_sp_nexthop_group *nh_grp;
5650 nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp,
5652 if (WARN_ON_ONCE(!nh_grp))
5657 nh_grp = mlxsw_sp_nexthop4_group_lookup(mlxsw_sp, fi);
5659 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
5661 return PTR_ERR(nh_grp);
5664 list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
5665 fib_entry->nh_group = nh_grp;
5669 static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
5670 struct mlxsw_sp_fib_entry *fib_entry)
5672 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
5674 list_del(&fib_entry->nexthop_group_node);
5675 if (!list_empty(&nh_grp->fib_list))
5678 if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ) {
5679 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5683 mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
5687 mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
5689 struct mlxsw_sp_fib4_entry *fib4_entry;
5691 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
5693 return !fib4_entry->dscp;
5697 mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
5699 struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
5701 switch (fib_entry->fib_node->fib->proto) {
5702 case MLXSW_SP_L3_PROTO_IPV4:
5703 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
5706 case MLXSW_SP_L3_PROTO_IPV6:
5710 switch (fib_entry->type) {
5711 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
5712 return !!nh_group->nhgi->adj_index_valid;
5713 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
5714 return !!mlxsw_sp_nhgi_rif(nh_group->nhgi);
5715 case MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE:
5716 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
5717 case MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP:
5724 static struct mlxsw_sp_nexthop *
5725 mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
5726 const struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
5730 for (i = 0; i < nh_grp->nhgi->count; i++) {
5731 struct mlxsw_sp_nexthop *nh = &nh_grp->nhgi->nexthops[i];
5732 struct net_device *dev = mlxsw_sp_nexthop_dev(nh);
5733 struct fib6_info *rt = mlxsw_sp_rt6->rt;
5735 if (dev && dev == rt->fib6_nh->fib_nh_dev &&
5736 ipv6_addr_equal((const struct in6_addr *) &nh->gw_addr,
5737 &rt->fib6_nh->fib_nh_gw6))
5745 mlxsw_sp_fib4_offload_failed_flag_set(struct mlxsw_sp *mlxsw_sp,
5746 struct fib_entry_notifier_info *fen_info)
5748 u32 *p_dst = (u32 *) &fen_info->dst;
5749 struct fib_rt_info fri;
5751 fri.fi = fen_info->fi;
5752 fri.tb_id = fen_info->tb_id;
5753 fri.dst = cpu_to_be32(*p_dst);
5754 fri.dst_len = fen_info->dst_len;
5755 fri.dscp = fen_info->dscp;
5756 fri.type = fen_info->type;
5757 fri.offload = false;
5759 fri.offload_failed = true;
5760 fib_alias_hw_flags_set(mlxsw_sp_net(mlxsw_sp), &fri);
5764 mlxsw_sp_fib4_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5765 struct mlxsw_sp_fib_entry *fib_entry)
5767 u32 *p_dst = (u32 *) fib_entry->fib_node->key.addr;
5768 int dst_len = fib_entry->fib_node->key.prefix_len;
5769 struct mlxsw_sp_fib4_entry *fib4_entry;
5770 struct fib_rt_info fri;
5771 bool should_offload;
5773 should_offload = mlxsw_sp_fib_entry_should_offload(fib_entry);
5774 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
5776 fri.fi = fib4_entry->fi;
5777 fri.tb_id = fib4_entry->tb_id;
5778 fri.dst = cpu_to_be32(*p_dst);
5779 fri.dst_len = dst_len;
5780 fri.dscp = fib4_entry->dscp;
5781 fri.type = fib4_entry->type;
5782 fri.offload = should_offload;
5783 fri.trap = !should_offload;
5784 fri.offload_failed = false;
5785 fib_alias_hw_flags_set(mlxsw_sp_net(mlxsw_sp), &fri);
5789 mlxsw_sp_fib4_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5790 struct mlxsw_sp_fib_entry *fib_entry)
5792 u32 *p_dst = (u32 *) fib_entry->fib_node->key.addr;
5793 int dst_len = fib_entry->fib_node->key.prefix_len;
5794 struct mlxsw_sp_fib4_entry *fib4_entry;
5795 struct fib_rt_info fri;
5797 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
5799 fri.fi = fib4_entry->fi;
5800 fri.tb_id = fib4_entry->tb_id;
5801 fri.dst = cpu_to_be32(*p_dst);
5802 fri.dst_len = dst_len;
5803 fri.dscp = fib4_entry->dscp;
5804 fri.type = fib4_entry->type;
5805 fri.offload = false;
5807 fri.offload_failed = false;
5808 fib_alias_hw_flags_set(mlxsw_sp_net(mlxsw_sp), &fri);
5811 #if IS_ENABLED(CONFIG_IPV6)
5813 mlxsw_sp_fib6_offload_failed_flag_set(struct mlxsw_sp *mlxsw_sp,
5814 struct fib6_info **rt_arr,
5819 /* In IPv6 a multipath route is represented using multiple routes, so
5820 * we need to set the flags on all of them.
5822 for (i = 0; i < nrt6; i++)
5823 fib6_info_hw_flags_set(mlxsw_sp_net(mlxsw_sp), rt_arr[i],
5824 false, false, true);
5828 mlxsw_sp_fib6_offload_failed_flag_set(struct mlxsw_sp *mlxsw_sp,
5829 struct fib6_info **rt_arr,
5835 #if IS_ENABLED(CONFIG_IPV6)
5837 mlxsw_sp_fib6_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5838 struct mlxsw_sp_fib_entry *fib_entry)
5840 struct mlxsw_sp_fib6_entry *fib6_entry;
5841 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5842 bool should_offload;
5844 should_offload = mlxsw_sp_fib_entry_should_offload(fib_entry);
5846 /* In IPv6 a multipath route is represented using multiple routes, so
5847 * we need to set the flags on all of them.
5849 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
5851 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list)
5852 fib6_info_hw_flags_set(mlxsw_sp_net(mlxsw_sp), mlxsw_sp_rt6->rt,
5853 should_offload, !should_offload, false);
5857 mlxsw_sp_fib6_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5858 struct mlxsw_sp_fib_entry *fib_entry)
5863 #if IS_ENABLED(CONFIG_IPV6)
5865 mlxsw_sp_fib6_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5866 struct mlxsw_sp_fib_entry *fib_entry)
5868 struct mlxsw_sp_fib6_entry *fib6_entry;
5869 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5871 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
5873 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list)
5874 fib6_info_hw_flags_set(mlxsw_sp_net(mlxsw_sp), mlxsw_sp_rt6->rt,
5875 false, false, false);
5879 mlxsw_sp_fib6_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5880 struct mlxsw_sp_fib_entry *fib_entry)
5886 mlxsw_sp_fib_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5887 struct mlxsw_sp_fib_entry *fib_entry)
5889 switch (fib_entry->fib_node->fib->proto) {
5890 case MLXSW_SP_L3_PROTO_IPV4:
5891 mlxsw_sp_fib4_entry_hw_flags_set(mlxsw_sp, fib_entry);
5893 case MLXSW_SP_L3_PROTO_IPV6:
5894 mlxsw_sp_fib6_entry_hw_flags_set(mlxsw_sp, fib_entry);
5900 mlxsw_sp_fib_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5901 struct mlxsw_sp_fib_entry *fib_entry)
5903 switch (fib_entry->fib_node->fib->proto) {
5904 case MLXSW_SP_L3_PROTO_IPV4:
5905 mlxsw_sp_fib4_entry_hw_flags_clear(mlxsw_sp, fib_entry);
5907 case MLXSW_SP_L3_PROTO_IPV6:
5908 mlxsw_sp_fib6_entry_hw_flags_clear(mlxsw_sp, fib_entry);
5914 mlxsw_sp_fib_entry_hw_flags_refresh(struct mlxsw_sp *mlxsw_sp,
5915 struct mlxsw_sp_fib_entry *fib_entry,
5916 enum mlxsw_reg_ralue_op op)
5919 case MLXSW_REG_RALUE_OP_WRITE_WRITE:
5920 mlxsw_sp_fib_entry_hw_flags_set(mlxsw_sp, fib_entry);
5922 case MLXSW_REG_RALUE_OP_WRITE_DELETE:
5923 mlxsw_sp_fib_entry_hw_flags_clear(mlxsw_sp, fib_entry);
5931 mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
5932 const struct mlxsw_sp_fib_entry *fib_entry,
5933 enum mlxsw_reg_ralue_op op)
5935 struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
5936 enum mlxsw_reg_ralxx_protocol proto;
5939 proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
5941 switch (fib->proto) {
5942 case MLXSW_SP_L3_PROTO_IPV4:
5943 p_dip = (u32 *) fib_entry->fib_node->key.addr;
5944 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
5945 fib_entry->fib_node->key.prefix_len,
5948 case MLXSW_SP_L3_PROTO_IPV6:
5949 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
5950 fib_entry->fib_node->key.prefix_len,
5951 fib_entry->fib_node->key.addr);
5956 static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
5957 struct mlxsw_sp_fib_entry *fib_entry,
5958 enum mlxsw_reg_ralue_op op)
5960 struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
5961 struct mlxsw_sp_nexthop_group_info *nhgi = nh_group->nhgi;
5962 char ralue_pl[MLXSW_REG_RALUE_LEN];
5963 enum mlxsw_reg_ralue_trap_action trap_action;
5965 u32 adjacency_index = 0;
5968 /* In case the nexthop group adjacency index is valid, use it
5969 * with provided ECMP size. Otherwise, setup trap and pass
5970 * traffic to kernel.
5972 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
5973 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
5974 adjacency_index = nhgi->adj_index;
5975 ecmp_size = nhgi->ecmp_size;
5976 } else if (!nhgi->adj_index_valid && nhgi->count &&
5977 mlxsw_sp_nhgi_rif(nhgi)) {
5978 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
5979 adjacency_index = mlxsw_sp->router->adj_trap_index;
5982 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
5983 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
5986 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5987 mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
5988 adjacency_index, ecmp_size);
5989 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5992 static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
5993 struct mlxsw_sp_fib_entry *fib_entry,
5994 enum mlxsw_reg_ralue_op op)
5996 struct mlxsw_sp_rif *rif = mlxsw_sp_nhgi_rif(fib_entry->nh_group->nhgi);
5997 enum mlxsw_reg_ralue_trap_action trap_action;
5998 char ralue_pl[MLXSW_REG_RALUE_LEN];
6002 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
6003 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
6004 rif_index = rif->rif_index;
6006 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
6007 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
6010 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
6011 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
6013 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
6016 static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
6017 struct mlxsw_sp_fib_entry *fib_entry,
6018 enum mlxsw_reg_ralue_op op)
6020 char ralue_pl[MLXSW_REG_RALUE_LEN];
6022 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
6023 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
6024 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
6027 static int mlxsw_sp_fib_entry_op_blackhole(struct mlxsw_sp *mlxsw_sp,
6028 struct mlxsw_sp_fib_entry *fib_entry,
6029 enum mlxsw_reg_ralue_op op)
6031 enum mlxsw_reg_ralue_trap_action trap_action;
6032 char ralue_pl[MLXSW_REG_RALUE_LEN];
6034 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_DISCARD_ERROR;
6035 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
6036 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, 0, 0);
6037 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
6041 mlxsw_sp_fib_entry_op_unreachable(struct mlxsw_sp *mlxsw_sp,
6042 struct mlxsw_sp_fib_entry *fib_entry,
6043 enum mlxsw_reg_ralue_op op)
6045 enum mlxsw_reg_ralue_trap_action trap_action;
6046 char ralue_pl[MLXSW_REG_RALUE_LEN];
6049 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
6050 trap_id = MLXSW_TRAP_ID_RTR_INGRESS1;
6052 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
6053 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id, 0);
6054 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
6058 mlxsw_sp_fib_entry_op_ipip_decap(struct mlxsw_sp *mlxsw_sp,
6059 struct mlxsw_sp_fib_entry *fib_entry,
6060 enum mlxsw_reg_ralue_op op)
6062 struct mlxsw_sp_ipip_entry *ipip_entry = fib_entry->decap.ipip_entry;
6063 const struct mlxsw_sp_ipip_ops *ipip_ops;
6064 char ralue_pl[MLXSW_REG_RALUE_LEN];
6067 if (WARN_ON(!ipip_entry))
6070 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
6071 err = ipip_ops->decap_config(mlxsw_sp, ipip_entry,
6072 fib_entry->decap.tunnel_index);
6076 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
6077 mlxsw_reg_ralue_act_ip2me_tun_pack(ralue_pl,
6078 fib_entry->decap.tunnel_index);
6079 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
6082 static int mlxsw_sp_fib_entry_op_nve_decap(struct mlxsw_sp *mlxsw_sp,
6083 struct mlxsw_sp_fib_entry *fib_entry,
6084 enum mlxsw_reg_ralue_op op)
6086 char ralue_pl[MLXSW_REG_RALUE_LEN];
6088 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
6089 mlxsw_reg_ralue_act_ip2me_tun_pack(ralue_pl,
6090 fib_entry->decap.tunnel_index);
6091 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
6094 static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
6095 struct mlxsw_sp_fib_entry *fib_entry,
6096 enum mlxsw_reg_ralue_op op)
6098 switch (fib_entry->type) {
6099 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
6100 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
6101 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
6102 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
6103 case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
6104 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
6105 case MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE:
6106 return mlxsw_sp_fib_entry_op_blackhole(mlxsw_sp, fib_entry, op);
6107 case MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE:
6108 return mlxsw_sp_fib_entry_op_unreachable(mlxsw_sp, fib_entry,
6110 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
6111 return mlxsw_sp_fib_entry_op_ipip_decap(mlxsw_sp,
6113 case MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP:
6114 return mlxsw_sp_fib_entry_op_nve_decap(mlxsw_sp, fib_entry, op);
6119 static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
6120 struct mlxsw_sp_fib_entry *fib_entry,
6121 enum mlxsw_reg_ralue_op op)
6123 int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
6128 mlxsw_sp_fib_entry_hw_flags_refresh(mlxsw_sp, fib_entry, op);
6133 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
6134 struct mlxsw_sp_fib_entry *fib_entry)
6136 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
6137 MLXSW_REG_RALUE_OP_WRITE_WRITE);
6140 static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
6141 struct mlxsw_sp_fib_entry *fib_entry)
6143 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
6144 MLXSW_REG_RALUE_OP_WRITE_DELETE);
6148 mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
6149 const struct fib_entry_notifier_info *fen_info,
6150 struct mlxsw_sp_fib_entry *fib_entry)
6152 struct mlxsw_sp_nexthop_group_info *nhgi = fib_entry->nh_group->nhgi;
6153 union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };
6154 struct mlxsw_sp_router *router = mlxsw_sp->router;
6155 u32 tb_id = mlxsw_sp_fix_tb_id(fen_info->tb_id);
6156 int ifindex = nhgi->nexthops[0].ifindex;
6157 struct mlxsw_sp_ipip_entry *ipip_entry;
6159 switch (fen_info->type) {
6161 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, ifindex,
6162 MLXSW_SP_L3_PROTO_IPV4, dip);
6163 if (ipip_entry && ipip_entry->ol_dev->flags & IFF_UP) {
6164 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
6165 return mlxsw_sp_fib_entry_decap_init(mlxsw_sp,
6169 if (mlxsw_sp_router_nve_is_decap(mlxsw_sp, tb_id,
6170 MLXSW_SP_L3_PROTO_IPV4,
6174 tunnel_index = router->nve_decap_config.tunnel_index;
6175 fib_entry->decap.tunnel_index = tunnel_index;
6176 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
6181 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
6184 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE;
6186 case RTN_UNREACHABLE:
6188 /* Packets hitting these routes need to be trapped, but
6189 * can do so with a lower priority than packets directed
6190 * at the host, so use action type local instead of trap.
6192 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE;
6196 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
6198 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
6206 mlxsw_sp_fib_entry_type_unset(struct mlxsw_sp *mlxsw_sp,
6207 struct mlxsw_sp_fib_entry *fib_entry)
6209 switch (fib_entry->type) {
6210 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
6211 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
6219 mlxsw_sp_fib4_entry_type_unset(struct mlxsw_sp *mlxsw_sp,
6220 struct mlxsw_sp_fib4_entry *fib4_entry)
6222 mlxsw_sp_fib_entry_type_unset(mlxsw_sp, &fib4_entry->common);
6225 static struct mlxsw_sp_fib4_entry *
6226 mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
6227 struct mlxsw_sp_fib_node *fib_node,
6228 const struct fib_entry_notifier_info *fen_info)
6230 struct mlxsw_sp_fib4_entry *fib4_entry;
6231 struct mlxsw_sp_fib_entry *fib_entry;
6234 fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
6236 return ERR_PTR(-ENOMEM);
6237 fib_entry = &fib4_entry->common;
6239 err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
6241 goto err_nexthop4_group_get;
6243 err = mlxsw_sp_nexthop_group_vr_link(fib_entry->nh_group,
6246 goto err_nexthop_group_vr_link;
6248 err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
6250 goto err_fib4_entry_type_set;
6252 fib4_entry->fi = fen_info->fi;
6253 fib_info_hold(fib4_entry->fi);
6254 fib4_entry->tb_id = fen_info->tb_id;
6255 fib4_entry->type = fen_info->type;
6256 fib4_entry->dscp = fen_info->dscp;
6258 fib_entry->fib_node = fib_node;
6262 err_fib4_entry_type_set:
6263 mlxsw_sp_nexthop_group_vr_unlink(fib_entry->nh_group, fib_node->fib);
6264 err_nexthop_group_vr_link:
6265 mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
6266 err_nexthop4_group_get:
6268 return ERR_PTR(err);
6271 static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
6272 struct mlxsw_sp_fib4_entry *fib4_entry)
6274 struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
6276 fib_info_put(fib4_entry->fi);
6277 mlxsw_sp_fib4_entry_type_unset(mlxsw_sp, fib4_entry);
6278 mlxsw_sp_nexthop_group_vr_unlink(fib4_entry->common.nh_group,
6280 mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
6284 static struct mlxsw_sp_fib4_entry *
6285 mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
6286 const struct fib_entry_notifier_info *fen_info)
6288 struct mlxsw_sp_fib4_entry *fib4_entry;
6289 struct mlxsw_sp_fib_node *fib_node;
6290 struct mlxsw_sp_fib *fib;
6291 struct mlxsw_sp_vr *vr;
6293 vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
6296 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
6298 fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
6299 sizeof(fen_info->dst),
6304 fib4_entry = container_of(fib_node->fib_entry,
6305 struct mlxsw_sp_fib4_entry, common);
6306 if (fib4_entry->tb_id == fen_info->tb_id &&
6307 fib4_entry->dscp == fen_info->dscp &&
6308 fib4_entry->type == fen_info->type &&
6309 fib4_entry->fi == fen_info->fi)
6315 static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
6316 .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
6317 .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
6318 .key_len = sizeof(struct mlxsw_sp_fib_key),
6319 .automatic_shrinking = true,
6322 static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
6323 struct mlxsw_sp_fib_node *fib_node)
6325 return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
6326 mlxsw_sp_fib_ht_params);
6329 static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
6330 struct mlxsw_sp_fib_node *fib_node)
6332 rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
6333 mlxsw_sp_fib_ht_params);
6336 static struct mlxsw_sp_fib_node *
6337 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
6338 size_t addr_len, unsigned char prefix_len)
6340 struct mlxsw_sp_fib_key key;
6342 memset(&key, 0, sizeof(key));
6343 memcpy(key.addr, addr, addr_len);
6344 key.prefix_len = prefix_len;
6345 return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
6348 static struct mlxsw_sp_fib_node *
6349 mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
6350 size_t addr_len, unsigned char prefix_len)
6352 struct mlxsw_sp_fib_node *fib_node;
6354 fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
6358 list_add(&fib_node->list, &fib->node_list);
6359 memcpy(fib_node->key.addr, addr, addr_len);
6360 fib_node->key.prefix_len = prefix_len;
6365 static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
6367 list_del(&fib_node->list);
6371 static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp,
6372 struct mlxsw_sp_fib_node *fib_node)
6374 struct mlxsw_sp_prefix_usage req_prefix_usage;
6375 struct mlxsw_sp_fib *fib = fib_node->fib;
6376 struct mlxsw_sp_lpm_tree *lpm_tree;
6379 lpm_tree = mlxsw_sp->router->lpm.proto_trees[fib->proto];
6380 if (lpm_tree->prefix_ref_count[fib_node->key.prefix_len] != 0)
6383 mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &lpm_tree->prefix_usage);
6384 mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
6385 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
6387 if (IS_ERR(lpm_tree))
6388 return PTR_ERR(lpm_tree);
6390 err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
6392 goto err_lpm_tree_replace;
6395 lpm_tree->prefix_ref_count[fib_node->key.prefix_len]++;
6398 err_lpm_tree_replace:
6399 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
6403 static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
6404 struct mlxsw_sp_fib_node *fib_node)
6406 struct mlxsw_sp_lpm_tree *lpm_tree = fib_node->fib->lpm_tree;
6407 struct mlxsw_sp_prefix_usage req_prefix_usage;
6408 struct mlxsw_sp_fib *fib = fib_node->fib;
6411 if (--lpm_tree->prefix_ref_count[fib_node->key.prefix_len] != 0)
6413 /* Try to construct a new LPM tree from the current prefix usage
6414 * minus the unused one. If we fail, continue using the old one.
6416 mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &lpm_tree->prefix_usage);
6417 mlxsw_sp_prefix_usage_clear(&req_prefix_usage,
6418 fib_node->key.prefix_len);
6419 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
6421 if (IS_ERR(lpm_tree))
6424 err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
6426 goto err_lpm_tree_replace;
6430 err_lpm_tree_replace:
6431 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
6434 static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
6435 struct mlxsw_sp_fib_node *fib_node,
6436 struct mlxsw_sp_fib *fib)
6440 err = mlxsw_sp_fib_node_insert(fib, fib_node);
6443 fib_node->fib = fib;
6445 err = mlxsw_sp_fib_lpm_tree_link(mlxsw_sp, fib_node);
6447 goto err_fib_lpm_tree_link;
6451 err_fib_lpm_tree_link:
6452 fib_node->fib = NULL;
6453 mlxsw_sp_fib_node_remove(fib, fib_node);
6457 static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
6458 struct mlxsw_sp_fib_node *fib_node)
6460 struct mlxsw_sp_fib *fib = fib_node->fib;
6462 mlxsw_sp_fib_lpm_tree_unlink(mlxsw_sp, fib_node);
6463 fib_node->fib = NULL;
6464 mlxsw_sp_fib_node_remove(fib, fib_node);
6467 static struct mlxsw_sp_fib_node *
6468 mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
6469 size_t addr_len, unsigned char prefix_len,
6470 enum mlxsw_sp_l3proto proto)
6472 struct mlxsw_sp_fib_node *fib_node;
6473 struct mlxsw_sp_fib *fib;
6474 struct mlxsw_sp_vr *vr;
6477 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id, NULL);
6479 return ERR_CAST(vr);
6480 fib = mlxsw_sp_vr_fib(vr, proto);
6482 fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
6486 fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
6489 goto err_fib_node_create;
6492 err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
6494 goto err_fib_node_init;
6499 mlxsw_sp_fib_node_destroy(fib_node);
6500 err_fib_node_create:
6501 mlxsw_sp_vr_put(mlxsw_sp, vr);
6502 return ERR_PTR(err);
6505 static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
6506 struct mlxsw_sp_fib_node *fib_node)
6508 struct mlxsw_sp_vr *vr = fib_node->fib->vr;
6510 if (fib_node->fib_entry)
6512 mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
6513 mlxsw_sp_fib_node_destroy(fib_node);
6514 mlxsw_sp_vr_put(mlxsw_sp, vr);
6517 static int mlxsw_sp_fib_node_entry_link(struct mlxsw_sp *mlxsw_sp,
6518 struct mlxsw_sp_fib_entry *fib_entry)
6520 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
6523 fib_node->fib_entry = fib_entry;
6525 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
6527 goto err_fib_entry_update;
6531 err_fib_entry_update:
6532 fib_node->fib_entry = NULL;
6537 mlxsw_sp_fib_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
6538 struct mlxsw_sp_fib_entry *fib_entry)
6540 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
6542 mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
6543 fib_node->fib_entry = NULL;
6546 static bool mlxsw_sp_fib4_allow_replace(struct mlxsw_sp_fib4_entry *fib4_entry)
6548 struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
6549 struct mlxsw_sp_fib4_entry *fib4_replaced;
6551 if (!fib_node->fib_entry)
6554 fib4_replaced = container_of(fib_node->fib_entry,
6555 struct mlxsw_sp_fib4_entry, common);
6556 if (fib4_entry->tb_id == RT_TABLE_MAIN &&
6557 fib4_replaced->tb_id == RT_TABLE_LOCAL)
6564 mlxsw_sp_router_fib4_replace(struct mlxsw_sp *mlxsw_sp,
6565 const struct fib_entry_notifier_info *fen_info)
6567 struct mlxsw_sp_fib4_entry *fib4_entry, *fib4_replaced;
6568 struct mlxsw_sp_fib_entry *replaced;
6569 struct mlxsw_sp_fib_node *fib_node;
6572 if (fen_info->fi->nh &&
6573 !mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, fen_info->fi->nh->id))
6576 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
6577 &fen_info->dst, sizeof(fen_info->dst),
6579 MLXSW_SP_L3_PROTO_IPV4);
6580 if (IS_ERR(fib_node)) {
6581 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
6582 return PTR_ERR(fib_node);
6585 fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
6586 if (IS_ERR(fib4_entry)) {
6587 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
6588 err = PTR_ERR(fib4_entry);
6589 goto err_fib4_entry_create;
6592 if (!mlxsw_sp_fib4_allow_replace(fib4_entry)) {
6593 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
6594 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
6598 replaced = fib_node->fib_entry;
6599 err = mlxsw_sp_fib_node_entry_link(mlxsw_sp, &fib4_entry->common);
6601 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
6602 goto err_fib_node_entry_link;
6605 /* Nothing to replace */
6609 mlxsw_sp_fib_entry_hw_flags_clear(mlxsw_sp, replaced);
6610 fib4_replaced = container_of(replaced, struct mlxsw_sp_fib4_entry,
6612 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_replaced);
6616 err_fib_node_entry_link:
6617 fib_node->fib_entry = replaced;
6618 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
6619 err_fib4_entry_create:
6620 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
6624 static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
6625 struct fib_entry_notifier_info *fen_info)
6627 struct mlxsw_sp_fib4_entry *fib4_entry;
6628 struct mlxsw_sp_fib_node *fib_node;
6630 fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
6633 fib_node = fib4_entry->common.fib_node;
6635 mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, &fib4_entry->common);
6636 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
6637 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
6640 static bool mlxsw_sp_fib6_rt_should_ignore(const struct fib6_info *rt)
6642 /* Multicast routes aren't supported, so ignore them. Neighbour
6643 * Discovery packets are specifically trapped.
6645 if (ipv6_addr_type(&rt->fib6_dst.addr) & IPV6_ADDR_MULTICAST)
6648 /* Cloned routes are irrelevant in the forwarding path. */
6649 if (rt->fib6_flags & RTF_CACHE)
6655 static struct mlxsw_sp_rt6 *mlxsw_sp_rt6_create(struct fib6_info *rt)
6657 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6659 mlxsw_sp_rt6 = kzalloc(sizeof(*mlxsw_sp_rt6), GFP_KERNEL);
6661 return ERR_PTR(-ENOMEM);
6663 /* In case of route replace, replaced route is deleted with
6664 * no notification. Take reference to prevent accessing freed
6667 mlxsw_sp_rt6->rt = rt;
6670 return mlxsw_sp_rt6;
6673 #if IS_ENABLED(CONFIG_IPV6)
6674 static void mlxsw_sp_rt6_release(struct fib6_info *rt)
6676 fib6_info_release(rt);
6679 static void mlxsw_sp_rt6_release(struct fib6_info *rt)
6684 static void mlxsw_sp_rt6_destroy(struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
6686 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
6688 if (!mlxsw_sp_rt6->rt->nh)
6689 fib6_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
6690 mlxsw_sp_rt6_release(mlxsw_sp_rt6->rt);
6691 kfree(mlxsw_sp_rt6);
6694 static struct fib6_info *
6695 mlxsw_sp_fib6_entry_rt(const struct mlxsw_sp_fib6_entry *fib6_entry)
6697 return list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
6701 static struct mlxsw_sp_rt6 *
6702 mlxsw_sp_fib6_entry_rt_find(const struct mlxsw_sp_fib6_entry *fib6_entry,
6703 const struct fib6_info *rt)
6705 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6707 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
6708 if (mlxsw_sp_rt6->rt == rt)
6709 return mlxsw_sp_rt6;
6715 static bool mlxsw_sp_nexthop6_ipip_type(const struct mlxsw_sp *mlxsw_sp,
6716 const struct fib6_info *rt,
6717 enum mlxsw_sp_ipip_type *ret)
6719 return rt->fib6_nh->fib_nh_dev &&
6720 mlxsw_sp_netdev_ipip_type(mlxsw_sp, rt->fib6_nh->fib_nh_dev, ret);
6723 static int mlxsw_sp_nexthop6_init(struct mlxsw_sp *mlxsw_sp,
6724 struct mlxsw_sp_nexthop_group *nh_grp,
6725 struct mlxsw_sp_nexthop *nh,
6726 const struct fib6_info *rt)
6728 struct net_device *dev = rt->fib6_nh->fib_nh_dev;
6731 nh->nhgi = nh_grp->nhgi;
6732 nh->nh_weight = rt->fib6_nh->fib_nh_weight;
6733 memcpy(&nh->gw_addr, &rt->fib6_nh->fib_nh_gw6, sizeof(nh->gw_addr));
6734 #if IS_ENABLED(CONFIG_IPV6)
6735 nh->neigh_tbl = &nd_tbl;
6737 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
6739 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
6743 nh->ifindex = dev->ifindex;
6745 err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
6747 goto err_nexthop_type_init;
6751 err_nexthop_type_init:
6752 list_del(&nh->router_list_node);
6753 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
6757 static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,
6758 struct mlxsw_sp_nexthop *nh)
6760 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
6761 list_del(&nh->router_list_node);
6762 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
6765 static bool mlxsw_sp_rt6_is_gateway(const struct mlxsw_sp *mlxsw_sp,
6766 const struct fib6_info *rt)
6768 return rt->fib6_nh->fib_nh_gw_family ||
6769 mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, NULL);
6773 mlxsw_sp_nexthop6_group_info_init(struct mlxsw_sp *mlxsw_sp,
6774 struct mlxsw_sp_nexthop_group *nh_grp,
6775 struct mlxsw_sp_fib6_entry *fib6_entry)
6777 struct mlxsw_sp_nexthop_group_info *nhgi;
6778 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6779 struct mlxsw_sp_nexthop *nh;
6782 nhgi = kzalloc(struct_size(nhgi, nexthops, fib6_entry->nrt6),
6786 nh_grp->nhgi = nhgi;
6787 nhgi->nh_grp = nh_grp;
6788 mlxsw_sp_rt6 = list_first_entry(&fib6_entry->rt6_list,
6789 struct mlxsw_sp_rt6, list);
6790 nhgi->gateway = mlxsw_sp_rt6_is_gateway(mlxsw_sp, mlxsw_sp_rt6->rt);
6791 nhgi->count = fib6_entry->nrt6;
6792 for (i = 0; i < nhgi->count; i++) {
6793 struct fib6_info *rt = mlxsw_sp_rt6->rt;
6795 nh = &nhgi->nexthops[i];
6796 err = mlxsw_sp_nexthop6_init(mlxsw_sp, nh_grp, nh, rt);
6798 goto err_nexthop6_init;
6799 mlxsw_sp_rt6 = list_next_entry(mlxsw_sp_rt6, list);
6801 nh_grp->nhgi = nhgi;
6802 err = mlxsw_sp_nexthop_group_inc(mlxsw_sp);
6805 err = mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
6807 goto err_group_refresh;
6812 mlxsw_sp_nexthop_group_dec(mlxsw_sp);
6816 for (i--; i >= 0; i--) {
6817 nh = &nhgi->nexthops[i];
6818 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
6825 mlxsw_sp_nexthop6_group_info_fini(struct mlxsw_sp *mlxsw_sp,
6826 struct mlxsw_sp_nexthop_group *nh_grp)
6828 struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
6831 mlxsw_sp_nexthop_group_dec(mlxsw_sp);
6832 for (i = nhgi->count - 1; i >= 0; i--) {
6833 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
6835 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
6837 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
6838 WARN_ON_ONCE(nhgi->adj_index_valid);
6842 static struct mlxsw_sp_nexthop_group *
6843 mlxsw_sp_nexthop6_group_create(struct mlxsw_sp *mlxsw_sp,
6844 struct mlxsw_sp_fib6_entry *fib6_entry)
6846 struct mlxsw_sp_nexthop_group *nh_grp;
6849 nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
6851 return ERR_PTR(-ENOMEM);
6852 INIT_LIST_HEAD(&nh_grp->vr_list);
6853 err = rhashtable_init(&nh_grp->vr_ht,
6854 &mlxsw_sp_nexthop_group_vr_ht_params);
6856 goto err_nexthop_group_vr_ht_init;
6857 INIT_LIST_HEAD(&nh_grp->fib_list);
6858 nh_grp->type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6;
6860 err = mlxsw_sp_nexthop6_group_info_init(mlxsw_sp, nh_grp, fib6_entry);
6862 goto err_nexthop_group_info_init;
6864 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
6866 goto err_nexthop_group_insert;
6868 nh_grp->can_destroy = true;
6872 err_nexthop_group_insert:
6873 mlxsw_sp_nexthop6_group_info_fini(mlxsw_sp, nh_grp);
6874 err_nexthop_group_info_init:
6875 rhashtable_destroy(&nh_grp->vr_ht);
6876 err_nexthop_group_vr_ht_init:
6878 return ERR_PTR(err);
6882 mlxsw_sp_nexthop6_group_destroy(struct mlxsw_sp *mlxsw_sp,
6883 struct mlxsw_sp_nexthop_group *nh_grp)
6885 if (!nh_grp->can_destroy)
6887 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
6888 mlxsw_sp_nexthop6_group_info_fini(mlxsw_sp, nh_grp);
6889 WARN_ON_ONCE(!list_empty(&nh_grp->vr_list));
6890 rhashtable_destroy(&nh_grp->vr_ht);
6894 static int mlxsw_sp_nexthop6_group_get(struct mlxsw_sp *mlxsw_sp,
6895 struct mlxsw_sp_fib6_entry *fib6_entry)
6897 struct fib6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
6898 struct mlxsw_sp_nexthop_group *nh_grp;
6901 nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp,
6903 if (WARN_ON_ONCE(!nh_grp))
6908 nh_grp = mlxsw_sp_nexthop6_group_lookup(mlxsw_sp, fib6_entry);
6910 nh_grp = mlxsw_sp_nexthop6_group_create(mlxsw_sp, fib6_entry);
6912 return PTR_ERR(nh_grp);
6915 /* The route and the nexthop are described by the same struct, so we
6916 * need to the update the nexthop offload indication for the new route.
6918 __mlxsw_sp_nexthop6_group_offload_refresh(nh_grp, fib6_entry);
6921 list_add_tail(&fib6_entry->common.nexthop_group_node,
6923 fib6_entry->common.nh_group = nh_grp;
6928 static void mlxsw_sp_nexthop6_group_put(struct mlxsw_sp *mlxsw_sp,
6929 struct mlxsw_sp_fib_entry *fib_entry)
6931 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
6933 list_del(&fib_entry->nexthop_group_node);
6934 if (!list_empty(&nh_grp->fib_list))
6937 if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ) {
6938 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
6942 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, nh_grp);
6946 mlxsw_sp_nexthop6_group_update(struct mlxsw_sp *mlxsw_sp,
6947 struct mlxsw_sp_fib6_entry *fib6_entry)
6949 struct mlxsw_sp_nexthop_group *old_nh_grp = fib6_entry->common.nh_group;
6950 struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
6953 mlxsw_sp_nexthop_group_vr_unlink(old_nh_grp, fib_node->fib);
6954 fib6_entry->common.nh_group = NULL;
6955 list_del(&fib6_entry->common.nexthop_group_node);
6957 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
6959 goto err_nexthop6_group_get;
6961 err = mlxsw_sp_nexthop_group_vr_link(fib6_entry->common.nh_group,
6964 goto err_nexthop_group_vr_link;
6966 /* In case this entry is offloaded, then the adjacency index
6967 * currently associated with it in the device's table is that
6968 * of the old group. Start using the new one instead.
6970 err = mlxsw_sp_fib_entry_update(mlxsw_sp, &fib6_entry->common);
6972 goto err_fib_entry_update;
6974 if (list_empty(&old_nh_grp->fib_list))
6975 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, old_nh_grp);
6979 err_fib_entry_update:
6980 mlxsw_sp_nexthop_group_vr_unlink(fib6_entry->common.nh_group,
6982 err_nexthop_group_vr_link:
6983 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
6984 err_nexthop6_group_get:
6985 list_add_tail(&fib6_entry->common.nexthop_group_node,
6986 &old_nh_grp->fib_list);
6987 fib6_entry->common.nh_group = old_nh_grp;
6988 mlxsw_sp_nexthop_group_vr_link(old_nh_grp, fib_node->fib);
6993 mlxsw_sp_fib6_entry_nexthop_add(struct mlxsw_sp *mlxsw_sp,
6994 struct mlxsw_sp_fib6_entry *fib6_entry,
6995 struct fib6_info **rt_arr, unsigned int nrt6)
6997 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
7000 for (i = 0; i < nrt6; i++) {
7001 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt_arr[i]);
7002 if (IS_ERR(mlxsw_sp_rt6)) {
7003 err = PTR_ERR(mlxsw_sp_rt6);
7004 goto err_rt6_unwind;
7007 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
7011 err = mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
7013 goto err_rt6_unwind;
7018 for (; i > 0; i--) {
7020 mlxsw_sp_rt6 = list_last_entry(&fib6_entry->rt6_list,
7021 struct mlxsw_sp_rt6, list);
7022 list_del(&mlxsw_sp_rt6->list);
7023 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
7029 mlxsw_sp_fib6_entry_nexthop_del(struct mlxsw_sp *mlxsw_sp,
7030 struct mlxsw_sp_fib6_entry *fib6_entry,
7031 struct fib6_info **rt_arr, unsigned int nrt6)
7033 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
7036 for (i = 0; i < nrt6; i++) {
7037 mlxsw_sp_rt6 = mlxsw_sp_fib6_entry_rt_find(fib6_entry,
7039 if (WARN_ON_ONCE(!mlxsw_sp_rt6))
7043 list_del(&mlxsw_sp_rt6->list);
7044 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
7047 mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
7051 mlxsw_sp_fib6_entry_type_set_local(struct mlxsw_sp *mlxsw_sp,
7052 struct mlxsw_sp_fib_entry *fib_entry,
7053 const struct fib6_info *rt)
7055 struct mlxsw_sp_nexthop_group_info *nhgi = fib_entry->nh_group->nhgi;
7056 union mlxsw_sp_l3addr dip = { .addr6 = rt->fib6_dst.addr };
7057 u32 tb_id = mlxsw_sp_fix_tb_id(rt->fib6_table->tb6_id);
7058 struct mlxsw_sp_router *router = mlxsw_sp->router;
7059 int ifindex = nhgi->nexthops[0].ifindex;
7060 struct mlxsw_sp_ipip_entry *ipip_entry;
7062 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
7063 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, ifindex,
7064 MLXSW_SP_L3_PROTO_IPV6,
7067 if (ipip_entry && ipip_entry->ol_dev->flags & IFF_UP) {
7068 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
7069 return mlxsw_sp_fib_entry_decap_init(mlxsw_sp, fib_entry,
7072 if (mlxsw_sp_router_nve_is_decap(mlxsw_sp, tb_id,
7073 MLXSW_SP_L3_PROTO_IPV6, &dip)) {
7076 tunnel_index = router->nve_decap_config.tunnel_index;
7077 fib_entry->decap.tunnel_index = tunnel_index;
7078 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
7084 static int mlxsw_sp_fib6_entry_type_set(struct mlxsw_sp *mlxsw_sp,
7085 struct mlxsw_sp_fib_entry *fib_entry,
7086 const struct fib6_info *rt)
7088 if (rt->fib6_flags & RTF_LOCAL)
7089 return mlxsw_sp_fib6_entry_type_set_local(mlxsw_sp, fib_entry,
7091 if (rt->fib6_flags & RTF_ANYCAST)
7092 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
7093 else if (rt->fib6_type == RTN_BLACKHOLE)
7094 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE;
7095 else if (rt->fib6_flags & RTF_REJECT)
7096 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE;
7097 else if (fib_entry->nh_group->nhgi->gateway)
7098 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
7100 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
7106 mlxsw_sp_fib6_entry_rt_destroy_all(struct mlxsw_sp_fib6_entry *fib6_entry)
7108 struct mlxsw_sp_rt6 *mlxsw_sp_rt6, *tmp;
7110 list_for_each_entry_safe(mlxsw_sp_rt6, tmp, &fib6_entry->rt6_list,
7113 list_del(&mlxsw_sp_rt6->list);
7114 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
7118 static struct mlxsw_sp_fib6_entry *
7119 mlxsw_sp_fib6_entry_create(struct mlxsw_sp *mlxsw_sp,
7120 struct mlxsw_sp_fib_node *fib_node,
7121 struct fib6_info **rt_arr, unsigned int nrt6)
7123 struct mlxsw_sp_fib6_entry *fib6_entry;
7124 struct mlxsw_sp_fib_entry *fib_entry;
7125 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
7128 fib6_entry = kzalloc(sizeof(*fib6_entry), GFP_KERNEL);
7130 return ERR_PTR(-ENOMEM);
7131 fib_entry = &fib6_entry->common;
7133 INIT_LIST_HEAD(&fib6_entry->rt6_list);
7135 for (i = 0; i < nrt6; i++) {
7136 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt_arr[i]);
7137 if (IS_ERR(mlxsw_sp_rt6)) {
7138 err = PTR_ERR(mlxsw_sp_rt6);
7139 goto err_rt6_unwind;
7141 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
7145 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
7147 goto err_rt6_unwind;
7149 err = mlxsw_sp_nexthop_group_vr_link(fib_entry->nh_group,
7152 goto err_nexthop_group_vr_link;
7154 err = mlxsw_sp_fib6_entry_type_set(mlxsw_sp, fib_entry, rt_arr[0]);
7156 goto err_fib6_entry_type_set;
7158 fib_entry->fib_node = fib_node;
7162 err_fib6_entry_type_set:
7163 mlxsw_sp_nexthop_group_vr_unlink(fib_entry->nh_group, fib_node->fib);
7164 err_nexthop_group_vr_link:
7165 mlxsw_sp_nexthop6_group_put(mlxsw_sp, fib_entry);
7167 for (; i > 0; i--) {
7169 mlxsw_sp_rt6 = list_last_entry(&fib6_entry->rt6_list,
7170 struct mlxsw_sp_rt6, list);
7171 list_del(&mlxsw_sp_rt6->list);
7172 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
7175 return ERR_PTR(err);
7179 mlxsw_sp_fib6_entry_type_unset(struct mlxsw_sp *mlxsw_sp,
7180 struct mlxsw_sp_fib6_entry *fib6_entry)
7182 mlxsw_sp_fib_entry_type_unset(mlxsw_sp, &fib6_entry->common);
7185 static void mlxsw_sp_fib6_entry_destroy(struct mlxsw_sp *mlxsw_sp,
7186 struct mlxsw_sp_fib6_entry *fib6_entry)
7188 struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
7190 mlxsw_sp_fib6_entry_type_unset(mlxsw_sp, fib6_entry);
7191 mlxsw_sp_nexthop_group_vr_unlink(fib6_entry->common.nh_group,
7193 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
7194 mlxsw_sp_fib6_entry_rt_destroy_all(fib6_entry);
7195 WARN_ON(fib6_entry->nrt6);
7199 static struct mlxsw_sp_fib6_entry *
7200 mlxsw_sp_fib6_entry_lookup(struct mlxsw_sp *mlxsw_sp,
7201 const struct fib6_info *rt)
7203 struct mlxsw_sp_fib6_entry *fib6_entry;
7204 struct mlxsw_sp_fib_node *fib_node;
7205 struct mlxsw_sp_fib *fib;
7206 struct fib6_info *cmp_rt;
7207 struct mlxsw_sp_vr *vr;
7209 vr = mlxsw_sp_vr_find(mlxsw_sp, rt->fib6_table->tb6_id);
7212 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV6);
7214 fib_node = mlxsw_sp_fib_node_lookup(fib, &rt->fib6_dst.addr,
7215 sizeof(rt->fib6_dst.addr),
7220 fib6_entry = container_of(fib_node->fib_entry,
7221 struct mlxsw_sp_fib6_entry, common);
7222 cmp_rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
7223 if (rt->fib6_table->tb6_id == cmp_rt->fib6_table->tb6_id &&
7224 rt->fib6_metric == cmp_rt->fib6_metric &&
7225 mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt))
7231 static bool mlxsw_sp_fib6_allow_replace(struct mlxsw_sp_fib6_entry *fib6_entry)
7233 struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
7234 struct mlxsw_sp_fib6_entry *fib6_replaced;
7235 struct fib6_info *rt, *rt_replaced;
7237 if (!fib_node->fib_entry)
7240 fib6_replaced = container_of(fib_node->fib_entry,
7241 struct mlxsw_sp_fib6_entry,
7243 rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
7244 rt_replaced = mlxsw_sp_fib6_entry_rt(fib6_replaced);
7245 if (rt->fib6_table->tb6_id == RT_TABLE_MAIN &&
7246 rt_replaced->fib6_table->tb6_id == RT_TABLE_LOCAL)
7252 static int mlxsw_sp_router_fib6_replace(struct mlxsw_sp *mlxsw_sp,
7253 struct fib6_info **rt_arr,
7256 struct mlxsw_sp_fib6_entry *fib6_entry, *fib6_replaced;
7257 struct mlxsw_sp_fib_entry *replaced;
7258 struct mlxsw_sp_fib_node *fib_node;
7259 struct fib6_info *rt = rt_arr[0];
7262 if (rt->fib6_src.plen)
7265 if (mlxsw_sp_fib6_rt_should_ignore(rt))
7268 if (rt->nh && !mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, rt->nh->id))
7271 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->fib6_table->tb6_id,
7273 sizeof(rt->fib6_dst.addr),
7275 MLXSW_SP_L3_PROTO_IPV6);
7276 if (IS_ERR(fib_node))
7277 return PTR_ERR(fib_node);
7279 fib6_entry = mlxsw_sp_fib6_entry_create(mlxsw_sp, fib_node, rt_arr,
7281 if (IS_ERR(fib6_entry)) {
7282 err = PTR_ERR(fib6_entry);
7283 goto err_fib6_entry_create;
7286 if (!mlxsw_sp_fib6_allow_replace(fib6_entry)) {
7287 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7288 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7292 replaced = fib_node->fib_entry;
7293 err = mlxsw_sp_fib_node_entry_link(mlxsw_sp, &fib6_entry->common);
7295 goto err_fib_node_entry_link;
7297 /* Nothing to replace */
7301 mlxsw_sp_fib_entry_hw_flags_clear(mlxsw_sp, replaced);
7302 fib6_replaced = container_of(replaced, struct mlxsw_sp_fib6_entry,
7304 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_replaced);
7308 err_fib_node_entry_link:
7309 fib_node->fib_entry = replaced;
7310 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7311 err_fib6_entry_create:
7312 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7316 static int mlxsw_sp_router_fib6_append(struct mlxsw_sp *mlxsw_sp,
7317 struct fib6_info **rt_arr,
7320 struct mlxsw_sp_fib6_entry *fib6_entry;
7321 struct mlxsw_sp_fib_node *fib_node;
7322 struct fib6_info *rt = rt_arr[0];
7325 if (rt->fib6_src.plen)
7328 if (mlxsw_sp_fib6_rt_should_ignore(rt))
7331 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->fib6_table->tb6_id,
7333 sizeof(rt->fib6_dst.addr),
7335 MLXSW_SP_L3_PROTO_IPV6);
7336 if (IS_ERR(fib_node))
7337 return PTR_ERR(fib_node);
7339 if (WARN_ON_ONCE(!fib_node->fib_entry)) {
7340 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7344 fib6_entry = container_of(fib_node->fib_entry,
7345 struct mlxsw_sp_fib6_entry, common);
7346 err = mlxsw_sp_fib6_entry_nexthop_add(mlxsw_sp, fib6_entry, rt_arr,
7349 goto err_fib6_entry_nexthop_add;
7353 err_fib6_entry_nexthop_add:
7354 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7358 static void mlxsw_sp_router_fib6_del(struct mlxsw_sp *mlxsw_sp,
7359 struct fib6_info **rt_arr,
7362 struct mlxsw_sp_fib6_entry *fib6_entry;
7363 struct mlxsw_sp_fib_node *fib_node;
7364 struct fib6_info *rt = rt_arr[0];
7366 if (mlxsw_sp_fib6_rt_should_ignore(rt))
7369 /* Multipath routes are first added to the FIB trie and only then
7370 * notified. If we vetoed the addition, we will get a delete
7371 * notification for a route we do not have. Therefore, do not warn if
7372 * route was not found.
7374 fib6_entry = mlxsw_sp_fib6_entry_lookup(mlxsw_sp, rt);
7378 /* If not all the nexthops are deleted, then only reduce the nexthop
7381 if (nrt6 != fib6_entry->nrt6) {
7382 mlxsw_sp_fib6_entry_nexthop_del(mlxsw_sp, fib6_entry, rt_arr,
7387 fib_node = fib6_entry->common.fib_node;
7389 mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, &fib6_entry->common);
7390 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7391 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7394 static struct mlxsw_sp_mr_table *
7395 mlxsw_sp_router_fibmr_family_to_table(struct mlxsw_sp_vr *vr, int family)
7397 if (family == RTNL_FAMILY_IPMR)
7398 return vr->mr_table[MLXSW_SP_L3_PROTO_IPV4];
7400 return vr->mr_table[MLXSW_SP_L3_PROTO_IPV6];
7403 static int mlxsw_sp_router_fibmr_add(struct mlxsw_sp *mlxsw_sp,
7404 struct mfc_entry_notifier_info *men_info,
7407 struct mlxsw_sp_mr_table *mrt;
7408 struct mlxsw_sp_vr *vr;
7410 vr = mlxsw_sp_vr_get(mlxsw_sp, men_info->tb_id, NULL);
7414 mrt = mlxsw_sp_router_fibmr_family_to_table(vr, men_info->info.family);
7415 return mlxsw_sp_mr_route_add(mrt, men_info->mfc, replace);
7418 static void mlxsw_sp_router_fibmr_del(struct mlxsw_sp *mlxsw_sp,
7419 struct mfc_entry_notifier_info *men_info)
7421 struct mlxsw_sp_mr_table *mrt;
7422 struct mlxsw_sp_vr *vr;
7424 vr = mlxsw_sp_vr_find(mlxsw_sp, men_info->tb_id);
7428 mrt = mlxsw_sp_router_fibmr_family_to_table(vr, men_info->info.family);
7429 mlxsw_sp_mr_route_del(mrt, men_info->mfc);
7430 mlxsw_sp_vr_put(mlxsw_sp, vr);
7434 mlxsw_sp_router_fibmr_vif_add(struct mlxsw_sp *mlxsw_sp,
7435 struct vif_entry_notifier_info *ven_info)
7437 struct mlxsw_sp_mr_table *mrt;
7438 struct mlxsw_sp_rif *rif;
7439 struct mlxsw_sp_vr *vr;
7441 vr = mlxsw_sp_vr_get(mlxsw_sp, ven_info->tb_id, NULL);
7445 mrt = mlxsw_sp_router_fibmr_family_to_table(vr, ven_info->info.family);
7446 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, ven_info->dev);
7447 return mlxsw_sp_mr_vif_add(mrt, ven_info->dev,
7448 ven_info->vif_index,
7449 ven_info->vif_flags, rif);
7453 mlxsw_sp_router_fibmr_vif_del(struct mlxsw_sp *mlxsw_sp,
7454 struct vif_entry_notifier_info *ven_info)
7456 struct mlxsw_sp_mr_table *mrt;
7457 struct mlxsw_sp_vr *vr;
7459 vr = mlxsw_sp_vr_find(mlxsw_sp, ven_info->tb_id);
7463 mrt = mlxsw_sp_router_fibmr_family_to_table(vr, ven_info->info.family);
7464 mlxsw_sp_mr_vif_del(mrt, ven_info->vif_index);
7465 mlxsw_sp_vr_put(mlxsw_sp, vr);
7468 static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
7469 struct mlxsw_sp_fib_node *fib_node)
7471 struct mlxsw_sp_fib4_entry *fib4_entry;
7473 fib4_entry = container_of(fib_node->fib_entry,
7474 struct mlxsw_sp_fib4_entry, common);
7475 mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, fib_node->fib_entry);
7476 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
7477 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7480 static void mlxsw_sp_fib6_node_flush(struct mlxsw_sp *mlxsw_sp,
7481 struct mlxsw_sp_fib_node *fib_node)
7483 struct mlxsw_sp_fib6_entry *fib6_entry;
7485 fib6_entry = container_of(fib_node->fib_entry,
7486 struct mlxsw_sp_fib6_entry, common);
7487 mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, fib_node->fib_entry);
7488 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7489 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7492 static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
7493 struct mlxsw_sp_fib_node *fib_node)
7495 switch (fib_node->fib->proto) {
7496 case MLXSW_SP_L3_PROTO_IPV4:
7497 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
7499 case MLXSW_SP_L3_PROTO_IPV6:
7500 mlxsw_sp_fib6_node_flush(mlxsw_sp, fib_node);
7505 static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
7506 struct mlxsw_sp_vr *vr,
7507 enum mlxsw_sp_l3proto proto)
7509 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
7510 struct mlxsw_sp_fib_node *fib_node, *tmp;
7512 list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
7513 bool do_break = &tmp->list == &fib->node_list;
7515 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
7521 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
7523 int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
7526 for (i = 0; i < max_vrs; i++) {
7527 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
7529 if (!mlxsw_sp_vr_is_used(vr))
7532 for (j = 0; j < MLXSW_SP_L3_PROTO_MAX; j++)
7533 mlxsw_sp_mr_table_flush(vr->mr_table[j]);
7534 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
7536 /* If virtual router was only used for IPv4, then it's no
7539 if (!mlxsw_sp_vr_is_used(vr))
7541 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
7545 struct mlxsw_sp_fib6_event_work {
7546 struct fib6_info **rt_arr;
7550 struct mlxsw_sp_fib_event_work {
7551 struct work_struct work;
7552 netdevice_tracker dev_tracker;
7554 struct mlxsw_sp_fib6_event_work fib6_work;
7555 struct fib_entry_notifier_info fen_info;
7556 struct fib_rule_notifier_info fr_info;
7557 struct fib_nh_notifier_info fnh_info;
7558 struct mfc_entry_notifier_info men_info;
7559 struct vif_entry_notifier_info ven_info;
7561 struct mlxsw_sp *mlxsw_sp;
7562 unsigned long event;
7566 mlxsw_sp_router_fib6_work_init(struct mlxsw_sp_fib6_event_work *fib6_work,
7567 struct fib6_entry_notifier_info *fen6_info)
7569 struct fib6_info *rt = fen6_info->rt;
7570 struct fib6_info **rt_arr;
7571 struct fib6_info *iter;
7575 nrt6 = fen6_info->nsiblings + 1;
7577 rt_arr = kcalloc(nrt6, sizeof(struct fib6_info *), GFP_ATOMIC);
7581 fib6_work->rt_arr = rt_arr;
7582 fib6_work->nrt6 = nrt6;
7587 if (!fen6_info->nsiblings)
7590 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {
7591 if (i == fen6_info->nsiblings)
7594 rt_arr[i + 1] = iter;
7595 fib6_info_hold(iter);
7598 WARN_ON_ONCE(i != fen6_info->nsiblings);
7604 mlxsw_sp_router_fib6_work_fini(struct mlxsw_sp_fib6_event_work *fib6_work)
7608 for (i = 0; i < fib6_work->nrt6; i++)
7609 mlxsw_sp_rt6_release(fib6_work->rt_arr[i]);
7610 kfree(fib6_work->rt_arr);
7613 static void mlxsw_sp_router_fib4_event_work(struct work_struct *work)
7615 struct mlxsw_sp_fib_event_work *fib_work =
7616 container_of(work, struct mlxsw_sp_fib_event_work, work);
7617 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
7620 mutex_lock(&mlxsw_sp->router->lock);
7621 mlxsw_sp_span_respin(mlxsw_sp);
7623 switch (fib_work->event) {
7624 case FIB_EVENT_ENTRY_REPLACE:
7625 err = mlxsw_sp_router_fib4_replace(mlxsw_sp,
7626 &fib_work->fen_info);
7628 dev_warn(mlxsw_sp->bus_info->dev, "FIB replace failed.\n");
7629 mlxsw_sp_fib4_offload_failed_flag_set(mlxsw_sp,
7630 &fib_work->fen_info);
7632 fib_info_put(fib_work->fen_info.fi);
7634 case FIB_EVENT_ENTRY_DEL:
7635 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
7636 fib_info_put(fib_work->fen_info.fi);
7638 case FIB_EVENT_NH_ADD:
7639 case FIB_EVENT_NH_DEL:
7640 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
7641 fib_work->fnh_info.fib_nh);
7642 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
7645 mutex_unlock(&mlxsw_sp->router->lock);
7649 static void mlxsw_sp_router_fib6_event_work(struct work_struct *work)
7651 struct mlxsw_sp_fib_event_work *fib_work =
7652 container_of(work, struct mlxsw_sp_fib_event_work, work);
7653 struct mlxsw_sp_fib6_event_work *fib6_work = &fib_work->fib6_work;
7654 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
7657 mutex_lock(&mlxsw_sp->router->lock);
7658 mlxsw_sp_span_respin(mlxsw_sp);
7660 switch (fib_work->event) {
7661 case FIB_EVENT_ENTRY_REPLACE:
7662 err = mlxsw_sp_router_fib6_replace(mlxsw_sp,
7666 dev_warn(mlxsw_sp->bus_info->dev, "FIB replace failed.\n");
7667 mlxsw_sp_fib6_offload_failed_flag_set(mlxsw_sp,
7671 mlxsw_sp_router_fib6_work_fini(fib6_work);
7673 case FIB_EVENT_ENTRY_APPEND:
7674 err = mlxsw_sp_router_fib6_append(mlxsw_sp,
7678 dev_warn(mlxsw_sp->bus_info->dev, "FIB append failed.\n");
7679 mlxsw_sp_fib6_offload_failed_flag_set(mlxsw_sp,
7683 mlxsw_sp_router_fib6_work_fini(fib6_work);
7685 case FIB_EVENT_ENTRY_DEL:
7686 mlxsw_sp_router_fib6_del(mlxsw_sp,
7689 mlxsw_sp_router_fib6_work_fini(fib6_work);
7692 mutex_unlock(&mlxsw_sp->router->lock);
7696 static void mlxsw_sp_router_fibmr_event_work(struct work_struct *work)
7698 struct mlxsw_sp_fib_event_work *fib_work =
7699 container_of(work, struct mlxsw_sp_fib_event_work, work);
7700 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
7705 mutex_lock(&mlxsw_sp->router->lock);
7706 switch (fib_work->event) {
7707 case FIB_EVENT_ENTRY_REPLACE:
7708 case FIB_EVENT_ENTRY_ADD:
7709 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
7711 err = mlxsw_sp_router_fibmr_add(mlxsw_sp, &fib_work->men_info,
7714 dev_warn(mlxsw_sp->bus_info->dev, "MR entry add failed.\n");
7715 mr_cache_put(fib_work->men_info.mfc);
7717 case FIB_EVENT_ENTRY_DEL:
7718 mlxsw_sp_router_fibmr_del(mlxsw_sp, &fib_work->men_info);
7719 mr_cache_put(fib_work->men_info.mfc);
7721 case FIB_EVENT_VIF_ADD:
7722 err = mlxsw_sp_router_fibmr_vif_add(mlxsw_sp,
7723 &fib_work->ven_info);
7725 dev_warn(mlxsw_sp->bus_info->dev, "MR VIF add failed.\n");
7726 netdev_put(fib_work->ven_info.dev, &fib_work->dev_tracker);
7728 case FIB_EVENT_VIF_DEL:
7729 mlxsw_sp_router_fibmr_vif_del(mlxsw_sp,
7730 &fib_work->ven_info);
7731 netdev_put(fib_work->ven_info.dev, &fib_work->dev_tracker);
7734 mutex_unlock(&mlxsw_sp->router->lock);
7739 static void mlxsw_sp_router_fib4_event(struct mlxsw_sp_fib_event_work *fib_work,
7740 struct fib_notifier_info *info)
7742 struct fib_entry_notifier_info *fen_info;
7743 struct fib_nh_notifier_info *fnh_info;
7745 switch (fib_work->event) {
7746 case FIB_EVENT_ENTRY_REPLACE:
7747 case FIB_EVENT_ENTRY_DEL:
7748 fen_info = container_of(info, struct fib_entry_notifier_info,
7750 fib_work->fen_info = *fen_info;
7751 /* Take reference on fib_info to prevent it from being
7752 * freed while work is queued. Release it afterwards.
7754 fib_info_hold(fib_work->fen_info.fi);
7756 case FIB_EVENT_NH_ADD:
7757 case FIB_EVENT_NH_DEL:
7758 fnh_info = container_of(info, struct fib_nh_notifier_info,
7760 fib_work->fnh_info = *fnh_info;
7761 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
7766 static int mlxsw_sp_router_fib6_event(struct mlxsw_sp_fib_event_work *fib_work,
7767 struct fib_notifier_info *info)
7769 struct fib6_entry_notifier_info *fen6_info;
7772 switch (fib_work->event) {
7773 case FIB_EVENT_ENTRY_REPLACE:
7774 case FIB_EVENT_ENTRY_APPEND:
7775 case FIB_EVENT_ENTRY_DEL:
7776 fen6_info = container_of(info, struct fib6_entry_notifier_info,
7778 err = mlxsw_sp_router_fib6_work_init(&fib_work->fib6_work,
7789 mlxsw_sp_router_fibmr_event(struct mlxsw_sp_fib_event_work *fib_work,
7790 struct fib_notifier_info *info)
7792 switch (fib_work->event) {
7793 case FIB_EVENT_ENTRY_REPLACE:
7794 case FIB_EVENT_ENTRY_ADD:
7795 case FIB_EVENT_ENTRY_DEL:
7796 memcpy(&fib_work->men_info, info, sizeof(fib_work->men_info));
7797 mr_cache_hold(fib_work->men_info.mfc);
7799 case FIB_EVENT_VIF_ADD:
7800 case FIB_EVENT_VIF_DEL:
7801 memcpy(&fib_work->ven_info, info, sizeof(fib_work->ven_info));
7802 netdev_hold(fib_work->ven_info.dev, &fib_work->dev_tracker,
7808 static int mlxsw_sp_router_fib_rule_event(unsigned long event,
7809 struct fib_notifier_info *info,
7810 struct mlxsw_sp *mlxsw_sp)
7812 struct netlink_ext_ack *extack = info->extack;
7813 struct fib_rule_notifier_info *fr_info;
7814 struct fib_rule *rule;
7817 /* nothing to do at the moment */
7818 if (event == FIB_EVENT_RULE_DEL)
7821 fr_info = container_of(info, struct fib_rule_notifier_info, info);
7822 rule = fr_info->rule;
7824 /* Rule only affects locally generated traffic */
7825 if (rule->iifindex == mlxsw_sp_net(mlxsw_sp)->loopback_dev->ifindex)
7828 switch (info->family) {
7830 if (!fib4_rule_default(rule) && !rule->l3mdev)
7834 if (!fib6_rule_default(rule) && !rule->l3mdev)
7837 case RTNL_FAMILY_IPMR:
7838 if (!ipmr_rule_default(rule) && !rule->l3mdev)
7841 case RTNL_FAMILY_IP6MR:
7842 if (!ip6mr_rule_default(rule) && !rule->l3mdev)
7848 NL_SET_ERR_MSG_MOD(extack, "FIB rules not supported");
7853 /* Called with rcu_read_lock() */
7854 static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
7855 unsigned long event, void *ptr)
7857 struct mlxsw_sp_fib_event_work *fib_work;
7858 struct fib_notifier_info *info = ptr;
7859 struct mlxsw_sp_router *router;
7862 if ((info->family != AF_INET && info->family != AF_INET6 &&
7863 info->family != RTNL_FAMILY_IPMR &&
7864 info->family != RTNL_FAMILY_IP6MR))
7867 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
7870 case FIB_EVENT_RULE_ADD:
7871 case FIB_EVENT_RULE_DEL:
7872 err = mlxsw_sp_router_fib_rule_event(event, info,
7874 return notifier_from_errno(err);
7875 case FIB_EVENT_ENTRY_ADD:
7876 case FIB_EVENT_ENTRY_REPLACE:
7877 case FIB_EVENT_ENTRY_APPEND:
7878 if (info->family == AF_INET) {
7879 struct fib_entry_notifier_info *fen_info = ptr;
7881 if (fen_info->fi->fib_nh_is_v6) {
7882 NL_SET_ERR_MSG_MOD(info->extack, "IPv6 gateway with IPv4 route is not supported");
7883 return notifier_from_errno(-EINVAL);
7889 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
7893 fib_work->mlxsw_sp = router->mlxsw_sp;
7894 fib_work->event = event;
7896 switch (info->family) {
7898 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib4_event_work);
7899 mlxsw_sp_router_fib4_event(fib_work, info);
7902 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib6_event_work);
7903 err = mlxsw_sp_router_fib6_event(fib_work, info);
7907 case RTNL_FAMILY_IP6MR:
7908 case RTNL_FAMILY_IPMR:
7909 INIT_WORK(&fib_work->work, mlxsw_sp_router_fibmr_event_work);
7910 mlxsw_sp_router_fibmr_event(fib_work, info);
7914 mlxsw_core_schedule_work(&fib_work->work);
7923 static struct mlxsw_sp_rif *
7924 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
7925 const struct net_device *dev)
7927 int max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
7930 for (i = 0; i < max_rifs; i++)
7931 if (mlxsw_sp->router->rifs[i] &&
7932 mlxsw_sp_rif_dev_is(mlxsw_sp->router->rifs[i], dev))
7933 return mlxsw_sp->router->rifs[i];
7938 bool mlxsw_sp_rif_exists(struct mlxsw_sp *mlxsw_sp,
7939 const struct net_device *dev)
7941 struct mlxsw_sp_rif *rif;
7943 mutex_lock(&mlxsw_sp->router->lock);
7944 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7945 mutex_unlock(&mlxsw_sp->router->lock);
7950 u16 mlxsw_sp_rif_vid(struct mlxsw_sp *mlxsw_sp, const struct net_device *dev)
7952 struct mlxsw_sp_rif *rif;
7955 mutex_lock(&mlxsw_sp->router->lock);
7956 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7960 /* We only return the VID for VLAN RIFs. Otherwise we return an
7961 * invalid value (0).
7963 if (rif->ops->type != MLXSW_SP_RIF_TYPE_VLAN)
7966 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
7969 mutex_unlock(&mlxsw_sp->router->lock);
7973 static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
7975 char ritr_pl[MLXSW_REG_RITR_LEN];
7978 mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
7979 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7983 mlxsw_reg_ritr_enable_set(ritr_pl, false);
7984 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7987 static int mlxsw_sp_router_rif_made_sync(struct mlxsw_sp *mlxsw_sp,
7988 struct mlxsw_sp_rif *rif)
7992 err = mlxsw_sp_neigh_rif_made_sync(mlxsw_sp, rif);
7996 err = mlxsw_sp_nexthop_rif_made_sync(mlxsw_sp, rif);
8003 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
8007 static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
8008 struct mlxsw_sp_rif *rif)
8010 /* Signal to nexthop cleanup that the RIF is going away. */
8011 rif->crif->rif = NULL;
8013 mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
8014 mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
8015 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
8018 static bool __mlxsw_sp_dev_addr_list_empty(const struct net_device *dev)
8020 struct inet6_dev *inet6_dev;
8021 struct in_device *idev;
8023 idev = __in_dev_get_rcu(dev);
8024 if (idev && idev->ifa_list)
8027 inet6_dev = __in6_dev_get(dev);
8028 if (inet6_dev && !list_empty(&inet6_dev->addr_list))
8034 static bool mlxsw_sp_dev_addr_list_empty(const struct net_device *dev)
8036 bool addr_list_empty;
8039 addr_list_empty = __mlxsw_sp_dev_addr_list_empty(dev);
8042 return addr_list_empty;
8046 mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
8047 unsigned long event)
8049 bool addr_list_empty;
8055 addr_list_empty = mlxsw_sp_dev_addr_list_empty(dev);
8057 /* macvlans do not have a RIF, but rather piggy back on the
8058 * RIF of their lower device.
8060 if (netif_is_macvlan(dev) && addr_list_empty)
8063 if (rif && addr_list_empty &&
8064 !netif_is_l3_slave(mlxsw_sp_rif_dev(rif)))
8066 /* It is possible we already removed the RIF ourselves
8067 * if it was assigned to a netdev that is now a bridge
8076 static enum mlxsw_sp_rif_type
8077 mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
8078 const struct net_device *dev)
8080 enum mlxsw_sp_fid_type type;
8082 if (mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL))
8083 return MLXSW_SP_RIF_TYPE_IPIP_LB;
8085 /* Otherwise RIF type is derived from the type of the underlying FID. */
8086 if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
8087 type = MLXSW_SP_FID_TYPE_8021Q;
8088 else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
8089 type = MLXSW_SP_FID_TYPE_8021Q;
8090 else if (netif_is_bridge_master(dev))
8091 type = MLXSW_SP_FID_TYPE_8021D;
8093 type = MLXSW_SP_FID_TYPE_RFID;
8095 return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
8098 static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index,
8101 *p_rif_index = gen_pool_alloc(mlxsw_sp->router->rifs_table,
8103 if (*p_rif_index == 0)
8105 *p_rif_index -= MLXSW_SP_ROUTER_GENALLOC_OFFSET;
8107 /* RIF indexes must be aligned to the allocation size. */
8108 WARN_ON_ONCE(*p_rif_index % rif_entries);
8113 static void mlxsw_sp_rif_index_free(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
8116 gen_pool_free(mlxsw_sp->router->rifs_table,
8117 MLXSW_SP_ROUTER_GENALLOC_OFFSET + rif_index, rif_entries);
8120 static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
8122 struct mlxsw_sp_crif *crif)
8124 struct net_device *l3_dev = crif ? crif->key.dev : NULL;
8125 struct mlxsw_sp_rif *rif;
8127 rif = kzalloc(rif_size, GFP_KERNEL);
8131 INIT_LIST_HEAD(&rif->neigh_list);
8133 ether_addr_copy(rif->addr, l3_dev->dev_addr);
8134 rif->mtu = l3_dev->mtu;
8137 rif->rif_index = rif_index;
8146 static void mlxsw_sp_rif_free(struct mlxsw_sp_rif *rif)
8148 WARN_ON(!list_empty(&rif->neigh_list));
8151 rif->crif->rif = NULL;
8155 struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
8158 return mlxsw_sp->router->rifs[rif_index];
8161 u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
8163 return rif->rif_index;
8166 u16 mlxsw_sp_ipip_lb_rif_index(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
8168 return lb_rif->common.rif_index;
8171 u16 mlxsw_sp_ipip_lb_ul_vr_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
8173 struct net_device *dev = mlxsw_sp_rif_dev(&lb_rif->common);
8174 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(dev);
8175 struct mlxsw_sp_vr *ul_vr;
8177 ul_vr = mlxsw_sp_vr_get(lb_rif->common.mlxsw_sp, ul_tb_id, NULL);
8178 if (WARN_ON(IS_ERR(ul_vr)))
8184 u16 mlxsw_sp_ipip_lb_ul_rif_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
8186 return lb_rif->ul_rif_id;
8190 mlxsw_sp_router_port_l3_stats_enabled(struct mlxsw_sp_rif *rif)
8192 return mlxsw_sp_rif_counter_valid_get(rif,
8193 MLXSW_SP_RIF_COUNTER_EGRESS) &&
8194 mlxsw_sp_rif_counter_valid_get(rif,
8195 MLXSW_SP_RIF_COUNTER_INGRESS);
8199 mlxsw_sp_router_port_l3_stats_enable(struct mlxsw_sp_rif *rif)
8203 err = mlxsw_sp_rif_counter_alloc(rif, MLXSW_SP_RIF_COUNTER_INGRESS);
8207 /* Clear stale data. */
8208 err = mlxsw_sp_rif_counter_fetch_clear(rif,
8209 MLXSW_SP_RIF_COUNTER_INGRESS,
8212 goto err_clear_ingress;
8214 err = mlxsw_sp_rif_counter_alloc(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
8216 goto err_alloc_egress;
8218 /* Clear stale data. */
8219 err = mlxsw_sp_rif_counter_fetch_clear(rif,
8220 MLXSW_SP_RIF_COUNTER_EGRESS,
8223 goto err_clear_egress;
8228 mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
8231 mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_INGRESS);
8236 mlxsw_sp_router_port_l3_stats_disable(struct mlxsw_sp_rif *rif)
8238 mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
8239 mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_INGRESS);
8243 mlxsw_sp_router_port_l3_stats_report_used(struct mlxsw_sp_rif *rif,
8244 struct netdev_notifier_offload_xstats_info *info)
8246 if (!mlxsw_sp_router_port_l3_stats_enabled(rif))
8248 netdev_offload_xstats_report_used(info->report_used);
8252 mlxsw_sp_router_port_l3_stats_fetch(struct mlxsw_sp_rif *rif,
8253 struct rtnl_hw_stats64 *p_stats)
8255 struct mlxsw_sp_rif_counter_set_basic ingress;
8256 struct mlxsw_sp_rif_counter_set_basic egress;
8259 err = mlxsw_sp_rif_counter_fetch_clear(rif,
8260 MLXSW_SP_RIF_COUNTER_INGRESS,
8265 err = mlxsw_sp_rif_counter_fetch_clear(rif,
8266 MLXSW_SP_RIF_COUNTER_EGRESS,
8271 #define MLXSW_SP_ROUTER_ALL_GOOD(SET, SFX) \
8272 ((SET.good_unicast_ ## SFX) + \
8273 (SET.good_multicast_ ## SFX) + \
8274 (SET.good_broadcast_ ## SFX))
8276 p_stats->rx_packets = MLXSW_SP_ROUTER_ALL_GOOD(ingress, packets);
8277 p_stats->tx_packets = MLXSW_SP_ROUTER_ALL_GOOD(egress, packets);
8278 p_stats->rx_bytes = MLXSW_SP_ROUTER_ALL_GOOD(ingress, bytes);
8279 p_stats->tx_bytes = MLXSW_SP_ROUTER_ALL_GOOD(egress, bytes);
8280 p_stats->rx_errors = ingress.error_packets;
8281 p_stats->tx_errors = egress.error_packets;
8282 p_stats->rx_dropped = ingress.discard_packets;
8283 p_stats->tx_dropped = egress.discard_packets;
8284 p_stats->multicast = ingress.good_multicast_packets +
8285 ingress.good_broadcast_packets;
8287 #undef MLXSW_SP_ROUTER_ALL_GOOD
8293 mlxsw_sp_router_port_l3_stats_report_delta(struct mlxsw_sp_rif *rif,
8294 struct netdev_notifier_offload_xstats_info *info)
8296 struct rtnl_hw_stats64 stats = {};
8299 if (!mlxsw_sp_router_port_l3_stats_enabled(rif))
8302 err = mlxsw_sp_router_port_l3_stats_fetch(rif, &stats);
8306 netdev_offload_xstats_report_delta(info->report_delta, &stats);
8310 struct mlxsw_sp_router_hwstats_notify_work {
8311 struct work_struct work;
8312 struct net_device *dev;
8313 netdevice_tracker dev_tracker;
8316 static void mlxsw_sp_router_hwstats_notify_work(struct work_struct *work)
8318 struct mlxsw_sp_router_hwstats_notify_work *hws_work =
8319 container_of(work, struct mlxsw_sp_router_hwstats_notify_work,
8323 rtnl_offload_xstats_notify(hws_work->dev);
8325 netdev_put(hws_work->dev, &hws_work->dev_tracker);
8330 mlxsw_sp_router_hwstats_notify_schedule(struct net_device *dev)
8332 struct mlxsw_sp_router_hwstats_notify_work *hws_work;
8334 /* To collect notification payload, the core ends up sending another
8335 * notifier block message, which would deadlock on the attempt to
8336 * acquire the router lock again. Just postpone the notification until
8340 hws_work = kzalloc(sizeof(*hws_work), GFP_KERNEL);
8344 INIT_WORK(&hws_work->work, mlxsw_sp_router_hwstats_notify_work);
8345 netdev_hold(dev, &hws_work->dev_tracker, GFP_KERNEL);
8346 hws_work->dev = dev;
8347 mlxsw_core_schedule_work(&hws_work->work);
8350 int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
8352 return mlxsw_sp_rif_dev(rif)->ifindex;
8355 bool mlxsw_sp_rif_has_dev(const struct mlxsw_sp_rif *rif)
8357 return !!mlxsw_sp_rif_dev(rif);
8360 bool mlxsw_sp_rif_dev_is(const struct mlxsw_sp_rif *rif,
8361 const struct net_device *dev)
8363 return mlxsw_sp_rif_dev(rif) == dev;
8366 static void mlxsw_sp_rif_push_l3_stats(struct mlxsw_sp_rif *rif)
8368 struct rtnl_hw_stats64 stats = {};
8370 if (!mlxsw_sp_router_port_l3_stats_fetch(rif, &stats))
8371 netdev_offload_xstats_push_delta(mlxsw_sp_rif_dev(rif),
8372 NETDEV_OFFLOAD_XSTATS_TYPE_L3,
8376 static struct mlxsw_sp_rif *
8377 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
8378 const struct mlxsw_sp_rif_params *params,
8379 struct netlink_ext_ack *extack)
8381 u8 rif_entries = params->double_entry ? 2 : 1;
8382 u32 tb_id = l3mdev_fib_table(params->dev);
8383 const struct mlxsw_sp_rif_ops *ops;
8384 struct mlxsw_sp_fid *fid = NULL;
8385 enum mlxsw_sp_rif_type type;
8386 struct mlxsw_sp_crif *crif;
8387 struct mlxsw_sp_rif *rif;
8388 struct mlxsw_sp_vr *vr;
8392 type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
8393 ops = mlxsw_sp->router->rif_ops_arr[type];
8395 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN, extack);
8397 return ERR_CAST(vr);
8400 err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index, rif_entries);
8402 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interfaces");
8403 goto err_rif_index_alloc;
8406 crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, params->dev);
8407 if (WARN_ON(!crif)) {
8409 goto err_crif_lookup;
8412 rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, crif);
8417 netdev_hold(params->dev, &rif->dev_tracker, GFP_KERNEL);
8418 mlxsw_sp->router->rifs[rif_index] = rif;
8419 rif->mlxsw_sp = mlxsw_sp;
8421 rif->rif_entries = rif_entries;
8424 ops->setup(rif, params);
8427 fid = ops->fid_get(rif, params, extack);
8435 err = ops->configure(rif, extack);
8439 for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++) {
8440 err = mlxsw_sp_mr_rif_add(vr->mr_table[i], rif);
8442 goto err_mr_rif_add;
8445 err = mlxsw_sp_router_rif_made_sync(mlxsw_sp, rif);
8447 goto err_rif_made_sync;
8449 if (netdev_offload_xstats_enabled(params->dev,
8450 NETDEV_OFFLOAD_XSTATS_TYPE_L3)) {
8451 err = mlxsw_sp_router_port_l3_stats_enable(rif);
8453 goto err_stats_enable;
8454 mlxsw_sp_router_hwstats_notify_schedule(params->dev);
8456 mlxsw_sp_rif_counters_alloc(rif);
8459 atomic_add(rif_entries, &mlxsw_sp->router->rifs_count);
8463 mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
8466 for (i--; i >= 0; i--)
8467 mlxsw_sp_mr_rif_del(vr->mr_table[i], rif);
8468 ops->deconfigure(rif);
8471 mlxsw_sp_fid_put(fid);
8473 mlxsw_sp->router->rifs[rif_index] = NULL;
8474 netdev_put(params->dev, &rif->dev_tracker);
8475 mlxsw_sp_rif_free(rif);
8478 mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
8479 err_rif_index_alloc:
8481 mlxsw_sp_vr_put(mlxsw_sp, vr);
8482 return ERR_PTR(err);
8485 static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
8487 struct net_device *dev = mlxsw_sp_rif_dev(rif);
8488 const struct mlxsw_sp_rif_ops *ops = rif->ops;
8489 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
8490 struct mlxsw_sp_crif *crif = rif->crif;
8491 struct mlxsw_sp_fid *fid = rif->fid;
8492 u8 rif_entries = rif->rif_entries;
8493 u16 rif_index = rif->rif_index;
8494 struct mlxsw_sp_vr *vr;
8497 atomic_sub(rif_entries, &mlxsw_sp->router->rifs_count);
8498 mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
8499 vr = &mlxsw_sp->router->vrs[rif->vr_id];
8501 if (netdev_offload_xstats_enabled(dev, NETDEV_OFFLOAD_XSTATS_TYPE_L3)) {
8502 mlxsw_sp_rif_push_l3_stats(rif);
8503 mlxsw_sp_router_port_l3_stats_disable(rif);
8504 mlxsw_sp_router_hwstats_notify_schedule(dev);
8506 mlxsw_sp_rif_counters_free(rif);
8509 for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++)
8510 mlxsw_sp_mr_rif_del(vr->mr_table[i], rif);
8511 ops->deconfigure(rif);
8513 /* Loopback RIFs are not associated with a FID. */
8514 mlxsw_sp_fid_put(fid);
8515 mlxsw_sp->router->rifs[rif->rif_index] = NULL;
8516 netdev_put(dev, &rif->dev_tracker);
8517 mlxsw_sp_rif_free(rif);
8518 mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
8520 mlxsw_sp_vr_put(mlxsw_sp, vr);
8522 if (crif->can_destroy)
8523 mlxsw_sp_crif_free(crif);
8526 void mlxsw_sp_rif_destroy_by_dev(struct mlxsw_sp *mlxsw_sp,
8527 struct net_device *dev)
8529 struct mlxsw_sp_rif *rif;
8531 mutex_lock(&mlxsw_sp->router->lock);
8532 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
8535 mlxsw_sp_rif_destroy(rif);
8537 mutex_unlock(&mlxsw_sp->router->lock);
8540 static void mlxsw_sp_rif_destroy_vlan_upper(struct mlxsw_sp *mlxsw_sp,
8541 struct net_device *br_dev,
8544 struct net_device *upper_dev;
8545 struct mlxsw_sp_crif *crif;
8548 upper_dev = __vlan_find_dev_deep_rcu(br_dev, htons(ETH_P_8021Q), vid);
8554 crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, upper_dev);
8555 if (!crif || !crif->rif)
8558 mlxsw_sp_rif_destroy(crif->rif);
8561 static int mlxsw_sp_inetaddr_bridge_event(struct mlxsw_sp *mlxsw_sp,
8562 struct net_device *l3_dev,
8564 unsigned long event,
8565 struct netlink_ext_ack *extack);
8567 int mlxsw_sp_router_bridge_vlan_add(struct mlxsw_sp *mlxsw_sp,
8568 struct net_device *br_dev,
8569 u16 new_vid, bool is_pvid,
8570 struct netlink_ext_ack *extack)
8572 struct mlxsw_sp_rif *old_rif;
8573 struct mlxsw_sp_rif *new_rif;
8574 struct net_device *upper_dev;
8579 mutex_lock(&mlxsw_sp->router->lock);
8580 old_rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, br_dev);
8582 /* If the RIF on the bridge is not a VLAN RIF, we shouldn't have
8583 * gotten a PVID notification.
8585 if (WARN_ON(old_rif->ops->type != MLXSW_SP_RIF_TYPE_VLAN))
8588 old_pvid = mlxsw_sp_fid_8021q_vid(old_rif->fid);
8593 else if (old_pvid == new_vid)
8598 if (old_pvid == new_pvid)
8602 struct mlxsw_sp_rif_params params = {
8607 /* If there is a VLAN upper with the same VID as the new PVID,
8608 * kill its RIF, if there is one.
8610 mlxsw_sp_rif_destroy_vlan_upper(mlxsw_sp, br_dev, new_pvid);
8612 if (mlxsw_sp_dev_addr_list_empty(br_dev))
8614 new_rif = mlxsw_sp_rif_create(mlxsw_sp, ¶ms, extack);
8615 if (IS_ERR(new_rif)) {
8616 err = PTR_ERR(new_rif);
8621 mlxsw_sp_rif_migrate_destroy(mlxsw_sp, old_rif, new_rif,
8624 mlxsw_sp_rif_destroy(old_rif);
8629 upper_dev = __vlan_find_dev_deep_rcu(br_dev, htons(ETH_P_8021Q),
8633 err = mlxsw_sp_inetaddr_bridge_event(mlxsw_sp,
8640 mutex_unlock(&mlxsw_sp->router->lock);
8645 mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
8646 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
8648 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
8650 params->vid = mlxsw_sp_port_vlan->vid;
8651 params->lag = mlxsw_sp_port->lagged;
8653 params->lag_id = mlxsw_sp_port->lag_id;
8655 params->system_port = mlxsw_sp_port->local_port;
8658 static struct mlxsw_sp_rif_subport *
8659 mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
8661 return container_of(rif, struct mlxsw_sp_rif_subport, common);
8664 int mlxsw_sp_rif_subport_port(const struct mlxsw_sp_rif *rif,
8665 u16 *port, bool *is_lag)
8667 struct mlxsw_sp_rif_subport *rif_subport;
8669 if (WARN_ON(rif->ops->type != MLXSW_SP_RIF_TYPE_SUBPORT))
8672 rif_subport = mlxsw_sp_rif_subport_rif(rif);
8673 *is_lag = rif_subport->lag;
8674 *port = *is_lag ? rif_subport->lag_id : rif_subport->system_port;
8678 static struct mlxsw_sp_rif *
8679 mlxsw_sp_rif_subport_get(struct mlxsw_sp *mlxsw_sp,
8680 const struct mlxsw_sp_rif_params *params,
8681 struct netlink_ext_ack *extack)
8683 struct mlxsw_sp_rif_subport *rif_subport;
8684 struct mlxsw_sp_rif *rif;
8686 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, params->dev);
8688 return mlxsw_sp_rif_create(mlxsw_sp, params, extack);
8690 rif_subport = mlxsw_sp_rif_subport_rif(rif);
8691 refcount_inc(&rif_subport->ref_count);
8695 static void mlxsw_sp_rif_subport_put(struct mlxsw_sp_rif *rif)
8697 struct mlxsw_sp_rif_subport *rif_subport;
8699 rif_subport = mlxsw_sp_rif_subport_rif(rif);
8700 if (!refcount_dec_and_test(&rif_subport->ref_count))
8703 mlxsw_sp_rif_destroy(rif);
8706 static int mlxsw_sp_rif_mac_profile_index_alloc(struct mlxsw_sp *mlxsw_sp,
8707 struct mlxsw_sp_rif_mac_profile *profile,
8708 struct netlink_ext_ack *extack)
8710 u8 max_rif_mac_profiles = mlxsw_sp->router->max_rif_mac_profile;
8711 struct mlxsw_sp_router *router = mlxsw_sp->router;
8714 id = idr_alloc(&router->rif_mac_profiles_idr, profile, 0,
8715 max_rif_mac_profiles, GFP_KERNEL);
8723 NL_SET_ERR_MSG_MOD(extack,
8724 "Exceeded number of supported router interface MAC profiles");
8729 static struct mlxsw_sp_rif_mac_profile *
8730 mlxsw_sp_rif_mac_profile_index_free(struct mlxsw_sp *mlxsw_sp, u8 mac_profile)
8732 struct mlxsw_sp_rif_mac_profile *profile;
8734 profile = idr_remove(&mlxsw_sp->router->rif_mac_profiles_idr,
8740 static struct mlxsw_sp_rif_mac_profile *
8741 mlxsw_sp_rif_mac_profile_alloc(const char *mac)
8743 struct mlxsw_sp_rif_mac_profile *profile;
8745 profile = kzalloc(sizeof(*profile), GFP_KERNEL);
8749 ether_addr_copy(profile->mac_prefix, mac);
8750 refcount_set(&profile->ref_count, 1);
8754 static struct mlxsw_sp_rif_mac_profile *
8755 mlxsw_sp_rif_mac_profile_find(const struct mlxsw_sp *mlxsw_sp, const char *mac)
8757 struct mlxsw_sp_router *router = mlxsw_sp->router;
8758 struct mlxsw_sp_rif_mac_profile *profile;
8761 idr_for_each_entry(&router->rif_mac_profiles_idr, profile, id) {
8762 if (ether_addr_equal_masked(profile->mac_prefix, mac,
8763 mlxsw_sp->mac_mask))
8770 static u64 mlxsw_sp_rif_mac_profiles_occ_get(void *priv)
8772 const struct mlxsw_sp *mlxsw_sp = priv;
8774 return atomic_read(&mlxsw_sp->router->rif_mac_profiles_count);
8777 static u64 mlxsw_sp_rifs_occ_get(void *priv)
8779 const struct mlxsw_sp *mlxsw_sp = priv;
8781 return atomic_read(&mlxsw_sp->router->rifs_count);
8784 static struct mlxsw_sp_rif_mac_profile *
8785 mlxsw_sp_rif_mac_profile_create(struct mlxsw_sp *mlxsw_sp, const char *mac,
8786 struct netlink_ext_ack *extack)
8788 struct mlxsw_sp_rif_mac_profile *profile;
8791 profile = mlxsw_sp_rif_mac_profile_alloc(mac);
8793 return ERR_PTR(-ENOMEM);
8795 err = mlxsw_sp_rif_mac_profile_index_alloc(mlxsw_sp, profile, extack);
8797 goto profile_index_alloc_err;
8799 atomic_inc(&mlxsw_sp->router->rif_mac_profiles_count);
8802 profile_index_alloc_err:
8804 return ERR_PTR(err);
8807 static void mlxsw_sp_rif_mac_profile_destroy(struct mlxsw_sp *mlxsw_sp,
8810 struct mlxsw_sp_rif_mac_profile *profile;
8812 atomic_dec(&mlxsw_sp->router->rif_mac_profiles_count);
8813 profile = mlxsw_sp_rif_mac_profile_index_free(mlxsw_sp, mac_profile);
8817 static int mlxsw_sp_rif_mac_profile_get(struct mlxsw_sp *mlxsw_sp,
8818 const char *mac, u8 *p_mac_profile,
8819 struct netlink_ext_ack *extack)
8821 struct mlxsw_sp_rif_mac_profile *profile;
8823 profile = mlxsw_sp_rif_mac_profile_find(mlxsw_sp, mac);
8825 refcount_inc(&profile->ref_count);
8829 profile = mlxsw_sp_rif_mac_profile_create(mlxsw_sp, mac, extack);
8830 if (IS_ERR(profile))
8831 return PTR_ERR(profile);
8834 *p_mac_profile = profile->id;
8838 static void mlxsw_sp_rif_mac_profile_put(struct mlxsw_sp *mlxsw_sp,
8841 struct mlxsw_sp_rif_mac_profile *profile;
8843 profile = idr_find(&mlxsw_sp->router->rif_mac_profiles_idr,
8845 if (WARN_ON(!profile))
8848 if (!refcount_dec_and_test(&profile->ref_count))
8851 mlxsw_sp_rif_mac_profile_destroy(mlxsw_sp, mac_profile);
8854 static bool mlxsw_sp_rif_mac_profile_is_shared(const struct mlxsw_sp_rif *rif)
8856 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
8857 struct mlxsw_sp_rif_mac_profile *profile;
8859 profile = idr_find(&mlxsw_sp->router->rif_mac_profiles_idr,
8860 rif->mac_profile_id);
8861 if (WARN_ON(!profile))
8864 return refcount_read(&profile->ref_count) > 1;
8867 static int mlxsw_sp_rif_mac_profile_edit(struct mlxsw_sp_rif *rif,
8868 const char *new_mac)
8870 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
8871 struct mlxsw_sp_rif_mac_profile *profile;
8873 profile = idr_find(&mlxsw_sp->router->rif_mac_profiles_idr,
8874 rif->mac_profile_id);
8875 if (WARN_ON(!profile))
8878 ether_addr_copy(profile->mac_prefix, new_mac);
8883 mlxsw_sp_rif_mac_profile_replace(struct mlxsw_sp *mlxsw_sp,
8884 struct mlxsw_sp_rif *rif,
8885 const char *new_mac,
8886 struct netlink_ext_ack *extack)
8891 if (!mlxsw_sp_rif_mac_profile_is_shared(rif) &&
8892 !mlxsw_sp_rif_mac_profile_find(mlxsw_sp, new_mac))
8893 return mlxsw_sp_rif_mac_profile_edit(rif, new_mac);
8895 err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, new_mac,
8896 &mac_profile, extack);
8900 mlxsw_sp_rif_mac_profile_put(mlxsw_sp, rif->mac_profile_id);
8901 rif->mac_profile_id = mac_profile;
8906 __mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
8907 struct net_device *l3_dev,
8908 struct netlink_ext_ack *extack)
8910 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
8911 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
8912 struct mlxsw_sp_rif_params params;
8913 u16 vid = mlxsw_sp_port_vlan->vid;
8914 struct mlxsw_sp_rif *rif;
8915 struct mlxsw_sp_fid *fid;
8918 params = (struct mlxsw_sp_rif_params) {
8923 mlxsw_sp_rif_subport_params_init(¶ms, mlxsw_sp_port_vlan);
8924 rif = mlxsw_sp_rif_subport_get(mlxsw_sp, ¶ms, extack);
8926 return PTR_ERR(rif);
8928 /* FID was already created, just take a reference */
8929 fid = rif->ops->fid_get(rif, ¶ms, extack);
8930 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
8932 goto err_fid_port_vid_map;
8934 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
8936 goto err_port_vid_learning_set;
8938 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
8939 BR_STATE_FORWARDING);
8941 goto err_port_vid_stp_set;
8943 mlxsw_sp_port_vlan->fid = fid;
8947 err_port_vid_stp_set:
8948 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
8949 err_port_vid_learning_set:
8950 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
8951 err_fid_port_vid_map:
8952 mlxsw_sp_fid_put(fid);
8953 mlxsw_sp_rif_subport_put(rif);
8958 __mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
8960 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
8961 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
8962 struct mlxsw_sp_rif *rif = mlxsw_sp_fid_rif(fid);
8963 u16 vid = mlxsw_sp_port_vlan->vid;
8965 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
8968 mlxsw_sp_port_vlan->fid = NULL;
8969 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
8970 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
8971 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
8972 mlxsw_sp_fid_put(fid);
8973 mlxsw_sp_rif_subport_put(rif);
8977 mlxsw_sp_port_vlan_router_join_existing(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
8978 struct net_device *l3_dev,
8979 struct netlink_ext_ack *extack)
8981 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port_vlan->mlxsw_sp_port->mlxsw_sp;
8983 lockdep_assert_held(&mlxsw_sp->router->lock);
8985 if (!mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev))
8988 return __mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan, l3_dev,
8993 mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
8995 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port_vlan->mlxsw_sp_port->mlxsw_sp;
8997 mutex_lock(&mlxsw_sp->router->lock);
8998 __mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
8999 mutex_unlock(&mlxsw_sp->router->lock);
9002 static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
9003 struct net_device *port_dev,
9004 unsigned long event, u16 vid,
9005 struct netlink_ext_ack *extack)
9007 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
9008 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
9010 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
9011 if (WARN_ON(!mlxsw_sp_port_vlan))
9016 return __mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
9019 __mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
9026 static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
9027 unsigned long event, bool nomaster,
9028 struct netlink_ext_ack *extack)
9030 if (!nomaster && (netif_is_any_bridge_port(port_dev) ||
9031 netif_is_lag_port(port_dev)))
9034 return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event,
9035 MLXSW_SP_DEFAULT_VID, extack);
9038 static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
9039 struct net_device *lag_dev,
9040 unsigned long event, u16 vid,
9041 struct netlink_ext_ack *extack)
9043 struct net_device *port_dev;
9044 struct list_head *iter;
9047 netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
9048 if (mlxsw_sp_port_dev_check(port_dev)) {
9049 err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
9061 static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
9062 unsigned long event, bool nomaster,
9063 struct netlink_ext_ack *extack)
9065 if (!nomaster && netif_is_bridge_port(lag_dev))
9068 return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event,
9069 MLXSW_SP_DEFAULT_VID, extack);
9072 static int mlxsw_sp_inetaddr_bridge_event(struct mlxsw_sp *mlxsw_sp,
9073 struct net_device *l3_dev,
9075 unsigned long event,
9076 struct netlink_ext_ack *extack)
9078 struct mlxsw_sp_rif_params params = {
9081 struct mlxsw_sp_rif *rif;
9086 if (netif_is_bridge_master(l3_dev) && br_vlan_enabled(l3_dev)) {
9089 br_vlan_get_proto(l3_dev, &proto);
9090 if (proto == ETH_P_8021AD) {
9091 NL_SET_ERR_MSG_MOD(extack, "Adding an IP address to 802.1ad bridge is not supported");
9094 err = br_vlan_get_pvid(l3_dev, ¶ms.vid);
9099 } else if (is_vlan_dev(l3_dev)) {
9100 params.vid = vlan_dev_vlan_id(l3_dev);
9102 /* If the VID matches PVID of the bridge below, the
9103 * bridge owns the RIF for this VLAN. Don't do anything.
9105 if ((int)params.vid == lower_pvid)
9109 rif = mlxsw_sp_rif_create(mlxsw_sp, ¶ms, extack);
9111 return PTR_ERR(rif);
9114 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
9115 mlxsw_sp_rif_destroy(rif);
9122 static int mlxsw_sp_inetaddr_vlan_event(struct mlxsw_sp *mlxsw_sp,
9123 struct net_device *vlan_dev,
9124 unsigned long event, bool nomaster,
9125 struct netlink_ext_ack *extack)
9127 struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
9128 u16 vid = vlan_dev_vlan_id(vlan_dev);
9132 if (!nomaster && netif_is_bridge_port(vlan_dev))
9135 if (mlxsw_sp_port_dev_check(real_dev)) {
9136 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
9137 event, vid, extack);
9138 } else if (netif_is_lag_master(real_dev)) {
9139 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
9141 } else if (netif_is_bridge_master(real_dev) &&
9142 br_vlan_enabled(real_dev)) {
9143 err = br_vlan_get_pvid(real_dev, &lower_pvid);
9146 return mlxsw_sp_inetaddr_bridge_event(mlxsw_sp, vlan_dev,
9154 static bool mlxsw_sp_rif_macvlan_is_vrrp4(const u8 *mac)
9156 u8 vrrp4[ETH_ALEN] = { 0x00, 0x00, 0x5e, 0x00, 0x01, 0x00 };
9157 u8 mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
9159 return ether_addr_equal_masked(mac, vrrp4, mask);
9162 static bool mlxsw_sp_rif_macvlan_is_vrrp6(const u8 *mac)
9164 u8 vrrp6[ETH_ALEN] = { 0x00, 0x00, 0x5e, 0x00, 0x02, 0x00 };
9165 u8 mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
9167 return ether_addr_equal_masked(mac, vrrp6, mask);
9170 static int mlxsw_sp_rif_vrrp_op(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
9171 const u8 *mac, bool adding)
9173 char ritr_pl[MLXSW_REG_RITR_LEN];
9174 u8 vrrp_id = adding ? mac[5] : 0;
9177 if (!mlxsw_sp_rif_macvlan_is_vrrp4(mac) &&
9178 !mlxsw_sp_rif_macvlan_is_vrrp6(mac))
9181 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
9182 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9186 if (mlxsw_sp_rif_macvlan_is_vrrp4(mac))
9187 mlxsw_reg_ritr_if_vrrp_id_ipv4_set(ritr_pl, vrrp_id);
9189 mlxsw_reg_ritr_if_vrrp_id_ipv6_set(ritr_pl, vrrp_id);
9191 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9194 static int mlxsw_sp_rif_macvlan_add(struct mlxsw_sp *mlxsw_sp,
9195 const struct net_device *macvlan_dev,
9196 struct netlink_ext_ack *extack)
9198 struct macvlan_dev *vlan = netdev_priv(macvlan_dev);
9199 struct mlxsw_sp_rif *rif;
9202 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, vlan->lowerdev);
9206 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
9207 mlxsw_sp_fid_index(rif->fid), true);
9211 err = mlxsw_sp_rif_vrrp_op(mlxsw_sp, rif->rif_index,
9212 macvlan_dev->dev_addr, true);
9214 goto err_rif_vrrp_add;
9216 /* Make sure the bridge driver does not have this MAC pointing at
9219 if (rif->ops->fdb_del)
9220 rif->ops->fdb_del(rif, macvlan_dev->dev_addr);
9225 mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
9226 mlxsw_sp_fid_index(rif->fid), false);
9230 static void __mlxsw_sp_rif_macvlan_del(struct mlxsw_sp *mlxsw_sp,
9231 const struct net_device *macvlan_dev)
9233 struct macvlan_dev *vlan = netdev_priv(macvlan_dev);
9234 struct mlxsw_sp_rif *rif;
9236 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, vlan->lowerdev);
9237 /* If we do not have a RIF, then we already took care of
9238 * removing the macvlan's MAC during RIF deletion.
9242 mlxsw_sp_rif_vrrp_op(mlxsw_sp, rif->rif_index, macvlan_dev->dev_addr,
9244 mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
9245 mlxsw_sp_fid_index(rif->fid), false);
9248 void mlxsw_sp_rif_macvlan_del(struct mlxsw_sp *mlxsw_sp,
9249 const struct net_device *macvlan_dev)
9251 mutex_lock(&mlxsw_sp->router->lock);
9252 __mlxsw_sp_rif_macvlan_del(mlxsw_sp, macvlan_dev);
9253 mutex_unlock(&mlxsw_sp->router->lock);
9256 static int mlxsw_sp_inetaddr_macvlan_event(struct mlxsw_sp *mlxsw_sp,
9257 struct net_device *macvlan_dev,
9258 unsigned long event,
9259 struct netlink_ext_ack *extack)
9263 return mlxsw_sp_rif_macvlan_add(mlxsw_sp, macvlan_dev, extack);
9265 __mlxsw_sp_rif_macvlan_del(mlxsw_sp, macvlan_dev);
9272 static int __mlxsw_sp_inetaddr_event(struct mlxsw_sp *mlxsw_sp,
9273 struct net_device *dev,
9274 unsigned long event, bool nomaster,
9275 struct netlink_ext_ack *extack)
9277 if (mlxsw_sp_port_dev_check(dev))
9278 return mlxsw_sp_inetaddr_port_event(dev, event, nomaster,
9280 else if (netif_is_lag_master(dev))
9281 return mlxsw_sp_inetaddr_lag_event(dev, event, nomaster,
9283 else if (netif_is_bridge_master(dev))
9284 return mlxsw_sp_inetaddr_bridge_event(mlxsw_sp, dev, -1, event,
9286 else if (is_vlan_dev(dev))
9287 return mlxsw_sp_inetaddr_vlan_event(mlxsw_sp, dev, event,
9289 else if (netif_is_macvlan(dev))
9290 return mlxsw_sp_inetaddr_macvlan_event(mlxsw_sp, dev, event,
9296 static int mlxsw_sp_inetaddr_event(struct notifier_block *nb,
9297 unsigned long event, void *ptr)
9299 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
9300 struct net_device *dev = ifa->ifa_dev->dev;
9301 struct mlxsw_sp_router *router;
9302 struct mlxsw_sp_rif *rif;
9305 /* NETDEV_UP event is handled by mlxsw_sp_inetaddr_valid_event */
9306 if (event == NETDEV_UP)
9309 router = container_of(nb, struct mlxsw_sp_router, inetaddr_nb);
9310 mutex_lock(&router->lock);
9311 rif = mlxsw_sp_rif_find_by_dev(router->mlxsw_sp, dev);
9312 if (!mlxsw_sp_rif_should_config(rif, dev, event))
9315 err = __mlxsw_sp_inetaddr_event(router->mlxsw_sp, dev, event, false,
9318 mutex_unlock(&router->lock);
9319 return notifier_from_errno(err);
9322 static int mlxsw_sp_inetaddr_valid_event(struct notifier_block *unused,
9323 unsigned long event, void *ptr)
9325 struct in_validator_info *ivi = (struct in_validator_info *) ptr;
9326 struct net_device *dev = ivi->ivi_dev->dev;
9327 struct mlxsw_sp *mlxsw_sp;
9328 struct mlxsw_sp_rif *rif;
9331 mlxsw_sp = mlxsw_sp_lower_get(dev);
9335 mutex_lock(&mlxsw_sp->router->lock);
9336 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9337 if (!mlxsw_sp_rif_should_config(rif, dev, event))
9340 err = __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, false,
9343 mutex_unlock(&mlxsw_sp->router->lock);
9344 return notifier_from_errno(err);
9347 struct mlxsw_sp_inet6addr_event_work {
9348 struct work_struct work;
9349 struct mlxsw_sp *mlxsw_sp;
9350 struct net_device *dev;
9351 netdevice_tracker dev_tracker;
9352 unsigned long event;
9355 static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
9357 struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
9358 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
9359 struct mlxsw_sp *mlxsw_sp = inet6addr_work->mlxsw_sp;
9360 struct net_device *dev = inet6addr_work->dev;
9361 unsigned long event = inet6addr_work->event;
9362 struct mlxsw_sp_rif *rif;
9365 mutex_lock(&mlxsw_sp->router->lock);
9367 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9368 if (!mlxsw_sp_rif_should_config(rif, dev, event))
9371 __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, false, NULL);
9373 mutex_unlock(&mlxsw_sp->router->lock);
9375 netdev_put(dev, &inet6addr_work->dev_tracker);
9376 kfree(inet6addr_work);
9379 /* Called with rcu_read_lock() */
9380 static int mlxsw_sp_inet6addr_event(struct notifier_block *nb,
9381 unsigned long event, void *ptr)
9383 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
9384 struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
9385 struct net_device *dev = if6->idev->dev;
9386 struct mlxsw_sp_router *router;
9388 /* NETDEV_UP event is handled by mlxsw_sp_inet6addr_valid_event */
9389 if (event == NETDEV_UP)
9392 inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
9393 if (!inet6addr_work)
9396 router = container_of(nb, struct mlxsw_sp_router, inet6addr_nb);
9397 INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
9398 inet6addr_work->mlxsw_sp = router->mlxsw_sp;
9399 inet6addr_work->dev = dev;
9400 inet6addr_work->event = event;
9401 netdev_hold(dev, &inet6addr_work->dev_tracker, GFP_ATOMIC);
9402 mlxsw_core_schedule_work(&inet6addr_work->work);
9407 static int mlxsw_sp_inet6addr_valid_event(struct notifier_block *unused,
9408 unsigned long event, void *ptr)
9410 struct in6_validator_info *i6vi = (struct in6_validator_info *) ptr;
9411 struct net_device *dev = i6vi->i6vi_dev->dev;
9412 struct mlxsw_sp *mlxsw_sp;
9413 struct mlxsw_sp_rif *rif;
9416 mlxsw_sp = mlxsw_sp_lower_get(dev);
9420 mutex_lock(&mlxsw_sp->router->lock);
9421 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9422 if (!mlxsw_sp_rif_should_config(rif, dev, event))
9425 err = __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, false,
9428 mutex_unlock(&mlxsw_sp->router->lock);
9429 return notifier_from_errno(err);
9432 static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
9433 const char *mac, int mtu, u8 mac_profile)
9435 char ritr_pl[MLXSW_REG_RITR_LEN];
9438 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
9439 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9443 mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
9444 mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
9445 mlxsw_reg_ritr_if_mac_profile_id_set(ritr_pl, mac_profile);
9446 mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
9447 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9451 mlxsw_sp_router_port_change_event(struct mlxsw_sp *mlxsw_sp,
9452 struct mlxsw_sp_rif *rif,
9453 struct netlink_ext_ack *extack)
9455 struct net_device *dev = mlxsw_sp_rif_dev(rif);
9460 fid_index = mlxsw_sp_fid_index(rif->fid);
9462 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
9466 old_mac_profile = rif->mac_profile_id;
9467 err = mlxsw_sp_rif_mac_profile_replace(mlxsw_sp, rif, dev->dev_addr,
9470 goto err_rif_mac_profile_replace;
9472 err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
9473 dev->mtu, rif->mac_profile_id);
9477 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
9479 goto err_rif_fdb_op;
9481 if (rif->mtu != dev->mtu) {
9482 struct mlxsw_sp_vr *vr;
9485 /* The RIF is relevant only to its mr_table instance, as unlike
9486 * unicast routing, in multicast routing a RIF cannot be shared
9487 * between several multicast routing tables.
9489 vr = &mlxsw_sp->router->vrs[rif->vr_id];
9490 for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++)
9491 mlxsw_sp_mr_rif_mtu_update(vr->mr_table[i],
9495 ether_addr_copy(rif->addr, dev->dev_addr);
9496 rif->mtu = dev->mtu;
9498 netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
9503 mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu,
9506 mlxsw_sp_rif_mac_profile_replace(mlxsw_sp, rif, rif->addr, extack);
9507 err_rif_mac_profile_replace:
9508 mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
9512 static int mlxsw_sp_router_port_pre_changeaddr_event(struct mlxsw_sp_rif *rif,
9513 struct netdev_notifier_pre_changeaddr_info *info)
9515 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
9516 struct mlxsw_sp_rif_mac_profile *profile;
9517 struct netlink_ext_ack *extack;
9518 u8 max_rif_mac_profiles;
9521 extack = netdev_notifier_info_to_extack(&info->info);
9523 profile = mlxsw_sp_rif_mac_profile_find(mlxsw_sp, info->dev_addr);
9527 max_rif_mac_profiles = mlxsw_sp->router->max_rif_mac_profile;
9528 occ = mlxsw_sp_rif_mac_profiles_occ_get(mlxsw_sp);
9529 if (occ < max_rif_mac_profiles)
9532 if (!mlxsw_sp_rif_mac_profile_is_shared(rif))
9535 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interface MAC profiles");
9539 static bool mlxsw_sp_router_netdevice_interesting(struct mlxsw_sp *mlxsw_sp,
9540 struct net_device *dev)
9542 struct vlan_dev_priv *vlan;
9544 if (netif_is_lag_master(dev) ||
9545 netif_is_bridge_master(dev) ||
9546 mlxsw_sp_port_dev_check(dev) ||
9547 mlxsw_sp_netdev_is_ipip_ol(mlxsw_sp, dev) ||
9548 netif_is_l3_master(dev))
9551 if (!is_vlan_dev(dev))
9554 vlan = vlan_dev_priv(dev);
9555 return netif_is_lag_master(vlan->real_dev) ||
9556 netif_is_bridge_master(vlan->real_dev) ||
9557 mlxsw_sp_port_dev_check(vlan->real_dev);
9560 static struct mlxsw_sp_crif *
9561 mlxsw_sp_crif_register(struct mlxsw_sp_router *router, struct net_device *dev)
9563 struct mlxsw_sp_crif *crif;
9566 if (WARN_ON(mlxsw_sp_crif_lookup(router, dev)))
9569 crif = mlxsw_sp_crif_alloc(dev);
9571 return ERR_PTR(-ENOMEM);
9573 err = mlxsw_sp_crif_insert(router, crif);
9575 goto err_netdev_insert;
9580 mlxsw_sp_crif_free(crif);
9581 return ERR_PTR(err);
9584 static void mlxsw_sp_crif_unregister(struct mlxsw_sp_router *router,
9585 struct mlxsw_sp_crif *crif)
9587 struct mlxsw_sp_nexthop *nh, *tmp;
9589 mlxsw_sp_crif_remove(router, crif);
9591 list_for_each_entry_safe(nh, tmp, &crif->nexthop_list, crif_list_node)
9592 mlxsw_sp_nexthop_type_fini(router->mlxsw_sp, nh);
9595 crif->can_destroy = true;
9597 mlxsw_sp_crif_free(crif);
9600 static int mlxsw_sp_netdevice_register(struct mlxsw_sp_router *router,
9601 struct net_device *dev)
9603 struct mlxsw_sp_crif *crif;
9605 if (!mlxsw_sp_router_netdevice_interesting(router->mlxsw_sp, dev))
9608 crif = mlxsw_sp_crif_register(router, dev);
9609 return PTR_ERR_OR_ZERO(crif);
9612 static void mlxsw_sp_netdevice_unregister(struct mlxsw_sp_router *router,
9613 struct net_device *dev)
9615 struct mlxsw_sp_crif *crif;
9617 if (!mlxsw_sp_router_netdevice_interesting(router->mlxsw_sp, dev))
9620 /* netdev_run_todo(), by way of netdev_wait_allrefs_any(), rebroadcasts
9621 * the NETDEV_UNREGISTER message, so we can get here twice. If that's
9622 * what happened, the netdevice state is NETREG_UNREGISTERED. In that
9623 * case, we expect to have collected the CRIF already, and warn if it
9624 * still exists. Otherwise we expect the CRIF to exist.
9626 crif = mlxsw_sp_crif_lookup(router, dev);
9627 if (dev->reg_state == NETREG_UNREGISTERED) {
9634 mlxsw_sp_crif_unregister(router, crif);
9637 static bool mlxsw_sp_is_offload_xstats_event(unsigned long event)
9640 case NETDEV_OFFLOAD_XSTATS_ENABLE:
9641 case NETDEV_OFFLOAD_XSTATS_DISABLE:
9642 case NETDEV_OFFLOAD_XSTATS_REPORT_USED:
9643 case NETDEV_OFFLOAD_XSTATS_REPORT_DELTA:
9651 mlxsw_sp_router_port_offload_xstats_cmd(struct mlxsw_sp_rif *rif,
9652 unsigned long event,
9653 struct netdev_notifier_offload_xstats_info *info)
9655 switch (info->type) {
9656 case NETDEV_OFFLOAD_XSTATS_TYPE_L3:
9663 case NETDEV_OFFLOAD_XSTATS_ENABLE:
9664 return mlxsw_sp_router_port_l3_stats_enable(rif);
9665 case NETDEV_OFFLOAD_XSTATS_DISABLE:
9666 mlxsw_sp_router_port_l3_stats_disable(rif);
9668 case NETDEV_OFFLOAD_XSTATS_REPORT_USED:
9669 mlxsw_sp_router_port_l3_stats_report_used(rif, info);
9671 case NETDEV_OFFLOAD_XSTATS_REPORT_DELTA:
9672 return mlxsw_sp_router_port_l3_stats_report_delta(rif, info);
9680 mlxsw_sp_netdevice_offload_xstats_cmd(struct mlxsw_sp *mlxsw_sp,
9681 struct net_device *dev,
9682 unsigned long event,
9683 struct netdev_notifier_offload_xstats_info *info)
9685 struct mlxsw_sp_rif *rif;
9687 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9691 return mlxsw_sp_router_port_offload_xstats_cmd(rif, event, info);
9694 static bool mlxsw_sp_is_router_event(unsigned long event)
9697 case NETDEV_PRE_CHANGEADDR:
9698 case NETDEV_CHANGEADDR:
9699 case NETDEV_CHANGEMTU:
9706 static int mlxsw_sp_netdevice_router_port_event(struct net_device *dev,
9707 unsigned long event, void *ptr)
9709 struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(ptr);
9710 struct mlxsw_sp *mlxsw_sp;
9711 struct mlxsw_sp_rif *rif;
9713 mlxsw_sp = mlxsw_sp_lower_get(dev);
9717 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9722 case NETDEV_CHANGEMTU:
9723 case NETDEV_CHANGEADDR:
9724 return mlxsw_sp_router_port_change_event(mlxsw_sp, rif, extack);
9725 case NETDEV_PRE_CHANGEADDR:
9726 return mlxsw_sp_router_port_pre_changeaddr_event(rif, ptr);
9735 static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
9736 struct net_device *l3_dev,
9737 struct netlink_ext_ack *extack)
9739 struct mlxsw_sp_rif *rif;
9741 /* If netdev is already associated with a RIF, then we need to
9742 * destroy it and create a new one with the new virtual router ID.
9744 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
9746 __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_DOWN, false,
9749 return __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_UP, false,
9753 static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
9754 struct net_device *l3_dev)
9756 struct mlxsw_sp_rif *rif;
9758 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
9761 __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_DOWN, false, NULL);
9764 static bool mlxsw_sp_is_vrf_event(unsigned long event, void *ptr)
9766 struct netdev_notifier_changeupper_info *info = ptr;
9768 if (event != NETDEV_PRECHANGEUPPER && event != NETDEV_CHANGEUPPER)
9770 return netif_is_l3_master(info->upper_dev);
9774 mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
9775 struct netdev_notifier_changeupper_info *info)
9777 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
9780 /* We do not create a RIF for a macvlan, but only use it to
9781 * direct more MAC addresses to the router.
9783 if (!mlxsw_sp || netif_is_macvlan(l3_dev))
9787 case NETDEV_PRECHANGEUPPER:
9789 case NETDEV_CHANGEUPPER:
9790 if (info->linking) {
9791 struct netlink_ext_ack *extack;
9793 extack = netdev_notifier_info_to_extack(&info->info);
9794 err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev, extack);
9796 mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
9804 struct mlxsw_sp_router_replay_inetaddr_up {
9805 struct mlxsw_sp *mlxsw_sp;
9806 struct netlink_ext_ack *extack;
9811 static int mlxsw_sp_router_replay_inetaddr_up(struct net_device *dev,
9812 struct netdev_nested_priv *priv)
9814 struct mlxsw_sp_router_replay_inetaddr_up *ctx = priv->data;
9815 bool nomaster = ctx->deslavement;
9816 struct mlxsw_sp_crif *crif;
9819 if (mlxsw_sp_dev_addr_list_empty(dev))
9822 crif = mlxsw_sp_crif_lookup(ctx->mlxsw_sp->router, dev);
9823 if (!crif || crif->rif)
9826 if (!mlxsw_sp_rif_should_config(crif->rif, dev, NETDEV_UP))
9829 err = __mlxsw_sp_inetaddr_event(ctx->mlxsw_sp, dev, NETDEV_UP,
9830 nomaster, ctx->extack);
9838 static int mlxsw_sp_router_unreplay_inetaddr_up(struct net_device *dev,
9839 struct netdev_nested_priv *priv)
9841 struct mlxsw_sp_router_replay_inetaddr_up *ctx = priv->data;
9842 bool nomaster = ctx->deslavement;
9843 struct mlxsw_sp_crif *crif;
9848 if (mlxsw_sp_dev_addr_list_empty(dev))
9851 crif = mlxsw_sp_crif_lookup(ctx->mlxsw_sp->router, dev);
9852 if (!crif || !crif->rif)
9855 /* We are rolling back NETDEV_UP, so ask for that. */
9856 if (!mlxsw_sp_rif_should_config(crif->rif, dev, NETDEV_UP))
9859 __mlxsw_sp_inetaddr_event(ctx->mlxsw_sp, dev, NETDEV_DOWN, nomaster,
9866 int mlxsw_sp_netdevice_enslavement_replay(struct mlxsw_sp *mlxsw_sp,
9867 struct net_device *upper_dev,
9868 struct netlink_ext_ack *extack)
9870 struct mlxsw_sp_router_replay_inetaddr_up ctx = {
9871 .mlxsw_sp = mlxsw_sp,
9873 .deslavement = false,
9875 struct netdev_nested_priv priv = {
9880 err = mlxsw_sp_router_replay_inetaddr_up(upper_dev, &priv);
9884 err = netdev_walk_all_upper_dev_rcu(upper_dev,
9885 mlxsw_sp_router_replay_inetaddr_up,
9893 netdev_walk_all_upper_dev_rcu(upper_dev,
9894 mlxsw_sp_router_unreplay_inetaddr_up,
9896 mlxsw_sp_router_unreplay_inetaddr_up(upper_dev, &priv);
9900 void mlxsw_sp_netdevice_deslavement_replay(struct mlxsw_sp *mlxsw_sp,
9901 struct net_device *dev)
9903 struct mlxsw_sp_router_replay_inetaddr_up ctx = {
9904 .mlxsw_sp = mlxsw_sp,
9905 .deslavement = true,
9907 struct netdev_nested_priv priv = {
9911 mlxsw_sp_router_replay_inetaddr_up(dev, &priv);
9915 mlxsw_sp_port_vid_router_join_existing(struct mlxsw_sp_port *mlxsw_sp_port,
9916 u16 vid, struct net_device *dev,
9917 struct netlink_ext_ack *extack)
9919 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
9921 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port,
9923 if (WARN_ON(!mlxsw_sp_port_vlan))
9926 return mlxsw_sp_port_vlan_router_join_existing(mlxsw_sp_port_vlan,
9931 mlxsw_sp_port_vid_router_leave(struct mlxsw_sp_port *mlxsw_sp_port, u16 vid,
9932 struct net_device *dev)
9934 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
9936 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port,
9938 if (WARN_ON(!mlxsw_sp_port_vlan))
9941 __mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
9944 static int __mlxsw_sp_router_port_join_lag(struct mlxsw_sp_port *mlxsw_sp_port,
9945 struct net_device *lag_dev,
9946 struct netlink_ext_ack *extack)
9948 u16 default_vid = MLXSW_SP_DEFAULT_VID;
9949 struct net_device *upper_dev;
9950 struct list_head *iter;
9955 err = mlxsw_sp_port_vid_router_join_existing(mlxsw_sp_port, default_vid,
9960 netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {
9961 if (!is_vlan_dev(upper_dev))
9964 vid = vlan_dev_vlan_id(upper_dev);
9965 err = mlxsw_sp_port_vid_router_join_existing(mlxsw_sp_port, vid,
9968 goto err_router_join_dev;
9975 err_router_join_dev:
9976 netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {
9977 if (!is_vlan_dev(upper_dev))
9982 vid = vlan_dev_vlan_id(upper_dev);
9983 mlxsw_sp_port_vid_router_leave(mlxsw_sp_port, vid, upper_dev);
9986 mlxsw_sp_port_vid_router_leave(mlxsw_sp_port, default_vid, lag_dev);
9991 __mlxsw_sp_router_port_leave_lag(struct mlxsw_sp_port *mlxsw_sp_port,
9992 struct net_device *lag_dev)
9994 u16 default_vid = MLXSW_SP_DEFAULT_VID;
9995 struct net_device *upper_dev;
9996 struct list_head *iter;
9999 netdev_for_each_upper_dev_rcu(lag_dev, upper_dev, iter) {
10000 if (!is_vlan_dev(upper_dev))
10003 vid = vlan_dev_vlan_id(upper_dev);
10004 mlxsw_sp_port_vid_router_leave(mlxsw_sp_port, vid, upper_dev);
10007 mlxsw_sp_port_vid_router_leave(mlxsw_sp_port, default_vid, lag_dev);
10010 int mlxsw_sp_router_port_join_lag(struct mlxsw_sp_port *mlxsw_sp_port,
10011 struct net_device *lag_dev,
10012 struct netlink_ext_ack *extack)
10016 mutex_lock(&mlxsw_sp_port->mlxsw_sp->router->lock);
10017 err = __mlxsw_sp_router_port_join_lag(mlxsw_sp_port, lag_dev, extack);
10018 mutex_unlock(&mlxsw_sp_port->mlxsw_sp->router->lock);
10023 void mlxsw_sp_router_port_leave_lag(struct mlxsw_sp_port *mlxsw_sp_port,
10024 struct net_device *lag_dev)
10026 mutex_lock(&mlxsw_sp_port->mlxsw_sp->router->lock);
10027 __mlxsw_sp_router_port_leave_lag(mlxsw_sp_port, lag_dev);
10028 mutex_unlock(&mlxsw_sp_port->mlxsw_sp->router->lock);
10031 static int mlxsw_sp_router_netdevice_event(struct notifier_block *nb,
10032 unsigned long event, void *ptr)
10034 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
10035 struct mlxsw_sp_router *router;
10036 struct mlxsw_sp *mlxsw_sp;
10039 router = container_of(nb, struct mlxsw_sp_router, netdevice_nb);
10040 mlxsw_sp = router->mlxsw_sp;
10042 mutex_lock(&mlxsw_sp->router->lock);
10044 if (event == NETDEV_REGISTER) {
10045 err = mlxsw_sp_netdevice_register(router, dev);
10047 /* No need to roll this back, UNREGISTER will collect it
10053 if (mlxsw_sp_is_offload_xstats_event(event))
10054 err = mlxsw_sp_netdevice_offload_xstats_cmd(mlxsw_sp, dev,
10056 else if (mlxsw_sp_netdev_is_ipip_ol(mlxsw_sp, dev))
10057 err = mlxsw_sp_netdevice_ipip_ol_event(mlxsw_sp, dev,
10059 else if (mlxsw_sp_netdev_is_ipip_ul(mlxsw_sp, dev))
10060 err = mlxsw_sp_netdevice_ipip_ul_event(mlxsw_sp, dev,
10062 else if (mlxsw_sp_is_router_event(event))
10063 err = mlxsw_sp_netdevice_router_port_event(dev, event, ptr);
10064 else if (mlxsw_sp_is_vrf_event(event, ptr))
10065 err = mlxsw_sp_netdevice_vrf_event(dev, event, ptr);
10067 if (event == NETDEV_UNREGISTER)
10068 mlxsw_sp_netdevice_unregister(router, dev);
10071 mutex_unlock(&mlxsw_sp->router->lock);
10073 return notifier_from_errno(err);
10076 struct mlxsw_sp_macvlan_replay {
10077 struct mlxsw_sp *mlxsw_sp;
10078 struct netlink_ext_ack *extack;
10081 static int mlxsw_sp_macvlan_replay_upper(struct net_device *dev,
10082 struct netdev_nested_priv *priv)
10084 const struct mlxsw_sp_macvlan_replay *rms = priv->data;
10085 struct netlink_ext_ack *extack = rms->extack;
10086 struct mlxsw_sp *mlxsw_sp = rms->mlxsw_sp;
10088 if (!netif_is_macvlan(dev))
10091 return mlxsw_sp_rif_macvlan_add(mlxsw_sp, dev, extack);
10094 static int mlxsw_sp_macvlan_replay(struct mlxsw_sp_rif *rif,
10095 struct netlink_ext_ack *extack)
10097 struct mlxsw_sp_macvlan_replay rms = {
10098 .mlxsw_sp = rif->mlxsw_sp,
10101 struct netdev_nested_priv priv = {
10105 return netdev_walk_all_upper_dev_rcu(mlxsw_sp_rif_dev(rif),
10106 mlxsw_sp_macvlan_replay_upper,
10110 static int __mlxsw_sp_rif_macvlan_flush(struct net_device *dev,
10111 struct netdev_nested_priv *priv)
10113 struct mlxsw_sp_rif *rif = (struct mlxsw_sp_rif *)priv->data;
10115 if (!netif_is_macvlan(dev))
10118 return mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10119 mlxsw_sp_fid_index(rif->fid), false);
10122 static int mlxsw_sp_rif_macvlan_flush(struct mlxsw_sp_rif *rif)
10124 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10125 struct netdev_nested_priv priv = {
10126 .data = (void *)rif,
10129 if (!netif_is_macvlan_port(dev))
10132 return netdev_walk_all_upper_dev_rcu(dev,
10133 __mlxsw_sp_rif_macvlan_flush, &priv);
10136 static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
10137 const struct mlxsw_sp_rif_params *params)
10139 struct mlxsw_sp_rif_subport *rif_subport;
10141 rif_subport = mlxsw_sp_rif_subport_rif(rif);
10142 refcount_set(&rif_subport->ref_count, 1);
10143 rif_subport->vid = params->vid;
10144 rif_subport->lag = params->lag;
10146 rif_subport->lag_id = params->lag_id;
10148 rif_subport->system_port = params->system_port;
10151 static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
10153 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10154 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10155 struct mlxsw_sp_rif_subport *rif_subport;
10156 char ritr_pl[MLXSW_REG_RITR_LEN];
10159 rif_subport = mlxsw_sp_rif_subport_rif(rif);
10160 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
10161 rif->rif_index, rif->vr_id, dev->mtu);
10162 mlxsw_reg_ritr_mac_pack(ritr_pl, dev->dev_addr);
10163 mlxsw_reg_ritr_if_mac_profile_id_set(ritr_pl, rif->mac_profile_id);
10164 efid = mlxsw_sp_fid_index(rif->fid);
10165 mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
10166 rif_subport->lag ? rif_subport->lag_id :
10167 rif_subport->system_port,
10169 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
10172 static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif,
10173 struct netlink_ext_ack *extack)
10175 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10179 err = mlxsw_sp_rif_mac_profile_get(rif->mlxsw_sp, rif->addr,
10180 &mac_profile, extack);
10183 rif->mac_profile_id = mac_profile;
10185 err = mlxsw_sp_rif_subport_op(rif, true);
10187 goto err_rif_subport_op;
10189 err = mlxsw_sp_macvlan_replay(rif, extack);
10191 goto err_macvlan_replay;
10193 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10194 mlxsw_sp_fid_index(rif->fid), true);
10196 goto err_rif_fdb_op;
10198 err = mlxsw_sp_fid_rif_set(rif->fid, rif);
10200 goto err_fid_rif_set;
10205 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10206 mlxsw_sp_fid_index(rif->fid), false);
10208 mlxsw_sp_rif_macvlan_flush(rif);
10209 err_macvlan_replay:
10210 mlxsw_sp_rif_subport_op(rif, false);
10211 err_rif_subport_op:
10212 mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, mac_profile);
10216 static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
10218 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10219 struct mlxsw_sp_fid *fid = rif->fid;
10221 mlxsw_sp_fid_rif_unset(fid);
10222 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10223 mlxsw_sp_fid_index(fid), false);
10224 mlxsw_sp_rif_macvlan_flush(rif);
10225 mlxsw_sp_rif_subport_op(rif, false);
10226 mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, rif->mac_profile_id);
10229 static struct mlxsw_sp_fid *
10230 mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif,
10231 const struct mlxsw_sp_rif_params *params,
10232 struct netlink_ext_ack *extack)
10234 return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
10237 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
10238 .type = MLXSW_SP_RIF_TYPE_SUBPORT,
10239 .rif_size = sizeof(struct mlxsw_sp_rif_subport),
10240 .setup = mlxsw_sp_rif_subport_setup,
10241 .configure = mlxsw_sp_rif_subport_configure,
10242 .deconfigure = mlxsw_sp_rif_subport_deconfigure,
10243 .fid_get = mlxsw_sp_rif_subport_fid_get,
10246 static int mlxsw_sp_rif_fid_op(struct mlxsw_sp_rif *rif, u16 fid, bool enable)
10248 enum mlxsw_reg_ritr_if_type type = MLXSW_REG_RITR_FID_IF;
10249 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10250 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10251 char ritr_pl[MLXSW_REG_RITR_LEN];
10253 mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
10255 mlxsw_reg_ritr_mac_pack(ritr_pl, dev->dev_addr);
10256 mlxsw_reg_ritr_if_mac_profile_id_set(ritr_pl, rif->mac_profile_id);
10257 mlxsw_reg_ritr_fid_if_fid_set(ritr_pl, fid);
10259 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
10262 u16 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
10264 return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
10267 static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif,
10268 struct netlink_ext_ack *extack)
10270 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10271 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10272 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
10276 err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, rif->addr,
10277 &mac_profile, extack);
10280 rif->mac_profile_id = mac_profile;
10282 err = mlxsw_sp_rif_fid_op(rif, fid_index, true);
10284 goto err_rif_fid_op;
10286 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10287 mlxsw_sp_router_port(mlxsw_sp), true);
10289 goto err_fid_mc_flood_set;
10291 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10292 mlxsw_sp_router_port(mlxsw_sp), true);
10294 goto err_fid_bc_flood_set;
10296 err = mlxsw_sp_macvlan_replay(rif, extack);
10298 goto err_macvlan_replay;
10300 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10301 mlxsw_sp_fid_index(rif->fid), true);
10303 goto err_rif_fdb_op;
10305 err = mlxsw_sp_fid_rif_set(rif->fid, rif);
10307 goto err_fid_rif_set;
10312 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10313 mlxsw_sp_fid_index(rif->fid), false);
10315 mlxsw_sp_rif_macvlan_flush(rif);
10316 err_macvlan_replay:
10317 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10318 mlxsw_sp_router_port(mlxsw_sp), false);
10319 err_fid_bc_flood_set:
10320 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10321 mlxsw_sp_router_port(mlxsw_sp), false);
10322 err_fid_mc_flood_set:
10323 mlxsw_sp_rif_fid_op(rif, fid_index, false);
10325 mlxsw_sp_rif_mac_profile_put(mlxsw_sp, mac_profile);
10329 static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
10331 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10332 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
10333 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10334 struct mlxsw_sp_fid *fid = rif->fid;
10336 mlxsw_sp_fid_rif_unset(fid);
10337 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10338 mlxsw_sp_fid_index(fid), false);
10339 mlxsw_sp_rif_macvlan_flush(rif);
10340 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10341 mlxsw_sp_router_port(mlxsw_sp), false);
10342 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10343 mlxsw_sp_router_port(mlxsw_sp), false);
10344 mlxsw_sp_rif_fid_op(rif, fid_index, false);
10345 mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, rif->mac_profile_id);
10348 static struct mlxsw_sp_fid *
10349 mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif,
10350 const struct mlxsw_sp_rif_params *params,
10351 struct netlink_ext_ack *extack)
10353 int rif_ifindex = mlxsw_sp_rif_dev_ifindex(rif);
10355 return mlxsw_sp_fid_8021d_get(rif->mlxsw_sp, rif_ifindex);
10358 static void mlxsw_sp_rif_fid_fdb_del(struct mlxsw_sp_rif *rif, const char *mac)
10360 struct switchdev_notifier_fdb_info info = {};
10361 struct net_device *dev;
10363 dev = br_fdb_find_port(mlxsw_sp_rif_dev(rif), mac, 0);
10369 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, dev, &info.info,
10373 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
10374 .type = MLXSW_SP_RIF_TYPE_FID,
10375 .rif_size = sizeof(struct mlxsw_sp_rif),
10376 .configure = mlxsw_sp_rif_fid_configure,
10377 .deconfigure = mlxsw_sp_rif_fid_deconfigure,
10378 .fid_get = mlxsw_sp_rif_fid_fid_get,
10379 .fdb_del = mlxsw_sp_rif_fid_fdb_del,
10382 static struct mlxsw_sp_fid *
10383 mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif,
10384 const struct mlxsw_sp_rif_params *params,
10385 struct netlink_ext_ack *extack)
10387 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10388 struct net_device *br_dev;
10390 if (WARN_ON(!params->vid))
10391 return ERR_PTR(-EINVAL);
10393 if (is_vlan_dev(dev)) {
10394 br_dev = vlan_dev_real_dev(dev);
10395 if (WARN_ON(!netif_is_bridge_master(br_dev)))
10396 return ERR_PTR(-EINVAL);
10399 return mlxsw_sp_fid_8021q_get(rif->mlxsw_sp, params->vid);
10402 static void mlxsw_sp_rif_vlan_fdb_del(struct mlxsw_sp_rif *rif, const char *mac)
10404 struct net_device *rif_dev = mlxsw_sp_rif_dev(rif);
10405 struct switchdev_notifier_fdb_info info = {};
10406 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
10407 struct net_device *br_dev;
10408 struct net_device *dev;
10410 br_dev = is_vlan_dev(rif_dev) ? vlan_dev_real_dev(rif_dev) : rif_dev;
10411 dev = br_fdb_find_port(br_dev, mac, vid);
10417 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, dev, &info.info,
10421 static int mlxsw_sp_rif_vlan_op(struct mlxsw_sp_rif *rif, u16 vid, u16 efid,
10424 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10425 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10426 char ritr_pl[MLXSW_REG_RITR_LEN];
10428 mlxsw_reg_ritr_vlan_if_pack(ritr_pl, enable, rif->rif_index, rif->vr_id,
10429 dev->mtu, dev->dev_addr,
10430 rif->mac_profile_id, vid, efid);
10432 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
10435 static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif, u16 efid,
10436 struct netlink_ext_ack *extack)
10438 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10439 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
10440 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10444 err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, rif->addr,
10445 &mac_profile, extack);
10448 rif->mac_profile_id = mac_profile;
10450 err = mlxsw_sp_rif_vlan_op(rif, vid, efid, true);
10452 goto err_rif_vlan_fid_op;
10454 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10455 mlxsw_sp_router_port(mlxsw_sp), true);
10457 goto err_fid_mc_flood_set;
10459 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10460 mlxsw_sp_router_port(mlxsw_sp), true);
10462 goto err_fid_bc_flood_set;
10464 err = mlxsw_sp_macvlan_replay(rif, extack);
10466 goto err_macvlan_replay;
10468 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10469 mlxsw_sp_fid_index(rif->fid), true);
10471 goto err_rif_fdb_op;
10473 err = mlxsw_sp_fid_rif_set(rif->fid, rif);
10475 goto err_fid_rif_set;
10480 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10481 mlxsw_sp_fid_index(rif->fid), false);
10483 mlxsw_sp_rif_macvlan_flush(rif);
10484 err_macvlan_replay:
10485 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10486 mlxsw_sp_router_port(mlxsw_sp), false);
10487 err_fid_bc_flood_set:
10488 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10489 mlxsw_sp_router_port(mlxsw_sp), false);
10490 err_fid_mc_flood_set:
10491 mlxsw_sp_rif_vlan_op(rif, vid, 0, false);
10492 err_rif_vlan_fid_op:
10493 mlxsw_sp_rif_mac_profile_put(mlxsw_sp, mac_profile);
10497 static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
10499 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10500 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
10501 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10503 mlxsw_sp_fid_rif_unset(rif->fid);
10504 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10505 mlxsw_sp_fid_index(rif->fid), false);
10506 mlxsw_sp_rif_macvlan_flush(rif);
10507 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10508 mlxsw_sp_router_port(mlxsw_sp), false);
10509 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10510 mlxsw_sp_router_port(mlxsw_sp), false);
10511 mlxsw_sp_rif_vlan_op(rif, vid, 0, false);
10512 mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, rif->mac_profile_id);
10515 static int mlxsw_sp1_rif_vlan_configure(struct mlxsw_sp_rif *rif,
10516 struct netlink_ext_ack *extack)
10518 return mlxsw_sp_rif_vlan_configure(rif, 0, extack);
10521 static const struct mlxsw_sp_rif_ops mlxsw_sp1_rif_vlan_ops = {
10522 .type = MLXSW_SP_RIF_TYPE_VLAN,
10523 .rif_size = sizeof(struct mlxsw_sp_rif),
10524 .configure = mlxsw_sp1_rif_vlan_configure,
10525 .deconfigure = mlxsw_sp_rif_vlan_deconfigure,
10526 .fid_get = mlxsw_sp_rif_vlan_fid_get,
10527 .fdb_del = mlxsw_sp_rif_vlan_fdb_del,
10530 static int mlxsw_sp2_rif_vlan_configure(struct mlxsw_sp_rif *rif,
10531 struct netlink_ext_ack *extack)
10533 u16 efid = mlxsw_sp_fid_index(rif->fid);
10535 return mlxsw_sp_rif_vlan_configure(rif, efid, extack);
10538 static const struct mlxsw_sp_rif_ops mlxsw_sp2_rif_vlan_ops = {
10539 .type = MLXSW_SP_RIF_TYPE_VLAN,
10540 .rif_size = sizeof(struct mlxsw_sp_rif),
10541 .configure = mlxsw_sp2_rif_vlan_configure,
10542 .deconfigure = mlxsw_sp_rif_vlan_deconfigure,
10543 .fid_get = mlxsw_sp_rif_vlan_fid_get,
10544 .fdb_del = mlxsw_sp_rif_vlan_fdb_del,
10547 static struct mlxsw_sp_rif_ipip_lb *
10548 mlxsw_sp_rif_ipip_lb_rif(struct mlxsw_sp_rif *rif)
10550 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
10554 mlxsw_sp_rif_ipip_lb_setup(struct mlxsw_sp_rif *rif,
10555 const struct mlxsw_sp_rif_params *params)
10557 struct mlxsw_sp_rif_params_ipip_lb *params_lb;
10558 struct mlxsw_sp_rif_ipip_lb *rif_lb;
10560 params_lb = container_of(params, struct mlxsw_sp_rif_params_ipip_lb,
10562 rif_lb = mlxsw_sp_rif_ipip_lb_rif(rif);
10563 rif_lb->lb_config = params_lb->lb_config;
10567 mlxsw_sp1_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif,
10568 struct netlink_ext_ack *extack)
10570 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10571 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10572 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(dev);
10573 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10574 struct mlxsw_sp_vr *ul_vr;
10577 ul_vr = mlxsw_sp_vr_get(mlxsw_sp, ul_tb_id, extack);
10579 return PTR_ERR(ul_vr);
10581 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr->id, 0, true);
10583 goto err_loopback_op;
10585 lb_rif->ul_vr_id = ul_vr->id;
10586 lb_rif->ul_rif_id = 0;
10587 ++ul_vr->rif_count;
10591 mlxsw_sp_vr_put(mlxsw_sp, ul_vr);
10595 static void mlxsw_sp1_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
10597 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10598 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10599 struct mlxsw_sp_vr *ul_vr;
10601 ul_vr = &mlxsw_sp->router->vrs[lb_rif->ul_vr_id];
10602 mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr->id, 0, false);
10604 --ul_vr->rif_count;
10605 mlxsw_sp_vr_put(mlxsw_sp, ul_vr);
10608 static const struct mlxsw_sp_rif_ops mlxsw_sp1_rif_ipip_lb_ops = {
10609 .type = MLXSW_SP_RIF_TYPE_IPIP_LB,
10610 .rif_size = sizeof(struct mlxsw_sp_rif_ipip_lb),
10611 .setup = mlxsw_sp_rif_ipip_lb_setup,
10612 .configure = mlxsw_sp1_rif_ipip_lb_configure,
10613 .deconfigure = mlxsw_sp1_rif_ipip_lb_deconfigure,
10616 static const struct mlxsw_sp_rif_ops *mlxsw_sp1_rif_ops_arr[] = {
10617 [MLXSW_SP_RIF_TYPE_SUBPORT] = &mlxsw_sp_rif_subport_ops,
10618 [MLXSW_SP_RIF_TYPE_VLAN] = &mlxsw_sp1_rif_vlan_ops,
10619 [MLXSW_SP_RIF_TYPE_FID] = &mlxsw_sp_rif_fid_ops,
10620 [MLXSW_SP_RIF_TYPE_IPIP_LB] = &mlxsw_sp1_rif_ipip_lb_ops,
10624 mlxsw_sp_rif_ipip_lb_ul_rif_op(struct mlxsw_sp_rif *ul_rif, bool enable)
10626 struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
10627 char ritr_pl[MLXSW_REG_RITR_LEN];
10629 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
10630 ul_rif->rif_index, ul_rif->vr_id, IP_MAX_MTU);
10631 mlxsw_reg_ritr_loopback_protocol_set(ritr_pl,
10632 MLXSW_REG_RITR_LOOPBACK_GENERIC);
10634 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
10637 static struct mlxsw_sp_rif *
10638 mlxsw_sp_ul_rif_create(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr,
10639 struct mlxsw_sp_crif *ul_crif,
10640 struct netlink_ext_ack *extack)
10642 struct mlxsw_sp_rif *ul_rif;
10643 u8 rif_entries = 1;
10647 err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index, rif_entries);
10649 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interfaces");
10650 return ERR_PTR(err);
10653 ul_rif = mlxsw_sp_rif_alloc(sizeof(*ul_rif), rif_index, vr->id,
10657 goto err_rif_alloc;
10660 mlxsw_sp->router->rifs[rif_index] = ul_rif;
10661 ul_rif->mlxsw_sp = mlxsw_sp;
10662 ul_rif->rif_entries = rif_entries;
10663 err = mlxsw_sp_rif_ipip_lb_ul_rif_op(ul_rif, true);
10665 goto ul_rif_op_err;
10667 atomic_add(rif_entries, &mlxsw_sp->router->rifs_count);
10671 mlxsw_sp->router->rifs[rif_index] = NULL;
10672 mlxsw_sp_rif_free(ul_rif);
10674 mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
10675 return ERR_PTR(err);
10678 static void mlxsw_sp_ul_rif_destroy(struct mlxsw_sp_rif *ul_rif)
10680 struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
10681 u8 rif_entries = ul_rif->rif_entries;
10682 u16 rif_index = ul_rif->rif_index;
10684 atomic_sub(rif_entries, &mlxsw_sp->router->rifs_count);
10685 mlxsw_sp_rif_ipip_lb_ul_rif_op(ul_rif, false);
10686 mlxsw_sp->router->rifs[ul_rif->rif_index] = NULL;
10687 mlxsw_sp_rif_free(ul_rif);
10688 mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
10691 static struct mlxsw_sp_rif *
10692 mlxsw_sp_ul_rif_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
10693 struct mlxsw_sp_crif *ul_crif,
10694 struct netlink_ext_ack *extack)
10696 struct mlxsw_sp_vr *vr;
10699 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id, extack);
10701 return ERR_CAST(vr);
10703 if (refcount_inc_not_zero(&vr->ul_rif_refcnt))
10706 vr->ul_rif = mlxsw_sp_ul_rif_create(mlxsw_sp, vr, ul_crif, extack);
10707 if (IS_ERR(vr->ul_rif)) {
10708 err = PTR_ERR(vr->ul_rif);
10709 goto err_ul_rif_create;
10713 refcount_set(&vr->ul_rif_refcnt, 1);
10718 mlxsw_sp_vr_put(mlxsw_sp, vr);
10719 return ERR_PTR(err);
10722 static void mlxsw_sp_ul_rif_put(struct mlxsw_sp_rif *ul_rif)
10724 struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
10725 struct mlxsw_sp_vr *vr;
10727 vr = &mlxsw_sp->router->vrs[ul_rif->vr_id];
10729 if (!refcount_dec_and_test(&vr->ul_rif_refcnt))
10733 mlxsw_sp_ul_rif_destroy(ul_rif);
10734 mlxsw_sp_vr_put(mlxsw_sp, vr);
10737 int mlxsw_sp_router_ul_rif_get(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
10740 struct mlxsw_sp_rif *ul_rif;
10743 mutex_lock(&mlxsw_sp->router->lock);
10744 ul_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, ul_tb_id, NULL, NULL);
10745 if (IS_ERR(ul_rif)) {
10746 err = PTR_ERR(ul_rif);
10749 *ul_rif_index = ul_rif->rif_index;
10751 mutex_unlock(&mlxsw_sp->router->lock);
10755 void mlxsw_sp_router_ul_rif_put(struct mlxsw_sp *mlxsw_sp, u16 ul_rif_index)
10757 struct mlxsw_sp_rif *ul_rif;
10759 mutex_lock(&mlxsw_sp->router->lock);
10760 ul_rif = mlxsw_sp->router->rifs[ul_rif_index];
10761 if (WARN_ON(!ul_rif))
10764 mlxsw_sp_ul_rif_put(ul_rif);
10766 mutex_unlock(&mlxsw_sp->router->lock);
10770 mlxsw_sp2_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif,
10771 struct netlink_ext_ack *extack)
10773 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10774 struct net_device *dev = mlxsw_sp_rif_dev(rif);
10775 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(dev);
10776 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10777 struct mlxsw_sp_rif *ul_rif;
10780 ul_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, ul_tb_id, NULL, extack);
10781 if (IS_ERR(ul_rif))
10782 return PTR_ERR(ul_rif);
10784 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, 0, ul_rif->rif_index, true);
10786 goto err_loopback_op;
10788 lb_rif->ul_vr_id = 0;
10789 lb_rif->ul_rif_id = ul_rif->rif_index;
10794 mlxsw_sp_ul_rif_put(ul_rif);
10798 static void mlxsw_sp2_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
10800 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10801 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10802 struct mlxsw_sp_rif *ul_rif;
10804 ul_rif = mlxsw_sp_rif_by_index(mlxsw_sp, lb_rif->ul_rif_id);
10805 mlxsw_sp_rif_ipip_lb_op(lb_rif, 0, lb_rif->ul_rif_id, false);
10806 mlxsw_sp_ul_rif_put(ul_rif);
10809 static const struct mlxsw_sp_rif_ops mlxsw_sp2_rif_ipip_lb_ops = {
10810 .type = MLXSW_SP_RIF_TYPE_IPIP_LB,
10811 .rif_size = sizeof(struct mlxsw_sp_rif_ipip_lb),
10812 .setup = mlxsw_sp_rif_ipip_lb_setup,
10813 .configure = mlxsw_sp2_rif_ipip_lb_configure,
10814 .deconfigure = mlxsw_sp2_rif_ipip_lb_deconfigure,
10817 static const struct mlxsw_sp_rif_ops *mlxsw_sp2_rif_ops_arr[] = {
10818 [MLXSW_SP_RIF_TYPE_SUBPORT] = &mlxsw_sp_rif_subport_ops,
10819 [MLXSW_SP_RIF_TYPE_VLAN] = &mlxsw_sp2_rif_vlan_ops,
10820 [MLXSW_SP_RIF_TYPE_FID] = &mlxsw_sp_rif_fid_ops,
10821 [MLXSW_SP_RIF_TYPE_IPIP_LB] = &mlxsw_sp2_rif_ipip_lb_ops,
10824 static int mlxsw_sp_rifs_table_init(struct mlxsw_sp *mlxsw_sp)
10826 struct gen_pool *rifs_table;
10829 rifs_table = gen_pool_create(0, -1);
10833 gen_pool_set_algo(rifs_table, gen_pool_first_fit_order_align,
10836 err = gen_pool_add(rifs_table, MLXSW_SP_ROUTER_GENALLOC_OFFSET,
10837 MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS), -1);
10839 goto err_gen_pool_add;
10841 mlxsw_sp->router->rifs_table = rifs_table;
10846 gen_pool_destroy(rifs_table);
10850 static void mlxsw_sp_rifs_table_fini(struct mlxsw_sp *mlxsw_sp)
10852 gen_pool_destroy(mlxsw_sp->router->rifs_table);
10855 static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
10857 u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
10858 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
10859 struct mlxsw_core *core = mlxsw_sp->core;
10862 if (!MLXSW_CORE_RES_VALID(core, MAX_RIF_MAC_PROFILES))
10864 mlxsw_sp->router->max_rif_mac_profile =
10865 MLXSW_CORE_RES_GET(core, MAX_RIF_MAC_PROFILES);
10867 mlxsw_sp->router->rifs = kcalloc(max_rifs,
10868 sizeof(struct mlxsw_sp_rif *),
10870 if (!mlxsw_sp->router->rifs)
10873 err = mlxsw_sp_rifs_table_init(mlxsw_sp);
10875 goto err_rifs_table_init;
10877 idr_init(&mlxsw_sp->router->rif_mac_profiles_idr);
10878 atomic_set(&mlxsw_sp->router->rif_mac_profiles_count, 0);
10879 atomic_set(&mlxsw_sp->router->rifs_count, 0);
10880 devl_resource_occ_get_register(devlink,
10881 MLXSW_SP_RESOURCE_RIF_MAC_PROFILES,
10882 mlxsw_sp_rif_mac_profiles_occ_get,
10884 devl_resource_occ_get_register(devlink,
10885 MLXSW_SP_RESOURCE_RIFS,
10886 mlxsw_sp_rifs_occ_get,
10891 err_rifs_table_init:
10892 kfree(mlxsw_sp->router->rifs);
10896 static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
10898 int max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
10899 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
10902 WARN_ON_ONCE(atomic_read(&mlxsw_sp->router->rifs_count));
10903 for (i = 0; i < max_rifs; i++)
10904 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
10906 devl_resource_occ_get_unregister(devlink, MLXSW_SP_RESOURCE_RIFS);
10907 devl_resource_occ_get_unregister(devlink,
10908 MLXSW_SP_RESOURCE_RIF_MAC_PROFILES);
10909 WARN_ON(!idr_is_empty(&mlxsw_sp->router->rif_mac_profiles_idr));
10910 idr_destroy(&mlxsw_sp->router->rif_mac_profiles_idr);
10911 mlxsw_sp_rifs_table_fini(mlxsw_sp);
10912 kfree(mlxsw_sp->router->rifs);
10916 mlxsw_sp_ipip_config_tigcr(struct mlxsw_sp *mlxsw_sp)
10918 char tigcr_pl[MLXSW_REG_TIGCR_LEN];
10920 mlxsw_reg_tigcr_pack(tigcr_pl, true, 0);
10921 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tigcr), tigcr_pl);
10924 static int mlxsw_sp_ipips_init(struct mlxsw_sp *mlxsw_sp)
10928 INIT_LIST_HEAD(&mlxsw_sp->router->ipip_list);
10930 err = mlxsw_sp_ipip_ecn_encap_init(mlxsw_sp);
10933 err = mlxsw_sp_ipip_ecn_decap_init(mlxsw_sp);
10937 return mlxsw_sp_ipip_config_tigcr(mlxsw_sp);
10940 static int mlxsw_sp1_ipips_init(struct mlxsw_sp *mlxsw_sp)
10942 mlxsw_sp->router->ipip_ops_arr = mlxsw_sp1_ipip_ops_arr;
10943 return mlxsw_sp_ipips_init(mlxsw_sp);
10946 static int mlxsw_sp2_ipips_init(struct mlxsw_sp *mlxsw_sp)
10948 mlxsw_sp->router->ipip_ops_arr = mlxsw_sp2_ipip_ops_arr;
10949 return mlxsw_sp_ipips_init(mlxsw_sp);
10952 static void mlxsw_sp_ipips_fini(struct mlxsw_sp *mlxsw_sp)
10954 WARN_ON(!list_empty(&mlxsw_sp->router->ipip_list));
10957 static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
10959 struct mlxsw_sp_router *router;
10961 /* Flush pending FIB notifications and then flush the device's
10962 * table before requesting another dump. The FIB notification
10963 * block is unregistered, so no need to take RTNL.
10965 mlxsw_core_flush_owq();
10966 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
10967 mlxsw_sp_router_fib_flush(router->mlxsw_sp);
10970 #ifdef CONFIG_IP_ROUTE_MULTIPATH
10971 struct mlxsw_sp_mp_hash_config {
10972 DECLARE_BITMAP(headers, __MLXSW_REG_RECR2_HEADER_CNT);
10973 DECLARE_BITMAP(fields, __MLXSW_REG_RECR2_FIELD_CNT);
10974 DECLARE_BITMAP(inner_headers, __MLXSW_REG_RECR2_HEADER_CNT);
10975 DECLARE_BITMAP(inner_fields, __MLXSW_REG_RECR2_INNER_FIELD_CNT);
10976 bool inc_parsing_depth;
10979 #define MLXSW_SP_MP_HASH_HEADER_SET(_headers, _header) \
10980 bitmap_set(_headers, MLXSW_REG_RECR2_##_header, 1)
10982 #define MLXSW_SP_MP_HASH_FIELD_SET(_fields, _field) \
10983 bitmap_set(_fields, MLXSW_REG_RECR2_##_field, 1)
10985 #define MLXSW_SP_MP_HASH_FIELD_RANGE_SET(_fields, _field, _nr) \
10986 bitmap_set(_fields, MLXSW_REG_RECR2_##_field, _nr)
10988 static void mlxsw_sp_mp_hash_inner_l3(struct mlxsw_sp_mp_hash_config *config)
10990 unsigned long *inner_headers = config->inner_headers;
10991 unsigned long *inner_fields = config->inner_fields;
10994 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_NOT_TCP_NOT_UDP);
10995 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_TCP_UDP);
10996 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_SIP0, 4);
10997 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_DIP0, 4);
10999 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_NOT_TCP_NOT_UDP);
11000 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_TCP_UDP);
11001 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_SIP0_7);
11002 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_SIP8, 8);
11003 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_DIP0_7);
11004 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_DIP8, 8);
11005 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_NEXT_HEADER);
11006 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_FLOW_LABEL);
11009 static void mlxsw_sp_mp4_hash_outer_addr(struct mlxsw_sp_mp_hash_config *config)
11011 unsigned long *headers = config->headers;
11012 unsigned long *fields = config->fields;
11014 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_NOT_TCP_NOT_UDP);
11015 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_TCP_UDP);
11016 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_SIP0, 4);
11017 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_DIP0, 4);
11021 mlxsw_sp_mp_hash_inner_custom(struct mlxsw_sp_mp_hash_config *config,
11024 unsigned long *inner_headers = config->inner_headers;
11025 unsigned long *inner_fields = config->inner_fields;
11028 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_NOT_TCP_NOT_UDP);
11029 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_TCP_UDP);
11030 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP)
11031 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_SIP0, 4);
11032 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP)
11033 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_DIP0, 4);
11034 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO)
11035 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV4_PROTOCOL);
11037 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_NOT_TCP_NOT_UDP);
11038 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_TCP_UDP);
11039 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP) {
11040 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_SIP0_7);
11041 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_SIP8, 8);
11043 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP) {
11044 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_DIP0_7);
11045 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_DIP8, 8);
11047 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO)
11048 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_NEXT_HEADER);
11049 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_FLOWLABEL)
11050 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_FLOW_LABEL);
11052 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, TCP_UDP_EN_IPV4);
11053 MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, TCP_UDP_EN_IPV6);
11054 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_SRC_PORT)
11055 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_TCP_UDP_SPORT);
11056 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_DST_PORT)
11057 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_TCP_UDP_DPORT);
11060 static void mlxsw_sp_mp4_hash_init(struct mlxsw_sp *mlxsw_sp,
11061 struct mlxsw_sp_mp_hash_config *config)
11063 struct net *net = mlxsw_sp_net(mlxsw_sp);
11064 unsigned long *headers = config->headers;
11065 unsigned long *fields = config->fields;
11068 switch (READ_ONCE(net->ipv4.sysctl_fib_multipath_hash_policy)) {
11070 mlxsw_sp_mp4_hash_outer_addr(config);
11073 mlxsw_sp_mp4_hash_outer_addr(config);
11074 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV4);
11075 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV4_PROTOCOL);
11076 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
11077 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
11081 mlxsw_sp_mp4_hash_outer_addr(config);
11083 mlxsw_sp_mp_hash_inner_l3(config);
11086 hash_fields = READ_ONCE(net->ipv4.sysctl_fib_multipath_hash_fields);
11088 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_NOT_TCP_NOT_UDP);
11089 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_TCP_UDP);
11090 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV4);
11091 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_IP)
11092 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_SIP0, 4);
11093 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_IP)
11094 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_DIP0, 4);
11095 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_IP_PROTO)
11096 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV4_PROTOCOL);
11097 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_PORT)
11098 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
11099 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_PORT)
11100 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
11102 mlxsw_sp_mp_hash_inner_custom(config, hash_fields);
11107 static void mlxsw_sp_mp6_hash_outer_addr(struct mlxsw_sp_mp_hash_config *config)
11109 unsigned long *headers = config->headers;
11110 unsigned long *fields = config->fields;
11112 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_NOT_TCP_NOT_UDP);
11113 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_TCP_UDP);
11114 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_SIP0_7);
11115 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_SIP8, 8);
11116 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_DIP0_7);
11117 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_DIP8, 8);
11120 static void mlxsw_sp_mp6_hash_init(struct mlxsw_sp *mlxsw_sp,
11121 struct mlxsw_sp_mp_hash_config *config)
11123 u32 hash_fields = ip6_multipath_hash_fields(mlxsw_sp_net(mlxsw_sp));
11124 unsigned long *headers = config->headers;
11125 unsigned long *fields = config->fields;
11127 switch (ip6_multipath_hash_policy(mlxsw_sp_net(mlxsw_sp))) {
11129 mlxsw_sp_mp6_hash_outer_addr(config);
11130 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
11131 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_FLOW_LABEL);
11134 mlxsw_sp_mp6_hash_outer_addr(config);
11135 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV6);
11136 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
11137 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
11138 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
11142 mlxsw_sp_mp6_hash_outer_addr(config);
11143 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
11144 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_FLOW_LABEL);
11146 mlxsw_sp_mp_hash_inner_l3(config);
11147 config->inc_parsing_depth = true;
11151 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_NOT_TCP_NOT_UDP);
11152 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_TCP_UDP);
11153 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV6);
11154 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_IP) {
11155 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_SIP0_7);
11156 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_SIP8, 8);
11158 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_IP) {
11159 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_DIP0_7);
11160 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_DIP8, 8);
11162 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_IP_PROTO)
11163 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
11164 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_FLOWLABEL)
11165 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_FLOW_LABEL);
11166 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_PORT)
11167 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
11168 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_PORT)
11169 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
11171 mlxsw_sp_mp_hash_inner_custom(config, hash_fields);
11172 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_MASK)
11173 config->inc_parsing_depth = true;
11178 static int mlxsw_sp_mp_hash_parsing_depth_adjust(struct mlxsw_sp *mlxsw_sp,
11179 bool old_inc_parsing_depth,
11180 bool new_inc_parsing_depth)
11184 if (!old_inc_parsing_depth && new_inc_parsing_depth) {
11185 err = mlxsw_sp_parsing_depth_inc(mlxsw_sp);
11188 mlxsw_sp->router->inc_parsing_depth = true;
11189 } else if (old_inc_parsing_depth && !new_inc_parsing_depth) {
11190 mlxsw_sp_parsing_depth_dec(mlxsw_sp);
11191 mlxsw_sp->router->inc_parsing_depth = false;
11197 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp)
11199 bool old_inc_parsing_depth, new_inc_parsing_depth;
11200 struct mlxsw_sp_mp_hash_config config = {};
11201 char recr2_pl[MLXSW_REG_RECR2_LEN];
11206 seed = jhash(mlxsw_sp->base_mac, sizeof(mlxsw_sp->base_mac), 0);
11207 mlxsw_reg_recr2_pack(recr2_pl, seed);
11208 mlxsw_sp_mp4_hash_init(mlxsw_sp, &config);
11209 mlxsw_sp_mp6_hash_init(mlxsw_sp, &config);
11211 old_inc_parsing_depth = mlxsw_sp->router->inc_parsing_depth;
11212 new_inc_parsing_depth = config.inc_parsing_depth;
11213 err = mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp,
11214 old_inc_parsing_depth,
11215 new_inc_parsing_depth);
11219 for_each_set_bit(bit, config.headers, __MLXSW_REG_RECR2_HEADER_CNT)
11220 mlxsw_reg_recr2_outer_header_enables_set(recr2_pl, bit, 1);
11221 for_each_set_bit(bit, config.fields, __MLXSW_REG_RECR2_FIELD_CNT)
11222 mlxsw_reg_recr2_outer_header_fields_enable_set(recr2_pl, bit, 1);
11223 for_each_set_bit(bit, config.inner_headers, __MLXSW_REG_RECR2_HEADER_CNT)
11224 mlxsw_reg_recr2_inner_header_enables_set(recr2_pl, bit, 1);
11225 for_each_set_bit(bit, config.inner_fields, __MLXSW_REG_RECR2_INNER_FIELD_CNT)
11226 mlxsw_reg_recr2_inner_header_fields_enable_set(recr2_pl, bit, 1);
11228 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(recr2), recr2_pl);
11230 goto err_reg_write;
11235 mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp, new_inc_parsing_depth,
11236 old_inc_parsing_depth);
11240 static void mlxsw_sp_mp_hash_fini(struct mlxsw_sp *mlxsw_sp)
11242 bool old_inc_parsing_depth = mlxsw_sp->router->inc_parsing_depth;
11244 mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp, old_inc_parsing_depth,
11248 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp)
11253 static void mlxsw_sp_mp_hash_fini(struct mlxsw_sp *mlxsw_sp)
11258 static int mlxsw_sp_dscp_init(struct mlxsw_sp *mlxsw_sp)
11260 char rdpm_pl[MLXSW_REG_RDPM_LEN];
11263 MLXSW_REG_ZERO(rdpm, rdpm_pl);
11265 /* HW is determining switch priority based on DSCP-bits, but the
11266 * kernel is still doing that based on the ToS. Since there's a
11267 * mismatch in bits we need to make sure to translate the right
11268 * value ToS would observe, skipping the 2 least-significant ECN bits.
11270 for (i = 0; i < MLXSW_REG_RDPM_DSCP_ENTRY_REC_MAX_COUNT; i++)
11271 mlxsw_reg_rdpm_pack(rdpm_pl, i, rt_tos2priority(i << 2));
11273 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rdpm), rdpm_pl);
11276 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
11278 struct net *net = mlxsw_sp_net(mlxsw_sp);
11279 char rgcr_pl[MLXSW_REG_RGCR_LEN];
11283 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
11285 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
11286 usp = READ_ONCE(net->ipv4.sysctl_ip_fwd_update_priority);
11288 mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
11289 mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
11290 mlxsw_reg_rgcr_usp_set(rgcr_pl, usp);
11291 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
11294 static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
11296 char rgcr_pl[MLXSW_REG_RGCR_LEN];
11298 mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
11299 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
11302 static int mlxsw_sp_lb_rif_init(struct mlxsw_sp *mlxsw_sp,
11303 struct netlink_ext_ack *extack)
11305 struct mlxsw_sp_router *router = mlxsw_sp->router;
11306 struct mlxsw_sp_rif *lb_rif;
11309 router->lb_crif = mlxsw_sp_crif_alloc(NULL);
11310 if (!router->lb_crif)
11313 /* Create a generic loopback RIF associated with the main table
11314 * (default VRF). Any table can be used, but the main table exists
11315 * anyway, so we do not waste resources. Loopback RIFs are usually
11316 * created with a NULL CRIF, but this RIF is used as a fallback RIF
11317 * for blackhole nexthops, and nexthops expect to have a valid CRIF.
11319 lb_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, RT_TABLE_MAIN, router->lb_crif,
11321 if (IS_ERR(lb_rif)) {
11322 err = PTR_ERR(lb_rif);
11323 goto err_ul_rif_get;
11329 mlxsw_sp_crif_free(router->lb_crif);
11333 static void mlxsw_sp_lb_rif_fini(struct mlxsw_sp *mlxsw_sp)
11335 mlxsw_sp_ul_rif_put(mlxsw_sp->router->lb_crif->rif);
11336 mlxsw_sp_crif_free(mlxsw_sp->router->lb_crif);
11339 static int mlxsw_sp1_router_init(struct mlxsw_sp *mlxsw_sp)
11341 size_t size_ranges_count = ARRAY_SIZE(mlxsw_sp1_adj_grp_size_ranges);
11343 mlxsw_sp->router->rif_ops_arr = mlxsw_sp1_rif_ops_arr;
11344 mlxsw_sp->router->adj_grp_size_ranges = mlxsw_sp1_adj_grp_size_ranges;
11345 mlxsw_sp->router->adj_grp_size_ranges_count = size_ranges_count;
11350 const struct mlxsw_sp_router_ops mlxsw_sp1_router_ops = {
11351 .init = mlxsw_sp1_router_init,
11352 .ipips_init = mlxsw_sp1_ipips_init,
11355 static int mlxsw_sp2_router_init(struct mlxsw_sp *mlxsw_sp)
11357 size_t size_ranges_count = ARRAY_SIZE(mlxsw_sp2_adj_grp_size_ranges);
11359 mlxsw_sp->router->rif_ops_arr = mlxsw_sp2_rif_ops_arr;
11360 mlxsw_sp->router->adj_grp_size_ranges = mlxsw_sp2_adj_grp_size_ranges;
11361 mlxsw_sp->router->adj_grp_size_ranges_count = size_ranges_count;
11366 const struct mlxsw_sp_router_ops mlxsw_sp2_router_ops = {
11367 .init = mlxsw_sp2_router_init,
11368 .ipips_init = mlxsw_sp2_ipips_init,
11371 int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp,
11372 struct netlink_ext_ack *extack)
11374 struct mlxsw_sp_router *router;
11375 struct notifier_block *nb;
11378 router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
11381 mutex_init(&router->lock);
11382 mlxsw_sp->router = router;
11383 router->mlxsw_sp = mlxsw_sp;
11385 err = mlxsw_sp->router_ops->init(mlxsw_sp);
11387 goto err_router_ops_init;
11389 INIT_LIST_HEAD(&mlxsw_sp->router->nh_res_grp_list);
11390 INIT_DELAYED_WORK(&mlxsw_sp->router->nh_grp_activity_dw,
11391 mlxsw_sp_nh_grp_activity_work);
11392 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
11393 err = __mlxsw_sp_router_init(mlxsw_sp);
11395 goto err_router_init;
11397 err = mlxsw_sp->router_ops->ipips_init(mlxsw_sp);
11399 goto err_ipips_init;
11401 err = rhashtable_init(&mlxsw_sp->router->crif_ht,
11402 &mlxsw_sp_crif_ht_params);
11404 goto err_crif_ht_init;
11406 err = mlxsw_sp_rifs_init(mlxsw_sp);
11408 goto err_rifs_init;
11410 err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
11411 &mlxsw_sp_nexthop_ht_params);
11413 goto err_nexthop_ht_init;
11415 err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
11416 &mlxsw_sp_nexthop_group_ht_params);
11418 goto err_nexthop_group_ht_init;
11420 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_list);
11421 err = mlxsw_sp_lpm_init(mlxsw_sp);
11425 err = mlxsw_sp_mr_init(mlxsw_sp, &mlxsw_sp_mr_tcam_ops);
11429 err = mlxsw_sp_vrs_init(mlxsw_sp);
11433 err = mlxsw_sp_lb_rif_init(mlxsw_sp, extack);
11435 goto err_lb_rif_init;
11437 err = mlxsw_sp_neigh_init(mlxsw_sp);
11439 goto err_neigh_init;
11441 err = mlxsw_sp_mp_hash_init(mlxsw_sp);
11443 goto err_mp_hash_init;
11445 err = mlxsw_sp_dscp_init(mlxsw_sp);
11447 goto err_dscp_init;
11449 router->inetaddr_nb.notifier_call = mlxsw_sp_inetaddr_event;
11450 err = register_inetaddr_notifier(&router->inetaddr_nb);
11452 goto err_register_inetaddr_notifier;
11454 router->inet6addr_nb.notifier_call = mlxsw_sp_inet6addr_event;
11455 err = register_inet6addr_notifier(&router->inet6addr_nb);
11457 goto err_register_inet6addr_notifier;
11459 router->inetaddr_valid_nb.notifier_call = mlxsw_sp_inetaddr_valid_event;
11460 err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
11462 goto err_register_inetaddr_valid_notifier;
11464 nb = &router->inet6addr_valid_nb;
11465 nb->notifier_call = mlxsw_sp_inet6addr_valid_event;
11466 err = register_inet6addr_validator_notifier(nb);
11468 goto err_register_inet6addr_valid_notifier;
11470 mlxsw_sp->router->netevent_nb.notifier_call =
11471 mlxsw_sp_router_netevent_event;
11472 err = register_netevent_notifier(&mlxsw_sp->router->netevent_nb);
11474 goto err_register_netevent_notifier;
11476 mlxsw_sp->router->netdevice_nb.notifier_call =
11477 mlxsw_sp_router_netdevice_event;
11478 err = register_netdevice_notifier_net(mlxsw_sp_net(mlxsw_sp),
11479 &mlxsw_sp->router->netdevice_nb);
11481 goto err_register_netdev_notifier;
11483 mlxsw_sp->router->nexthop_nb.notifier_call =
11484 mlxsw_sp_nexthop_obj_event;
11485 err = register_nexthop_notifier(mlxsw_sp_net(mlxsw_sp),
11486 &mlxsw_sp->router->nexthop_nb,
11489 goto err_register_nexthop_notifier;
11491 mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
11492 err = register_fib_notifier(mlxsw_sp_net(mlxsw_sp),
11493 &mlxsw_sp->router->fib_nb,
11494 mlxsw_sp_router_fib_dump_flush, extack);
11496 goto err_register_fib_notifier;
11500 err_register_fib_notifier:
11501 unregister_nexthop_notifier(mlxsw_sp_net(mlxsw_sp),
11502 &mlxsw_sp->router->nexthop_nb);
11503 err_register_nexthop_notifier:
11504 unregister_netdevice_notifier_net(mlxsw_sp_net(mlxsw_sp),
11505 &router->netdevice_nb);
11506 err_register_netdev_notifier:
11507 unregister_netevent_notifier(&mlxsw_sp->router->netevent_nb);
11508 err_register_netevent_notifier:
11509 unregister_inet6addr_validator_notifier(&router->inet6addr_valid_nb);
11510 err_register_inet6addr_valid_notifier:
11511 unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
11512 err_register_inetaddr_valid_notifier:
11513 unregister_inet6addr_notifier(&router->inet6addr_nb);
11514 err_register_inet6addr_notifier:
11515 unregister_inetaddr_notifier(&router->inetaddr_nb);
11516 err_register_inetaddr_notifier:
11517 mlxsw_core_flush_owq();
11519 mlxsw_sp_mp_hash_fini(mlxsw_sp);
11521 mlxsw_sp_neigh_fini(mlxsw_sp);
11523 mlxsw_sp_lb_rif_fini(mlxsw_sp);
11525 mlxsw_sp_vrs_fini(mlxsw_sp);
11527 mlxsw_sp_mr_fini(mlxsw_sp);
11529 mlxsw_sp_lpm_fini(mlxsw_sp);
11531 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
11532 err_nexthop_group_ht_init:
11533 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
11534 err_nexthop_ht_init:
11535 mlxsw_sp_rifs_fini(mlxsw_sp);
11537 rhashtable_destroy(&mlxsw_sp->router->crif_ht);
11539 mlxsw_sp_ipips_fini(mlxsw_sp);
11541 __mlxsw_sp_router_fini(mlxsw_sp);
11543 cancel_delayed_work_sync(&mlxsw_sp->router->nh_grp_activity_dw);
11544 err_router_ops_init:
11545 mutex_destroy(&mlxsw_sp->router->lock);
11546 kfree(mlxsw_sp->router);
11550 void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
11552 struct mlxsw_sp_router *router = mlxsw_sp->router;
11554 unregister_fib_notifier(mlxsw_sp_net(mlxsw_sp), &router->fib_nb);
11555 unregister_nexthop_notifier(mlxsw_sp_net(mlxsw_sp),
11556 &router->nexthop_nb);
11557 unregister_netdevice_notifier_net(mlxsw_sp_net(mlxsw_sp),
11558 &router->netdevice_nb);
11559 unregister_netevent_notifier(&router->netevent_nb);
11560 unregister_inet6addr_validator_notifier(&router->inet6addr_valid_nb);
11561 unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
11562 unregister_inet6addr_notifier(&router->inet6addr_nb);
11563 unregister_inetaddr_notifier(&router->inetaddr_nb);
11564 mlxsw_core_flush_owq();
11565 mlxsw_sp_mp_hash_fini(mlxsw_sp);
11566 mlxsw_sp_neigh_fini(mlxsw_sp);
11567 mlxsw_sp_lb_rif_fini(mlxsw_sp);
11568 mlxsw_sp_vrs_fini(mlxsw_sp);
11569 mlxsw_sp_mr_fini(mlxsw_sp);
11570 mlxsw_sp_lpm_fini(mlxsw_sp);
11571 rhashtable_destroy(&router->nexthop_group_ht);
11572 rhashtable_destroy(&router->nexthop_ht);
11573 mlxsw_sp_rifs_fini(mlxsw_sp);
11574 rhashtable_destroy(&mlxsw_sp->router->crif_ht);
11575 mlxsw_sp_ipips_fini(mlxsw_sp);
11576 __mlxsw_sp_router_fini(mlxsw_sp);
11577 cancel_delayed_work_sync(&router->nh_grp_activity_dw);
11578 mutex_destroy(&router->lock);