| // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
| /* Copyright (c) 2016-2018 Mellanox Technologies. All rights reserved */ |
| |
| #include <linux/kernel.h> |
| #include <linux/types.h> |
| #include <linux/rhashtable.h> |
| #include <linux/bitops.h> |
| #include <linux/in6.h> |
| #include <linux/notifier.h> |
| #include <linux/inetdevice.h> |
| #include <linux/netdevice.h> |
| #include <linux/if_bridge.h> |
| #include <linux/socket.h> |
| #include <linux/route.h> |
| #include <linux/gcd.h> |
| #include <linux/if_macvlan.h> |
| #include <linux/refcount.h> |
| #include <linux/jhash.h> |
| #include <linux/net_namespace.h> |
| #include <linux/mutex.h> |
| #include <net/netevent.h> |
| #include <net/neighbour.h> |
| #include <net/arp.h> |
| #include <net/ip_fib.h> |
| #include <net/ip6_fib.h> |
| #include <net/nexthop.h> |
| #include <net/fib_rules.h> |
| #include <net/ip_tunnels.h> |
| #include <net/l3mdev.h> |
| #include <net/addrconf.h> |
| #include <net/ndisc.h> |
| #include <net/ipv6.h> |
| #include <net/fib_notifier.h> |
| #include <net/switchdev.h> |
| |
| #include "spectrum.h" |
| #include "core.h" |
| #include "reg.h" |
| #include "spectrum_cnt.h" |
| #include "spectrum_dpipe.h" |
| #include "spectrum_ipip.h" |
| #include "spectrum_mr.h" |
| #include "spectrum_mr_tcam.h" |
| #include "spectrum_router.h" |
| #include "spectrum_span.h" |
| |
| struct mlxsw_sp_fib; |
| struct mlxsw_sp_vr; |
| struct mlxsw_sp_lpm_tree; |
| struct mlxsw_sp_rif_ops; |
| |
| struct mlxsw_sp_rif { |
| struct list_head nexthop_list; |
| struct list_head neigh_list; |
| struct net_device *dev; /* NULL for underlay RIF */ |
| struct mlxsw_sp_fid *fid; |
| unsigned char addr[ETH_ALEN]; |
| int mtu; |
| u16 rif_index; |
| u8 mac_profile_id; |
| u16 vr_id; |
| const struct mlxsw_sp_rif_ops *ops; |
| struct mlxsw_sp *mlxsw_sp; |
| |
| unsigned int counter_ingress; |
| bool counter_ingress_valid; |
| unsigned int counter_egress; |
| bool counter_egress_valid; |
| }; |
| |
| struct mlxsw_sp_rif_params { |
| struct net_device *dev; |
| union { |
| u16 system_port; |
| u16 lag_id; |
| }; |
| u16 vid; |
| bool lag; |
| }; |
| |
| struct mlxsw_sp_rif_subport { |
| struct mlxsw_sp_rif common; |
| refcount_t ref_count; |
| union { |
| u16 system_port; |
| u16 lag_id; |
| }; |
| u16 vid; |
| bool lag; |
| }; |
| |
| struct mlxsw_sp_rif_ipip_lb { |
| struct mlxsw_sp_rif common; |
| struct mlxsw_sp_rif_ipip_lb_config lb_config; |
| u16 ul_vr_id; /* Reserved for Spectrum-2. */ |
| u16 ul_rif_id; /* Reserved for Spectrum. */ |
| }; |
| |
| struct mlxsw_sp_rif_params_ipip_lb { |
| struct mlxsw_sp_rif_params common; |
| struct mlxsw_sp_rif_ipip_lb_config lb_config; |
| }; |
| |
| struct mlxsw_sp_rif_ops { |
| enum mlxsw_sp_rif_type type; |
| size_t rif_size; |
| |
| void (*setup)(struct mlxsw_sp_rif *rif, |
| const struct mlxsw_sp_rif_params *params); |
| int (*configure)(struct mlxsw_sp_rif *rif, |
| struct netlink_ext_ack *extack); |
| void (*deconfigure)(struct mlxsw_sp_rif *rif); |
| struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif, |
| struct netlink_ext_ack *extack); |
| void (*fdb_del)(struct mlxsw_sp_rif *rif, const char *mac); |
| }; |
| |
| struct mlxsw_sp_rif_mac_profile { |
| unsigned char mac_prefix[ETH_ALEN]; |
| refcount_t ref_count; |
| u8 id; |
| }; |
| |
| struct mlxsw_sp_router_ops { |
| int (*init)(struct mlxsw_sp *mlxsw_sp); |
| int (*ipips_init)(struct mlxsw_sp *mlxsw_sp); |
| }; |
| |
| static struct mlxsw_sp_rif * |
| mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *dev); |
| static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif); |
| static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree); |
| static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_lpm_tree *lpm_tree); |
| static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_fib *fib, |
| u8 tree_id); |
| static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_fib *fib); |
| |
| static unsigned int * |
| mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif, |
| enum mlxsw_sp_rif_counter_dir dir) |
| { |
| switch (dir) { |
| case MLXSW_SP_RIF_COUNTER_EGRESS: |
| return &rif->counter_egress; |
| case MLXSW_SP_RIF_COUNTER_INGRESS: |
| return &rif->counter_ingress; |
| } |
| return NULL; |
| } |
| |
| static bool |
| mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif, |
| enum mlxsw_sp_rif_counter_dir dir) |
| { |
| switch (dir) { |
| case MLXSW_SP_RIF_COUNTER_EGRESS: |
| return rif->counter_egress_valid; |
| case MLXSW_SP_RIF_COUNTER_INGRESS: |
| return rif->counter_ingress_valid; |
| } |
| return false; |
| } |
| |
| static void |
| mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif, |
| enum mlxsw_sp_rif_counter_dir dir, |
| bool valid) |
| { |
| switch (dir) { |
| case MLXSW_SP_RIF_COUNTER_EGRESS: |
| rif->counter_egress_valid = valid; |
| break; |
| case MLXSW_SP_RIF_COUNTER_INGRESS: |
| rif->counter_ingress_valid = valid; |
| break; |
| } |
| } |
| |
| static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index, |
| unsigned int counter_index, bool enable, |
| enum mlxsw_sp_rif_counter_dir dir) |
| { |
| char ritr_pl[MLXSW_REG_RITR_LEN]; |
| bool is_egress = false; |
| int err; |
| |
| if (dir == MLXSW_SP_RIF_COUNTER_EGRESS) |
| is_egress = true; |
| mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index); |
| err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl); |
| if (err) |
| return err; |
| |
| mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable, |
| is_egress); |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl); |
| } |
| |
| int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_rif *rif, |
| enum mlxsw_sp_rif_counter_dir dir, u64 *cnt) |
| { |
| char ricnt_pl[MLXSW_REG_RICNT_LEN]; |
| unsigned int *p_counter_index; |
| bool valid; |
| int err; |
| |
| valid = mlxsw_sp_rif_counter_valid_get(rif, dir); |
| if (!valid) |
| return -EINVAL; |
| |
| p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir); |
| if (!p_counter_index) |
| return -EINVAL; |
| mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index, |
| MLXSW_REG_RICNT_OPCODE_NOP); |
| err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl); |
| if (err) |
| return err; |
| *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl); |
| return 0; |
| } |
| |
| static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp, |
| unsigned int counter_index) |
| { |
| char ricnt_pl[MLXSW_REG_RICNT_LEN]; |
| |
| mlxsw_reg_ricnt_pack(ricnt_pl, counter_index, |
| MLXSW_REG_RICNT_OPCODE_CLEAR); |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl); |
| } |
| |
| int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_rif *rif, |
| enum mlxsw_sp_rif_counter_dir dir) |
| { |
| unsigned int *p_counter_index; |
| int err; |
| |
| p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir); |
| if (!p_counter_index) |
| return -EINVAL; |
| err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF, |
| p_counter_index); |
| if (err) |
| return err; |
| |
| err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index); |
| if (err) |
| goto err_counter_clear; |
| |
| err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index, |
| *p_counter_index, true, dir); |
| if (err) |
| goto err_counter_edit; |
| mlxsw_sp_rif_counter_valid_set(rif, dir, true); |
| return 0; |
| |
| err_counter_edit: |
| err_counter_clear: |
| mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF, |
| *p_counter_index); |
| return err; |
| } |
| |
| void mlxsw_sp_rif_counter_free(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_rif *rif, |
| enum mlxsw_sp_rif_counter_dir dir) |
| { |
| unsigned int *p_counter_index; |
| |
| if (!mlxsw_sp_rif_counter_valid_get(rif, dir)) |
| return; |
| |
| p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir); |
| if (WARN_ON(!p_counter_index)) |
| return; |
| mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index, |
| *p_counter_index, false, dir); |
| mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF, |
| *p_counter_index); |
| mlxsw_sp_rif_counter_valid_set(rif, dir, false); |
| } |
| |
| static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif) |
| { |
| struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp; |
| struct devlink *devlink; |
| |
| devlink = priv_to_devlink(mlxsw_sp->core); |
| if (!devlink_dpipe_table_counter_enabled(devlink, |
| MLXSW_SP_DPIPE_TABLE_NAME_ERIF)) |
| return; |
| mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS); |
| } |
| |
| static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif) |
| { |
| struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp; |
| |
| mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS); |
| } |
| |
| #define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1) |
| |
| struct mlxsw_sp_prefix_usage { |
| DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT); |
| }; |
| |
| #define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \ |
| for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT) |
| |
| static bool |
| mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1, |
| struct mlxsw_sp_prefix_usage *prefix_usage2) |
| { |
| return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1)); |
| } |
| |
| static void |
| mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1, |
| struct mlxsw_sp_prefix_usage *prefix_usage2) |
| { |
| memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1)); |
| } |
| |
| static void |
| mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage, |
| unsigned char prefix_len) |
| { |
| set_bit(prefix_len, prefix_usage->b); |
| } |
| |
| static void |
| mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage, |
| unsigned char prefix_len) |
| { |
| clear_bit(prefix_len, prefix_usage->b); |
| } |
| |
| struct mlxsw_sp_fib_key { |
| unsigned char addr[sizeof(struct in6_addr)]; |
| unsigned char prefix_len; |
| }; |
| |
| enum mlxsw_sp_fib_entry_type { |
| MLXSW_SP_FIB_ENTRY_TYPE_REMOTE, |
| MLXSW_SP_FIB_ENTRY_TYPE_LOCAL, |
| MLXSW_SP_FIB_ENTRY_TYPE_TRAP, |
| MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE, |
| MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE, |
| |
| /* This is a special case of local delivery, where a packet should be |
| * decapsulated on reception. Note that there is no corresponding ENCAP, |
| * because that's a type of next hop, not of FIB entry. (There can be |
| * several next hops in a REMOTE entry, and some of them may be |
| * encapsulating entries.) |
| */ |
| MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP, |
| MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP, |
| }; |
| |
| struct mlxsw_sp_nexthop_group_info; |
| struct mlxsw_sp_nexthop_group; |
| struct mlxsw_sp_fib_entry; |
| |
| struct mlxsw_sp_fib_node { |
| struct mlxsw_sp_fib_entry *fib_entry; |
| struct list_head list; |
| struct rhash_head ht_node; |
| struct mlxsw_sp_fib *fib; |
| struct mlxsw_sp_fib_key key; |
| }; |
| |
| struct mlxsw_sp_fib_entry_decap { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| u32 tunnel_index; |
| }; |
| |
| static struct mlxsw_sp_fib_entry_priv * |
| mlxsw_sp_fib_entry_priv_create(const struct mlxsw_sp_router_ll_ops *ll_ops) |
| { |
| struct mlxsw_sp_fib_entry_priv *priv; |
| |
| if (!ll_ops->fib_entry_priv_size) |
| /* No need to have priv */ |
| return NULL; |
| |
| priv = kzalloc(sizeof(*priv) + ll_ops->fib_entry_priv_size, GFP_KERNEL); |
| if (!priv) |
| return ERR_PTR(-ENOMEM); |
| refcount_set(&priv->refcnt, 1); |
| return priv; |
| } |
| |
| static void |
| mlxsw_sp_fib_entry_priv_destroy(struct mlxsw_sp_fib_entry_priv *priv) |
| { |
| kfree(priv); |
| } |
| |
| static void mlxsw_sp_fib_entry_priv_hold(struct mlxsw_sp_fib_entry_priv *priv) |
| { |
| refcount_inc(&priv->refcnt); |
| } |
| |
| static void mlxsw_sp_fib_entry_priv_put(struct mlxsw_sp_fib_entry_priv *priv) |
| { |
| if (!priv || !refcount_dec_and_test(&priv->refcnt)) |
| return; |
| mlxsw_sp_fib_entry_priv_destroy(priv); |
| } |
| |
| static void mlxsw_sp_fib_entry_op_ctx_priv_hold(struct mlxsw_sp_fib_entry_op_ctx *op_ctx, |
| struct mlxsw_sp_fib_entry_priv *priv) |
| { |
| if (!priv) |
| return; |
| mlxsw_sp_fib_entry_priv_hold(priv); |
| list_add(&priv->list, &op_ctx->fib_entry_priv_list); |
| } |
| |
| static void mlxsw_sp_fib_entry_op_ctx_priv_put_all(struct mlxsw_sp_fib_entry_op_ctx *op_ctx) |
| { |
| struct mlxsw_sp_fib_entry_priv *priv, *tmp; |
| |
| list_for_each_entry_safe(priv, tmp, &op_ctx->fib_entry_priv_list, list) |
| mlxsw_sp_fib_entry_priv_put(priv); |
| INIT_LIST_HEAD(&op_ctx->fib_entry_priv_list); |
| } |
| |
| struct mlxsw_sp_fib_entry { |
| struct mlxsw_sp_fib_node *fib_node; |
| enum mlxsw_sp_fib_entry_type type; |
| struct list_head nexthop_group_node; |
| struct mlxsw_sp_nexthop_group *nh_group; |
| struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */ |
| struct mlxsw_sp_fib_entry_priv *priv; |
| }; |
| |
| struct mlxsw_sp_fib4_entry { |
| struct mlxsw_sp_fib_entry common; |
| struct fib_info *fi; |
| u32 tb_id; |
| u8 tos; |
| u8 type; |
| }; |
| |
| struct mlxsw_sp_fib6_entry { |
| struct mlxsw_sp_fib_entry common; |
| struct list_head rt6_list; |
| unsigned int nrt6; |
| }; |
| |
| struct mlxsw_sp_rt6 { |
| struct list_head list; |
| struct fib6_info *rt; |
| }; |
| |
| struct mlxsw_sp_lpm_tree { |
| u8 id; /* tree ID */ |
| unsigned int ref_count; |
| enum mlxsw_sp_l3proto proto; |
| unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT]; |
| struct mlxsw_sp_prefix_usage prefix_usage; |
| }; |
| |
| struct mlxsw_sp_fib { |
| struct rhashtable ht; |
| struct list_head node_list; |
| struct mlxsw_sp_vr *vr; |
| struct mlxsw_sp_lpm_tree *lpm_tree; |
| enum mlxsw_sp_l3proto proto; |
| const struct mlxsw_sp_router_ll_ops *ll_ops; |
| }; |
| |
| struct mlxsw_sp_vr { |
| u16 id; /* virtual router ID */ |
| u32 tb_id; /* kernel fib table id */ |
| unsigned int rif_count; |
| struct mlxsw_sp_fib *fib4; |
| struct mlxsw_sp_fib *fib6; |
| struct mlxsw_sp_mr_table *mr_table[MLXSW_SP_L3_PROTO_MAX]; |
| struct mlxsw_sp_rif *ul_rif; |
| refcount_t ul_rif_refcnt; |
| }; |
| |
| static int mlxsw_sp_router_ll_basic_init(struct mlxsw_sp *mlxsw_sp, u16 vr_id, |
| enum mlxsw_sp_l3proto proto) |
| { |
| return 0; |
| } |
| |
| static int mlxsw_sp_router_ll_basic_ralta_write(struct mlxsw_sp *mlxsw_sp, char *xralta_pl) |
| { |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), |
| xralta_pl + MLXSW_REG_XRALTA_RALTA_OFFSET); |
| } |
| |
| static int mlxsw_sp_router_ll_basic_ralst_write(struct mlxsw_sp *mlxsw_sp, char *xralst_pl) |
| { |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), |
| xralst_pl + MLXSW_REG_XRALST_RALST_OFFSET); |
| } |
| |
| static int mlxsw_sp_router_ll_basic_raltb_write(struct mlxsw_sp *mlxsw_sp, char *xraltb_pl) |
| { |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), |
| xraltb_pl + MLXSW_REG_XRALTB_RALTB_OFFSET); |
| } |
| |
| static const struct rhashtable_params mlxsw_sp_fib_ht_params; |
| |
| static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_vr *vr, |
| enum mlxsw_sp_l3proto proto) |
| { |
| const struct mlxsw_sp_router_ll_ops *ll_ops = mlxsw_sp->router->proto_ll_ops[proto]; |
| struct mlxsw_sp_lpm_tree *lpm_tree; |
| struct mlxsw_sp_fib *fib; |
| int err; |
| |
| err = ll_ops->init(mlxsw_sp, vr->id, proto); |
| if (err) |
| return ERR_PTR(err); |
| |
| lpm_tree = mlxsw_sp->router->lpm.proto_trees[proto]; |
| fib = kzalloc(sizeof(*fib), GFP_KERNEL); |
| if (!fib) |
| return ERR_PTR(-ENOMEM); |
| err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params); |
| if (err) |
| goto err_rhashtable_init; |
| INIT_LIST_HEAD(&fib->node_list); |
| fib->proto = proto; |
| fib->vr = vr; |
| fib->lpm_tree = lpm_tree; |
| fib->ll_ops = ll_ops; |
| mlxsw_sp_lpm_tree_hold(lpm_tree); |
| err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, lpm_tree->id); |
| if (err) |
| goto err_lpm_tree_bind; |
| return fib; |
| |
| err_lpm_tree_bind: |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree); |
| err_rhashtable_init: |
| kfree(fib); |
| return ERR_PTR(err); |
| } |
| |
| static void mlxsw_sp_fib_destroy(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_fib *fib) |
| { |
| mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib); |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree); |
| WARN_ON(!list_empty(&fib->node_list)); |
| rhashtable_destroy(&fib->ht); |
| kfree(fib); |
| } |
| |
| static struct mlxsw_sp_lpm_tree * |
| mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp) |
| { |
| static struct mlxsw_sp_lpm_tree *lpm_tree; |
| int i; |
| |
| for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) { |
| lpm_tree = &mlxsw_sp->router->lpm.trees[i]; |
| if (lpm_tree->ref_count == 0) |
| return lpm_tree; |
| } |
| return NULL; |
| } |
| |
| static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_router_ll_ops *ll_ops, |
| struct mlxsw_sp_lpm_tree *lpm_tree) |
| { |
| char xralta_pl[MLXSW_REG_XRALTA_LEN]; |
| |
| mlxsw_reg_xralta_pack(xralta_pl, true, |
| (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto, |
| lpm_tree->id); |
| return ll_ops->ralta_write(mlxsw_sp, xralta_pl); |
| } |
| |
| static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_router_ll_ops *ll_ops, |
| struct mlxsw_sp_lpm_tree *lpm_tree) |
| { |
| char xralta_pl[MLXSW_REG_XRALTA_LEN]; |
| |
| mlxsw_reg_xralta_pack(xralta_pl, false, |
| (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto, |
| lpm_tree->id); |
| ll_ops->ralta_write(mlxsw_sp, xralta_pl); |
| } |
| |
| static int |
| mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_router_ll_ops *ll_ops, |
| struct mlxsw_sp_prefix_usage *prefix_usage, |
| struct mlxsw_sp_lpm_tree *lpm_tree) |
| { |
| char xralst_pl[MLXSW_REG_XRALST_LEN]; |
| u8 root_bin = 0; |
| u8 prefix; |
| u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD; |
| |
| mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) |
| root_bin = prefix; |
| |
| mlxsw_reg_xralst_pack(xralst_pl, root_bin, lpm_tree->id); |
| mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) { |
| if (prefix == 0) |
| continue; |
| mlxsw_reg_xralst_bin_pack(xralst_pl, prefix, last_prefix, |
| MLXSW_REG_RALST_BIN_NO_CHILD); |
| last_prefix = prefix; |
| } |
| return ll_ops->ralst_write(mlxsw_sp, xralst_pl); |
| } |
| |
| static struct mlxsw_sp_lpm_tree * |
| mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_router_ll_ops *ll_ops, |
| struct mlxsw_sp_prefix_usage *prefix_usage, |
| enum mlxsw_sp_l3proto proto) |
| { |
| struct mlxsw_sp_lpm_tree *lpm_tree; |
| int err; |
| |
| lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp); |
| if (!lpm_tree) |
| return ERR_PTR(-EBUSY); |
| lpm_tree->proto = proto; |
| err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, ll_ops, lpm_tree); |
| if (err) |
| return ERR_PTR(err); |
| |
| err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, ll_ops, prefix_usage, lpm_tree); |
| if (err) |
| goto err_left_struct_set; |
| memcpy(&lpm_tree->prefix_usage, prefix_usage, |
| sizeof(lpm_tree->prefix_usage)); |
| memset(&lpm_tree->prefix_ref_count, 0, |
| sizeof(lpm_tree->prefix_ref_count)); |
| lpm_tree->ref_count = 1; |
| return lpm_tree; |
| |
| err_left_struct_set: |
| mlxsw_sp_lpm_tree_free(mlxsw_sp, ll_ops, lpm_tree); |
| return ERR_PTR(err); |
| } |
| |
| static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_router_ll_ops *ll_ops, |
| struct mlxsw_sp_lpm_tree *lpm_tree) |
| { |
| mlxsw_sp_lpm_tree_free(mlxsw_sp, ll_ops, lpm_tree); |
| } |
| |
| static struct mlxsw_sp_lpm_tree * |
| mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_prefix_usage *prefix_usage, |
| enum mlxsw_sp_l3proto proto) |
| { |
| const struct mlxsw_sp_router_ll_ops *ll_ops = mlxsw_sp->router->proto_ll_ops[proto]; |
| struct mlxsw_sp_lpm_tree *lpm_tree; |
| int i; |
| |
| for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) { |
| lpm_tree = &mlxsw_sp->router->lpm.trees[i]; |
| if (lpm_tree->ref_count != 0 && |
| lpm_tree->proto == proto && |
| mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage, |
| prefix_usage)) { |
| mlxsw_sp_lpm_tree_hold(lpm_tree); |
| return lpm_tree; |
| } |
| } |
| return mlxsw_sp_lpm_tree_create(mlxsw_sp, ll_ops, prefix_usage, proto); |
| } |
| |
| static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree) |
| { |
| lpm_tree->ref_count++; |
| } |
| |
| static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_lpm_tree *lpm_tree) |
| { |
| const struct mlxsw_sp_router_ll_ops *ll_ops = |
| mlxsw_sp->router->proto_ll_ops[lpm_tree->proto]; |
| |
| if (--lpm_tree->ref_count == 0) |
| mlxsw_sp_lpm_tree_destroy(mlxsw_sp, ll_ops, lpm_tree); |
| } |
| |
| #define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */ |
| |
| static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } }; |
| struct mlxsw_sp_lpm_tree *lpm_tree; |
| u64 max_trees; |
| int err, i; |
| |
| if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES)) |
| return -EIO; |
| |
| max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES); |
| mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN; |
| mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count, |
| sizeof(struct mlxsw_sp_lpm_tree), |
| GFP_KERNEL); |
| if (!mlxsw_sp->router->lpm.trees) |
| return -ENOMEM; |
| |
| for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) { |
| lpm_tree = &mlxsw_sp->router->lpm.trees[i]; |
| lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN; |
| } |
| |
| lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage, |
| MLXSW_SP_L3_PROTO_IPV4); |
| if (IS_ERR(lpm_tree)) { |
| err = PTR_ERR(lpm_tree); |
| goto err_ipv4_tree_get; |
| } |
| mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4] = lpm_tree; |
| |
| lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage, |
| MLXSW_SP_L3_PROTO_IPV6); |
| if (IS_ERR(lpm_tree)) { |
| err = PTR_ERR(lpm_tree); |
| goto err_ipv6_tree_get; |
| } |
| mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6] = lpm_tree; |
| |
| return 0; |
| |
| err_ipv6_tree_get: |
| lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4]; |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree); |
| err_ipv4_tree_get: |
| kfree(mlxsw_sp->router->lpm.trees); |
| return err; |
| } |
| |
| static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_lpm_tree *lpm_tree; |
| |
| lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6]; |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree); |
| |
| lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4]; |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree); |
| |
| kfree(mlxsw_sp->router->lpm.trees); |
| } |
| |
| static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr) |
| { |
| return !!vr->fib4 || !!vr->fib6 || |
| !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] || |
| !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]; |
| } |
| |
| static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_vr *vr; |
| int i; |
| |
| for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) { |
| vr = &mlxsw_sp->router->vrs[i]; |
| if (!mlxsw_sp_vr_is_used(vr)) |
| return vr; |
| } |
| return NULL; |
| } |
| |
| static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_fib *fib, u8 tree_id) |
| { |
| char xraltb_pl[MLXSW_REG_XRALTB_LEN]; |
| |
| mlxsw_reg_xraltb_pack(xraltb_pl, fib->vr->id, |
| (enum mlxsw_reg_ralxx_protocol) fib->proto, |
| tree_id); |
| return fib->ll_ops->raltb_write(mlxsw_sp, xraltb_pl); |
| } |
| |
| static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_fib *fib) |
| { |
| char xraltb_pl[MLXSW_REG_XRALTB_LEN]; |
| |
| /* Bind to tree 0 which is default */ |
| mlxsw_reg_xraltb_pack(xraltb_pl, fib->vr->id, |
| (enum mlxsw_reg_ralxx_protocol) fib->proto, 0); |
| return fib->ll_ops->raltb_write(mlxsw_sp, xraltb_pl); |
| } |
| |
| static u32 mlxsw_sp_fix_tb_id(u32 tb_id) |
| { |
| /* For our purpose, squash main, default and local tables into one */ |
| if (tb_id == RT_TABLE_LOCAL || tb_id == RT_TABLE_DEFAULT) |
| tb_id = RT_TABLE_MAIN; |
| return tb_id; |
| } |
| |
| static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp, |
| u32 tb_id) |
| { |
| struct mlxsw_sp_vr *vr; |
| int i; |
| |
| tb_id = mlxsw_sp_fix_tb_id(tb_id); |
| |
| for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) { |
| vr = &mlxsw_sp->router->vrs[i]; |
| if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id) |
| return vr; |
| } |
| return NULL; |
| } |
| |
| int mlxsw_sp_router_tb_id_vr_id(struct mlxsw_sp *mlxsw_sp, u32 tb_id, |
| u16 *vr_id) |
| { |
| struct mlxsw_sp_vr *vr; |
| int err = 0; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id); |
| if (!vr) { |
| err = -ESRCH; |
| goto out; |
| } |
| *vr_id = vr->id; |
| out: |
| mutex_unlock(&mlxsw_sp->router->lock); |
| return err; |
| } |
| |
| static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr, |
| enum mlxsw_sp_l3proto proto) |
| { |
| switch (proto) { |
| case MLXSW_SP_L3_PROTO_IPV4: |
| return vr->fib4; |
| case MLXSW_SP_L3_PROTO_IPV6: |
| return vr->fib6; |
| } |
| return NULL; |
| } |
| |
| static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp, |
| u32 tb_id, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_mr_table *mr4_table, *mr6_table; |
| struct mlxsw_sp_fib *fib4; |
| struct mlxsw_sp_fib *fib6; |
| struct mlxsw_sp_vr *vr; |
| int err; |
| |
| vr = mlxsw_sp_vr_find_unused(mlxsw_sp); |
| if (!vr) { |
| NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported virtual routers"); |
| return ERR_PTR(-EBUSY); |
| } |
| fib4 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4); |
| if (IS_ERR(fib4)) |
| return ERR_CAST(fib4); |
| fib6 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6); |
| if (IS_ERR(fib6)) { |
| err = PTR_ERR(fib6); |
| goto err_fib6_create; |
| } |
| mr4_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id, |
| MLXSW_SP_L3_PROTO_IPV4); |
| if (IS_ERR(mr4_table)) { |
| err = PTR_ERR(mr4_table); |
| goto err_mr4_table_create; |
| } |
| mr6_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id, |
| MLXSW_SP_L3_PROTO_IPV6); |
| if (IS_ERR(mr6_table)) { |
| err = PTR_ERR(mr6_table); |
| goto err_mr6_table_create; |
| } |
| |
| vr->fib4 = fib4; |
| vr->fib6 = fib6; |
| vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = mr4_table; |
| vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = mr6_table; |
| vr->tb_id = tb_id; |
| return vr; |
| |
| err_mr6_table_create: |
| mlxsw_sp_mr_table_destroy(mr4_table); |
| err_mr4_table_create: |
| mlxsw_sp_fib_destroy(mlxsw_sp, fib6); |
| err_fib6_create: |
| mlxsw_sp_fib_destroy(mlxsw_sp, fib4); |
| return ERR_PTR(err); |
| } |
| |
| static void mlxsw_sp_vr_destroy(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_vr *vr) |
| { |
| mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]); |
| vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = NULL; |
| mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]); |
| vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = NULL; |
| mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib6); |
| vr->fib6 = NULL; |
| mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib4); |
| vr->fib4 = NULL; |
| } |
| |
| static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_vr *vr; |
| |
| tb_id = mlxsw_sp_fix_tb_id(tb_id); |
| vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id); |
| if (!vr) |
| vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id, extack); |
| return vr; |
| } |
| |
| static void mlxsw_sp_vr_put(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr) |
| { |
| if (!vr->rif_count && list_empty(&vr->fib4->node_list) && |
| list_empty(&vr->fib6->node_list) && |
| mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]) && |
| mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6])) |
| mlxsw_sp_vr_destroy(mlxsw_sp, vr); |
| } |
| |
| static bool |
| mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr, |
| enum mlxsw_sp_l3proto proto, u8 tree_id) |
| { |
| struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto); |
| |
| if (!mlxsw_sp_vr_is_used(vr)) |
| return false; |
| if (fib->lpm_tree->id == tree_id) |
| return true; |
| return false; |
| } |
| |
| static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_fib *fib, |
| struct mlxsw_sp_lpm_tree *new_tree) |
| { |
| struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree; |
| int err; |
| |
| fib->lpm_tree = new_tree; |
| mlxsw_sp_lpm_tree_hold(new_tree); |
| err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id); |
| if (err) |
| goto err_tree_bind; |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree); |
| return 0; |
| |
| err_tree_bind: |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, new_tree); |
| fib->lpm_tree = old_tree; |
| return err; |
| } |
| |
| static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_fib *fib, |
| struct mlxsw_sp_lpm_tree *new_tree) |
| { |
| enum mlxsw_sp_l3proto proto = fib->proto; |
| struct mlxsw_sp_lpm_tree *old_tree; |
| u8 old_id, new_id = new_tree->id; |
| struct mlxsw_sp_vr *vr; |
| int i, err; |
| |
| old_tree = mlxsw_sp->router->lpm.proto_trees[proto]; |
| old_id = old_tree->id; |
| |
| for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) { |
| vr = &mlxsw_sp->router->vrs[i]; |
| if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id)) |
| continue; |
| err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp, |
| mlxsw_sp_vr_fib(vr, proto), |
| new_tree); |
| if (err) |
| goto err_tree_replace; |
| } |
| |
| memcpy(new_tree->prefix_ref_count, old_tree->prefix_ref_count, |
| sizeof(new_tree->prefix_ref_count)); |
| mlxsw_sp->router->lpm.proto_trees[proto] = new_tree; |
| mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree); |
| |
| return 0; |
| |
| err_tree_replace: |
| for (i--; i >= 0; i--) { |
| if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id)) |
| continue; |
| mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp, |
| mlxsw_sp_vr_fib(vr, proto), |
| old_tree); |
| } |
| return err; |
| } |
| |
| static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_vr *vr; |
| u64 max_vrs; |
| int i; |
| |
| if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS)) |
| return -EIO; |
| |
| max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); |
| mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr), |
| GFP_KERNEL); |
| if (!mlxsw_sp->router->vrs) |
| return -ENOMEM; |
| |
| for (i = 0; i < max_vrs; i++) { |
| vr = &mlxsw_sp->router->vrs[i]; |
| vr->id = i; |
| } |
| |
| return 0; |
| } |
| |
| static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp); |
| |
| static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp) |
| { |
| /* At this stage we're guaranteed not to have new incoming |
| * FIB notifications and the work queue is free from FIBs |
| * sitting on top of mlxsw netdevs. However, we can still |
| * have other FIBs queued. Flush the queue before flushing |
| * the device's tables. No need for locks, as we're the only |
| * writer. |
| */ |
| mlxsw_core_flush_owq(); |
| mlxsw_sp_router_fib_flush(mlxsw_sp); |
| kfree(mlxsw_sp->router->vrs); |
| } |
| |
| u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev) |
| { |
| struct net_device *d; |
| u32 tb_id; |
| |
| rcu_read_lock(); |
| d = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev); |
| if (d) |
| tb_id = l3mdev_fib_table(d) ? : RT_TABLE_MAIN; |
| else |
| tb_id = RT_TABLE_MAIN; |
| rcu_read_unlock(); |
| |
| return tb_id; |
| } |
| |
| static struct mlxsw_sp_rif * |
| mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_rif_params *params, |
| struct netlink_ext_ack *extack); |
| |
| static struct mlxsw_sp_rif_ipip_lb * |
| mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp, |
| enum mlxsw_sp_ipip_type ipipt, |
| struct net_device *ol_dev, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_rif_params_ipip_lb lb_params; |
| const struct mlxsw_sp_ipip_ops *ipip_ops; |
| struct mlxsw_sp_rif *rif; |
| |
| ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt]; |
| lb_params = (struct mlxsw_sp_rif_params_ipip_lb) { |
| .common.dev = ol_dev, |
| .common.lag = false, |
| .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev), |
| }; |
| |
| rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common, extack); |
| if (IS_ERR(rif)) |
| return ERR_CAST(rif); |
| return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common); |
| } |
| |
| static struct mlxsw_sp_ipip_entry * |
| mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp, |
| enum mlxsw_sp_ipip_type ipipt, |
| struct net_device *ol_dev) |
| { |
| const struct mlxsw_sp_ipip_ops *ipip_ops; |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| struct mlxsw_sp_ipip_entry *ret = NULL; |
| int err; |
| |
| ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt]; |
| ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL); |
| if (!ipip_entry) |
| return ERR_PTR(-ENOMEM); |
| |
| ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt, |
| ol_dev, NULL); |
| if (IS_ERR(ipip_entry->ol_lb)) { |
| ret = ERR_CAST(ipip_entry->ol_lb); |
| goto err_ol_ipip_lb_create; |
| } |
| |
| ipip_entry->ipipt = ipipt; |
| ipip_entry->ol_dev = ol_dev; |
| ipip_entry->parms = ipip_ops->parms_init(ol_dev); |
| |
| err = ipip_ops->rem_ip_addr_set(mlxsw_sp, ipip_entry); |
| if (err) { |
| ret = ERR_PTR(err); |
| goto err_rem_ip_addr_set; |
| } |
| |
| return ipip_entry; |
| |
| err_rem_ip_addr_set: |
| mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common); |
| err_ol_ipip_lb_create: |
| kfree(ipip_entry); |
| return ret; |
| } |
| |
| static void mlxsw_sp_ipip_entry_dealloc(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| const struct mlxsw_sp_ipip_ops *ipip_ops = |
| mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt]; |
| |
| ipip_ops->rem_ip_addr_unset(mlxsw_sp, ipip_entry); |
| mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common); |
| kfree(ipip_entry); |
| } |
| |
| static bool |
| mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp, |
| const enum mlxsw_sp_l3proto ul_proto, |
| union mlxsw_sp_l3addr saddr, |
| u32 ul_tb_id, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev); |
| enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt; |
| union mlxsw_sp_l3addr tun_saddr; |
| |
| if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto) |
| return false; |
| |
| tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev); |
| return tun_ul_tb_id == ul_tb_id && |
| mlxsw_sp_l3addr_eq(&tun_saddr, &saddr); |
| } |
| |
| static int mlxsw_sp_ipip_decap_parsing_depth_inc(struct mlxsw_sp *mlxsw_sp, |
| enum mlxsw_sp_ipip_type ipipt) |
| { |
| const struct mlxsw_sp_ipip_ops *ipip_ops; |
| |
| ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt]; |
| |
| /* Not all tunnels require to increase the default pasing depth |
| * (96 bytes). |
| */ |
| if (ipip_ops->inc_parsing_depth) |
| return mlxsw_sp_parsing_depth_inc(mlxsw_sp); |
| |
| return 0; |
| } |
| |
| static void mlxsw_sp_ipip_decap_parsing_depth_dec(struct mlxsw_sp *mlxsw_sp, |
| enum mlxsw_sp_ipip_type ipipt) |
| { |
| const struct mlxsw_sp_ipip_ops *ipip_ops = |
| mlxsw_sp->router->ipip_ops_arr[ipipt]; |
| |
| if (ipip_ops->inc_parsing_depth) |
| mlxsw_sp_parsing_depth_dec(mlxsw_sp); |
| } |
| |
| static int |
| mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_fib_entry *fib_entry, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| u32 tunnel_index; |
| int err; |
| |
| err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, |
| 1, &tunnel_index); |
| if (err) |
| return err; |
| |
| err = mlxsw_sp_ipip_decap_parsing_depth_inc(mlxsw_sp, |
| ipip_entry->ipipt); |
| if (err) |
| goto err_parsing_depth_inc; |
| |
| ipip_entry->decap_fib_entry = fib_entry; |
| fib_entry->decap.ipip_entry = ipip_entry; |
| fib_entry->decap.tunnel_index = tunnel_index; |
| |
| return 0; |
| |
| err_parsing_depth_inc: |
| mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1, |
| fib_entry->decap.tunnel_index); |
| return err; |
| } |
| |
| static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_fib_entry *fib_entry) |
| { |
| enum mlxsw_sp_ipip_type ipipt = fib_entry->decap.ipip_entry->ipipt; |
| |
| /* Unlink this node from the IPIP entry that it's the decap entry of. */ |
| fib_entry->decap.ipip_entry->decap_fib_entry = NULL; |
| fib_entry->decap.ipip_entry = NULL; |
| mlxsw_sp_ipip_decap_parsing_depth_dec(mlxsw_sp, ipipt); |
| mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, |
| 1, fib_entry->decap.tunnel_index); |
| } |
| |
| static struct mlxsw_sp_fib_node * |
| mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr, |
| size_t addr_len, unsigned char prefix_len); |
| static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_fib_entry *fib_entry); |
| |
| static void |
| mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry; |
| |
| mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry); |
| fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP; |
| |
| mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry); |
| } |
| |
| static void |
| mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| struct mlxsw_sp_fib_entry *decap_fib_entry) |
| { |
| if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry, |
| ipip_entry)) |
| return; |
| decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP; |
| |
| if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry)) |
| mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry); |
| } |
| |
| static struct mlxsw_sp_fib_entry * |
| mlxsw_sp_router_ip2me_fib_entry_find(struct mlxsw_sp *mlxsw_sp, u32 tb_id, |
| enum mlxsw_sp_l3proto proto, |
| const union mlxsw_sp_l3addr *addr, |
| enum mlxsw_sp_fib_entry_type type) |
| { |
| struct mlxsw_sp_fib_node *fib_node; |
| unsigned char addr_prefix_len; |
| struct mlxsw_sp_fib *fib; |
| struct mlxsw_sp_vr *vr; |
| const void *addrp; |
| size_t addr_len; |
| u32 addr4; |
| |
| vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id); |
| if (!vr) |
| return NULL; |
| fib = mlxsw_sp_vr_fib(vr, proto); |
| |
| switch (proto) { |
| case MLXSW_SP_L3_PROTO_IPV4: |
| addr4 = be32_to_cpu(addr->addr4); |
| addrp = &addr4; |
| addr_len = 4; |
| addr_prefix_len = 32; |
| break; |
| case MLXSW_SP_L3_PROTO_IPV6: |
| default: |
| WARN_ON(1); |
| return NULL; |
| } |
| |
| fib_node = mlxsw_sp_fib_node_lookup(fib, addrp, addr_len, |
| addr_prefix_len); |
| if (!fib_node || fib_node->fib_entry->type != type) |
| return NULL; |
| |
| return fib_node->fib_entry; |
| } |
| |
| /* Given an IPIP entry, find the corresponding decap route. */ |
| static struct mlxsw_sp_fib_entry * |
| mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| static struct mlxsw_sp_fib_node *fib_node; |
| const struct mlxsw_sp_ipip_ops *ipip_ops; |
| unsigned char saddr_prefix_len; |
| union mlxsw_sp_l3addr saddr; |
| struct mlxsw_sp_fib *ul_fib; |
| struct mlxsw_sp_vr *ul_vr; |
| const void *saddrp; |
| size_t saddr_len; |
| u32 ul_tb_id; |
| u32 saddr4; |
| |
| ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt]; |
| |
| ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev); |
| ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id); |
| if (!ul_vr) |
| return NULL; |
| |
| ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto); |
| saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto, |
| ipip_entry->ol_dev); |
| |
| switch (ipip_ops->ul_proto) { |
| case MLXSW_SP_L3_PROTO_IPV4: |
| saddr4 = be32_to_cpu(saddr.addr4); |
| saddrp = &saddr4; |
| saddr_len = 4; |
| saddr_prefix_len = 32; |
| break; |
| case MLXSW_SP_L3_PROTO_IPV6: |
| saddrp = &saddr.addr6; |
| saddr_len = 16; |
| saddr_prefix_len = 128; |
| break; |
| default: |
| WARN_ON(1); |
| return NULL; |
| } |
| |
| fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len, |
| saddr_prefix_len); |
| if (!fib_node || |
| fib_node->fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP) |
| return NULL; |
| |
| return fib_node->fib_entry; |
| } |
| |
| static struct mlxsw_sp_ipip_entry * |
| mlxsw_sp_ipip_entry_create(struct mlxsw_sp *mlxsw_sp, |
| enum mlxsw_sp_ipip_type ipipt, |
| struct net_device *ol_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| |
| ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev); |
| if (IS_ERR(ipip_entry)) |
| return ipip_entry; |
| |
| list_add_tail(&ipip_entry->ipip_list_node, |
| &mlxsw_sp->router->ipip_list); |
| |
| return ipip_entry; |
| } |
| |
| static void |
| mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| list_del(&ipip_entry->ipip_list_node); |
| mlxsw_sp_ipip_entry_dealloc(mlxsw_sp, ipip_entry); |
| } |
| |
| static bool |
| mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *ul_dev, |
| enum mlxsw_sp_l3proto ul_proto, |
| union mlxsw_sp_l3addr ul_dip, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN; |
| enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt; |
| |
| if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto) |
| return false; |
| |
| return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip, |
| ul_tb_id, ipip_entry); |
| } |
| |
| /* Given decap parameters, find the corresponding IPIP entry. */ |
| static struct mlxsw_sp_ipip_entry * |
| mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp, int ul_dev_ifindex, |
| enum mlxsw_sp_l3proto ul_proto, |
| union mlxsw_sp_l3addr ul_dip) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry = NULL; |
| struct net_device *ul_dev; |
| |
| rcu_read_lock(); |
| |
| ul_dev = dev_get_by_index_rcu(mlxsw_sp_net(mlxsw_sp), ul_dev_ifindex); |
| if (!ul_dev) |
| goto out_unlock; |
| |
| list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list, |
| ipip_list_node) |
| if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev, |
| ul_proto, ul_dip, |
| ipip_entry)) |
| goto out_unlock; |
| |
| rcu_read_unlock(); |
| |
| return NULL; |
| |
| out_unlock: |
| rcu_read_unlock(); |
| return ipip_entry; |
| } |
| |
| static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *dev, |
| enum mlxsw_sp_ipip_type *p_type) |
| { |
| struct mlxsw_sp_router *router = mlxsw_sp->router; |
| const struct mlxsw_sp_ipip_ops *ipip_ops; |
| enum mlxsw_sp_ipip_type ipipt; |
| |
| for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) { |
| ipip_ops = router->ipip_ops_arr[ipipt]; |
| if (dev->type == ipip_ops->dev_type) { |
| if (p_type) |
| *p_type = ipipt; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool mlxsw_sp_netdev_is_ipip_ol(const struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *dev) |
| { |
| return mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL); |
| } |
| |
| static struct mlxsw_sp_ipip_entry * |
| mlxsw_sp_ipip_entry_find_by_ol_dev(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *ol_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| |
| list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list, |
| ipip_list_node) |
| if (ipip_entry->ol_dev == ol_dev) |
| return ipip_entry; |
| |
| return NULL; |
| } |
| |
| static struct mlxsw_sp_ipip_entry * |
| mlxsw_sp_ipip_entry_find_by_ul_dev(const struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *ul_dev, |
| struct mlxsw_sp_ipip_entry *start) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| |
| ipip_entry = list_prepare_entry(start, &mlxsw_sp->router->ipip_list, |
| ipip_list_node); |
| list_for_each_entry_continue(ipip_entry, &mlxsw_sp->router->ipip_list, |
| ipip_list_node) { |
| struct net_device *ol_dev = ipip_entry->ol_dev; |
| struct net_device *ipip_ul_dev; |
| |
| rcu_read_lock(); |
| ipip_ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev); |
| rcu_read_unlock(); |
| |
| if (ipip_ul_dev == ul_dev) |
| return ipip_entry; |
| } |
| |
| return NULL; |
| } |
| |
| bool mlxsw_sp_netdev_is_ipip_ul(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *dev) |
| { |
| bool is_ipip_ul; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| is_ipip_ul = mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp, dev, NULL); |
| mutex_unlock(&mlxsw_sp->router->lock); |
| |
| return is_ipip_ul; |
| } |
| |
| static bool mlxsw_sp_netdevice_ipip_can_offload(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *ol_dev, |
| enum mlxsw_sp_ipip_type ipipt) |
| { |
| const struct mlxsw_sp_ipip_ops *ops |
| = mlxsw_sp->router->ipip_ops_arr[ipipt]; |
| |
| return ops->can_offload(mlxsw_sp, ol_dev); |
| } |
| |
| static int mlxsw_sp_netdevice_ipip_ol_reg_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev) |
| { |
| enum mlxsw_sp_ipip_type ipipt = MLXSW_SP_IPIP_TYPE_MAX; |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| enum mlxsw_sp_l3proto ul_proto; |
| union mlxsw_sp_l3addr saddr; |
| u32 ul_tb_id; |
| |
| mlxsw_sp_netdev_ipip_type(mlxsw_sp, ol_dev, &ipipt); |
| if (mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev, ipipt)) { |
| ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev); |
| ul_proto = mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto; |
| saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev); |
| if (!mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto, |
| saddr, ul_tb_id, |
| NULL)) { |
| ipip_entry = mlxsw_sp_ipip_entry_create(mlxsw_sp, ipipt, |
| ol_dev); |
| if (IS_ERR(ipip_entry)) |
| return PTR_ERR(ipip_entry); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void mlxsw_sp_netdevice_ipip_ol_unreg_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| |
| ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev); |
| if (ipip_entry) |
| mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry); |
| } |
| |
| static void |
| mlxsw_sp_ipip_entry_ol_up_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| struct mlxsw_sp_fib_entry *decap_fib_entry; |
| |
| decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry); |
| if (decap_fib_entry) |
| mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry, |
| decap_fib_entry); |
| } |
| |
| static int |
| mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif, u16 ul_vr_id, |
| u16 ul_rif_id, bool enable) |
| { |
| struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config; |
| enum mlxsw_reg_ritr_loopback_ipip_options ipip_options; |
| struct mlxsw_sp_rif *rif = &lb_rif->common; |
| struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp; |
| char ritr_pl[MLXSW_REG_RITR_LEN]; |
| struct in6_addr *saddr6; |
| u32 saddr4; |
| |
| ipip_options = MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET; |
| switch (lb_cf.ul_protocol) { |
| case MLXSW_SP_L3_PROTO_IPV4: |
| saddr4 = be32_to_cpu(lb_cf.saddr.addr4); |
| mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF, |
| rif->rif_index, rif->vr_id, rif->dev->mtu); |
| mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt, |
| ipip_options, ul_vr_id, |
| ul_rif_id, saddr4, |
| lb_cf.okey); |
| break; |
| |
| case MLXSW_SP_L3_PROTO_IPV6: |
| saddr6 = &lb_cf.saddr.addr6; |
| mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF, |
| rif->rif_index, rif->vr_id, rif->dev->mtu); |
| mlxsw_reg_ritr_loopback_ipip6_pack(ritr_pl, lb_cf.lb_ipipt, |
| ipip_options, ul_vr_id, |
| ul_rif_id, saddr6, |
| lb_cf.okey); |
| break; |
| } |
| |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl); |
| } |
| |
| static int mlxsw_sp_netdevice_ipip_ol_update_mtu(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| struct mlxsw_sp_rif_ipip_lb *lb_rif; |
| int err = 0; |
| |
| ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev); |
| if (ipip_entry) { |
| lb_rif = ipip_entry->ol_lb; |
| err = mlxsw_sp_rif_ipip_lb_op(lb_rif, lb_rif->ul_vr_id, |
| lb_rif->ul_rif_id, true); |
| if (err) |
| goto out; |
| lb_rif->common.mtu = ol_dev->mtu; |
| } |
| |
| out: |
| return err; |
| } |
| |
| static void mlxsw_sp_netdevice_ipip_ol_up_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| |
| ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev); |
| if (ipip_entry) |
| mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry); |
| } |
| |
| static void |
| mlxsw_sp_ipip_entry_ol_down_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| if (ipip_entry->decap_fib_entry) |
| mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry); |
| } |
| |
| static void mlxsw_sp_netdevice_ipip_ol_down_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| |
| ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev); |
| if (ipip_entry) |
| mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry); |
| } |
| |
| static void mlxsw_sp_nexthop_rif_migrate(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_rif *old_rif, |
| struct mlxsw_sp_rif *new_rif); |
| static int |
| mlxsw_sp_ipip_entry_ol_lb_update(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| bool keep_encap, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_rif_ipip_lb *old_lb_rif = ipip_entry->ol_lb; |
| struct mlxsw_sp_rif_ipip_lb *new_lb_rif; |
| |
| new_lb_rif = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, |
| ipip_entry->ipipt, |
| ipip_entry->ol_dev, |
| extack); |
| if (IS_ERR(new_lb_rif)) |
| return PTR_ERR(new_lb_rif); |
| ipip_entry->ol_lb = new_lb_rif; |
| |
| if (keep_encap) |
| mlxsw_sp_nexthop_rif_migrate(mlxsw_sp, &old_lb_rif->common, |
| &new_lb_rif->common); |
| |
| mlxsw_sp_rif_destroy(&old_lb_rif->common); |
| |
| return 0; |
| } |
| |
| static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_rif *rif); |
| |
| /** |
| * __mlxsw_sp_ipip_entry_update_tunnel - Update offload related to IPIP entry. |
| * @mlxsw_sp: mlxsw_sp. |
| * @ipip_entry: IPIP entry. |
| * @recreate_loopback: Recreates the associated loopback RIF. |
| * @keep_encap: Updates next hops that use the tunnel netdevice. This is only |
| * relevant when recreate_loopback is true. |
| * @update_nexthops: Updates next hops, keeping the current loopback RIF. This |
| * is only relevant when recreate_loopback is false. |
| * @extack: extack. |
| * |
| * Return: Non-zero value on failure. |
| */ |
| int __mlxsw_sp_ipip_entry_update_tunnel(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| bool recreate_loopback, |
| bool keep_encap, |
| bool update_nexthops, |
| struct netlink_ext_ack *extack) |
| { |
| int err; |
| |
| /* RIFs can't be edited, so to update loopback, we need to destroy and |
| * recreate it. That creates a window of opportunity where RALUE and |
| * RATR registers end up referencing a RIF that's already gone. RATRs |
| * are handled in mlxsw_sp_ipip_entry_ol_lb_update(), and to take care |
| * of RALUE, demote the decap route back. |
| */ |
| if (ipip_entry->decap_fib_entry) |
| mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry); |
| |
| if (recreate_loopback) { |
| err = mlxsw_sp_ipip_entry_ol_lb_update(mlxsw_sp, ipip_entry, |
| keep_encap, extack); |
| if (err) |
| return err; |
| } else if (update_nexthops) { |
| mlxsw_sp_nexthop_rif_update(mlxsw_sp, |
| &ipip_entry->ol_lb->common); |
| } |
| |
| if (ipip_entry->ol_dev->flags & IFF_UP) |
| mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry); |
| |
| return 0; |
| } |
| |
| static int mlxsw_sp_netdevice_ipip_ol_vrf_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry = |
| mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev); |
| |
| if (!ipip_entry) |
| return 0; |
| |
| return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry, |
| true, false, false, extack); |
| } |
| |
| static int |
| mlxsw_sp_netdevice_ipip_ul_vrf_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| struct net_device *ul_dev, |
| bool *demote_this, |
| struct netlink_ext_ack *extack) |
| { |
| u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN; |
| enum mlxsw_sp_l3proto ul_proto; |
| union mlxsw_sp_l3addr saddr; |
| |
| /* Moving underlay to a different VRF might cause local address |
| * conflict, and the conflicting tunnels need to be demoted. |
| */ |
| ul_proto = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt]->ul_proto; |
| saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev); |
| if (mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto, |
| saddr, ul_tb_id, |
| ipip_entry)) { |
| *demote_this = true; |
| return 0; |
| } |
| |
| return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry, |
| true, true, false, extack); |
| } |
| |
| static int |
| mlxsw_sp_netdevice_ipip_ul_up_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| struct net_device *ul_dev) |
| { |
| return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry, |
| false, false, true, NULL); |
| } |
| |
| static int |
| mlxsw_sp_netdevice_ipip_ul_down_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| struct net_device *ul_dev) |
| { |
| /* A down underlay device causes encapsulated packets to not be |
| * forwarded, but decap still works. So refresh next hops without |
| * touching anything else. |
| */ |
| return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry, |
| false, false, true, NULL); |
| } |
| |
| static int |
| mlxsw_sp_netdevice_ipip_ol_change_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev, |
| struct netlink_ext_ack *extack) |
| { |
| const struct mlxsw_sp_ipip_ops *ipip_ops; |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| int err; |
| |
| ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev); |
| if (!ipip_entry) |
| /* A change might make a tunnel eligible for offloading, but |
| * that is currently not implemented. What falls to slow path |
| * stays there. |
| */ |
| return 0; |
| |
| /* A change might make a tunnel not eligible for offloading. */ |
| if (!mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev, |
| ipip_entry->ipipt)) { |
| mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry); |
| return 0; |
| } |
| |
| ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt]; |
| err = ipip_ops->ol_netdev_change(mlxsw_sp, ipip_entry, extack); |
| return err; |
| } |
| |
| void mlxsw_sp_ipip_entry_demote_tunnel(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry) |
| { |
| struct net_device *ol_dev = ipip_entry->ol_dev; |
| |
| if (ol_dev->flags & IFF_UP) |
| mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry); |
| mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry); |
| } |
| |
| /* The configuration where several tunnels have the same local address in the |
| * same underlay table needs special treatment in the HW. That is currently not |
| * implemented in the driver. This function finds and demotes the first tunnel |
| * with a given source address, except the one passed in in the argument |
| * `except'. |
| */ |
| bool |
| mlxsw_sp_ipip_demote_tunnel_by_saddr(struct mlxsw_sp *mlxsw_sp, |
| enum mlxsw_sp_l3proto ul_proto, |
| union mlxsw_sp_l3addr saddr, |
| u32 ul_tb_id, |
| const struct mlxsw_sp_ipip_entry *except) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry, *tmp; |
| |
| list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list, |
| ipip_list_node) { |
| if (ipip_entry != except && |
| mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr, |
| ul_tb_id, ipip_entry)) { |
| mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| static void mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ul_dev) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry, *tmp; |
| |
| list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list, |
| ipip_list_node) { |
| struct net_device *ol_dev = ipip_entry->ol_dev; |
| struct net_device *ipip_ul_dev; |
| |
| rcu_read_lock(); |
| ipip_ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev); |
| rcu_read_unlock(); |
| if (ipip_ul_dev == ul_dev) |
| mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry); |
| } |
| } |
| |
| int mlxsw_sp_netdevice_ipip_ol_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ol_dev, |
| unsigned long event, |
| struct netdev_notifier_info *info) |
| { |
| struct netdev_notifier_changeupper_info *chup; |
| struct netlink_ext_ack *extack; |
| int err = 0; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| switch (event) { |
| case NETDEV_REGISTER: |
| err = mlxsw_sp_netdevice_ipip_ol_reg_event(mlxsw_sp, ol_dev); |
| break; |
| case NETDEV_UNREGISTER: |
| mlxsw_sp_netdevice_ipip_ol_unreg_event(mlxsw_sp, ol_dev); |
| break; |
| case NETDEV_UP: |
| mlxsw_sp_netdevice_ipip_ol_up_event(mlxsw_sp, ol_dev); |
| break; |
| case NETDEV_DOWN: |
| mlxsw_sp_netdevice_ipip_ol_down_event(mlxsw_sp, ol_dev); |
| break; |
| case NETDEV_CHANGEUPPER: |
| chup = container_of(info, typeof(*chup), info); |
| extack = info->extack; |
| if (netif_is_l3_master(chup->upper_dev)) |
| err = mlxsw_sp_netdevice_ipip_ol_vrf_event(mlxsw_sp, |
| ol_dev, |
| extack); |
| break; |
| case NETDEV_CHANGE: |
| extack = info->extack; |
| err = mlxsw_sp_netdevice_ipip_ol_change_event(mlxsw_sp, |
| ol_dev, extack); |
| break; |
| case NETDEV_CHANGEMTU: |
| err = mlxsw_sp_netdevice_ipip_ol_update_mtu(mlxsw_sp, ol_dev); |
| break; |
| } |
| mutex_unlock(&mlxsw_sp->router->lock); |
| return err; |
| } |
| |
| static int |
| __mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_ipip_entry *ipip_entry, |
| struct net_device *ul_dev, |
| bool *demote_this, |
| unsigned long event, |
| struct netdev_notifier_info *info) |
| { |
| struct netdev_notifier_changeupper_info *chup; |
| struct netlink_ext_ack *extack; |
| |
| switch (event) { |
| case NETDEV_CHANGEUPPER: |
| chup = container_of(info, typeof(*chup), info); |
| extack = info->extack; |
| if (netif_is_l3_master(chup->upper_dev)) |
| return mlxsw_sp_netdevice_ipip_ul_vrf_event(mlxsw_sp, |
| ipip_entry, |
| ul_dev, |
| demote_this, |
| extack); |
| break; |
| |
| case NETDEV_UP: |
| return mlxsw_sp_netdevice_ipip_ul_up_event(mlxsw_sp, ipip_entry, |
| ul_dev); |
| case NETDEV_DOWN: |
| return mlxsw_sp_netdevice_ipip_ul_down_event(mlxsw_sp, |
| ipip_entry, |
| ul_dev); |
| } |
| return 0; |
| } |
| |
| int |
| mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *ul_dev, |
| unsigned long event, |
| struct netdev_notifier_info *info) |
| { |
| struct mlxsw_sp_ipip_entry *ipip_entry = NULL; |
| int err = 0; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| while ((ipip_entry = mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp, |
| ul_dev, |
| ipip_entry))) { |
| struct mlxsw_sp_ipip_entry *prev; |
| bool demote_this = false; |
| |
| err = __mlxsw_sp_netdevice_ipip_ul_event(mlxsw_sp, ipip_entry, |
| ul_dev, &demote_this, |
| event, info); |
| if (err) { |
| mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(mlxsw_sp, |
| ul_dev); |
| break; |
| } |
| |
| if (demote_this) { |
| if (list_is_first(&ipip_entry->ipip_list_node, |
| &mlxsw_sp->router->ipip_list)) |
| prev = NULL; |
| else |
| /* This can't be cached from previous iteration, |
| * because that entry could be gone now. |
| */ |
| prev = list_prev_entry(ipip_entry, |
| ipip_list_node); |
| mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry); |
| ipip_entry = prev; |
| } |
| } |
| mutex_unlock(&mlxsw_sp->router->lock); |
| |
| return err; |
| } |
| |
| int mlxsw_sp_router_nve_promote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id, |
| enum mlxsw_sp_l3proto ul_proto, |
| const union mlxsw_sp_l3addr *ul_sip, |
| u32 tunnel_index) |
| { |
| enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP; |
| struct mlxsw_sp_router *router = mlxsw_sp->router; |
| struct mlxsw_sp_fib_entry *fib_entry; |
| int err = 0; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| |
| if (WARN_ON_ONCE(router->nve_decap_config.valid)) { |
| err = -EINVAL; |
| goto out; |
| } |
| |
| router->nve_decap_config.ul_tb_id = ul_tb_id; |
| router->nve_decap_config.tunnel_index = tunnel_index; |
| router->nve_decap_config.ul_proto = ul_proto; |
| router->nve_decap_config.ul_sip = *ul_sip; |
| router->nve_decap_config.valid = true; |
| |
| /* It is valid to create a tunnel with a local IP and only later |
| * assign this IP address to a local interface |
| */ |
| fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id, |
| ul_proto, ul_sip, |
| type); |
| if (!fib_entry) |
| goto out; |
| |
| fib_entry->decap.tunnel_index = tunnel_index; |
| fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP; |
| |
| err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry); |
| if (err) |
| goto err_fib_entry_update; |
| |
| goto out; |
| |
| err_fib_entry_update: |
| fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP; |
| mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry); |
| out: |
| mutex_unlock(&mlxsw_sp->router->lock); |
| return err; |
| } |
| |
| void mlxsw_sp_router_nve_demote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id, |
| enum mlxsw_sp_l3proto ul_proto, |
| const union mlxsw_sp_l3addr *ul_sip) |
| { |
| enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP; |
| struct mlxsw_sp_router *router = mlxsw_sp->router; |
| struct mlxsw_sp_fib_entry *fib_entry; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| |
| if (WARN_ON_ONCE(!router->nve_decap_config.valid)) |
| goto out; |
| |
| router->nve_decap_config.valid = false; |
| |
| fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id, |
| ul_proto, ul_sip, |
| type); |
| if (!fib_entry) |
| goto out; |
| |
| fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP; |
| mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry); |
| out: |
| mutex_unlock(&mlxsw_sp->router->lock); |
| } |
| |
| static bool mlxsw_sp_router_nve_is_decap(struct mlxsw_sp *mlxsw_sp, |
| u32 ul_tb_id, |
| enum mlxsw_sp_l3proto ul_proto, |
| const union mlxsw_sp_l3addr *ul_sip) |
| { |
| struct mlxsw_sp_router *router = mlxsw_sp->router; |
| |
| return router->nve_decap_config.valid && |
| router->nve_decap_config.ul_tb_id == ul_tb_id && |
| router->nve_decap_config.ul_proto == ul_proto && |
| !memcmp(&router->nve_decap_config.ul_sip, ul_sip, |
| sizeof(*ul_sip)); |
| } |
| |
| struct mlxsw_sp_neigh_key { |
| struct neighbour *n; |
| }; |
| |
| struct mlxsw_sp_neigh_entry { |
| struct list_head rif_list_node; |
| struct rhash_head ht_node; |
| struct mlxsw_sp_neigh_key key; |
| u16 rif; |
| bool connected; |
| unsigned char ha[ETH_ALEN]; |
| struct list_head nexthop_list; /* list of nexthops using |
| * this neigh entry |
| */ |
| struct list_head nexthop_neighs_list_node; |
| unsigned int counter_index; |
| bool counter_valid; |
| }; |
| |
| static const struct rhashtable_params mlxsw_sp_neigh_ht_params = { |
| .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key), |
| .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node), |
| .key_len = sizeof(struct mlxsw_sp_neigh_key), |
| }; |
| |
| struct mlxsw_sp_neigh_entry * |
| mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| if (!neigh_entry) { |
| if (list_empty(&rif->neigh_list)) |
| return NULL; |
| else |
| return list_first_entry(&rif->neigh_list, |
| typeof(*neigh_entry), |
| rif_list_node); |
| } |
| if (list_is_last(&neigh_entry->rif_list_node, &rif->neigh_list)) |
| return NULL; |
| return list_next_entry(neigh_entry, rif_list_node); |
| } |
| |
| int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| return neigh_entry->key.n->tbl->family; |
| } |
| |
| unsigned char * |
| mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| return neigh_entry->ha; |
| } |
| |
| u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| struct neighbour *n; |
| |
| n = neigh_entry->key.n; |
| return ntohl(*((__be32 *) n->primary_key)); |
| } |
| |
| struct in6_addr * |
| mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| struct neighbour *n; |
| |
| n = neigh_entry->key.n; |
| return (struct in6_addr *) &n->primary_key; |
| } |
| |
| int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry, |
| u64 *p_counter) |
| { |
| if (!neigh_entry->counter_valid) |
| return -EINVAL; |
| |
| return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index, |
| p_counter, NULL); |
| } |
| |
| static struct mlxsw_sp_neigh_entry * |
| mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n, |
| u16 rif) |
| { |
| struct mlxsw_sp_neigh_entry *neigh_entry; |
| |
| neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL); |
| if (!neigh_entry) |
| return NULL; |
| |
| neigh_entry->key.n = n; |
| neigh_entry->rif = rif; |
| INIT_LIST_HEAD(&neigh_entry->nexthop_list); |
| |
| return neigh_entry; |
| } |
| |
| static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| kfree(neigh_entry); |
| } |
| |
| static int |
| mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht, |
| &neigh_entry->ht_node, |
| mlxsw_sp_neigh_ht_params); |
| } |
| |
| static void |
| mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht, |
| &neigh_entry->ht_node, |
| mlxsw_sp_neigh_ht_params); |
| } |
| |
| static bool |
| mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| struct devlink *devlink; |
| const char *table_name; |
| |
| switch (mlxsw_sp_neigh_entry_type(neigh_entry)) { |
| case AF_INET: |
| table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4; |
| break; |
| case AF_INET6: |
| table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6; |
| break; |
| default: |
| WARN_ON(1); |
| return false; |
| } |
| |
| devlink = priv_to_devlink(mlxsw_sp->core); |
| return devlink_dpipe_table_counter_enabled(devlink, table_name); |
| } |
| |
| static void |
| mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry)) |
| return; |
| |
| if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index)) |
| return; |
| |
| neigh_entry->counter_valid = true; |
| } |
| |
| static void |
| mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| if (!neigh_entry->counter_valid) |
| return; |
| mlxsw_sp_flow_counter_free(mlxsw_sp, |
| neigh_entry->counter_index); |
| neigh_entry->counter_valid = false; |
| } |
| |
| static struct mlxsw_sp_neigh_entry * |
| mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n) |
| { |
| struct mlxsw_sp_neigh_entry *neigh_entry; |
| struct mlxsw_sp_rif *rif; |
| int err; |
| |
| rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev); |
| if (!rif) |
| return ERR_PTR(-EINVAL); |
| |
| neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index); |
| if (!neigh_entry) |
| return ERR_PTR(-ENOMEM); |
| |
| err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry); |
| if (err) |
| goto err_neigh_entry_insert; |
| |
| mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry); |
| list_add(&neigh_entry->rif_list_node, &rif->neigh_list); |
| |
| return neigh_entry; |
| |
| err_neigh_entry_insert: |
| mlxsw_sp_neigh_entry_free(neigh_entry); |
| return ERR_PTR(err); |
| } |
| |
| static void |
| mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| list_del(&neigh_entry->rif_list_node); |
| mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry); |
| mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry); |
| mlxsw_sp_neigh_entry_free(neigh_entry); |
| } |
| |
| static struct mlxsw_sp_neigh_entry * |
| mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n) |
| { |
| struct mlxsw_sp_neigh_key key; |
| |
| key.n = n; |
| return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht, |
| &key, mlxsw_sp_neigh_ht_params); |
| } |
| |
| static void |
| mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp) |
| { |
| unsigned long interval; |
| |
| #if IS_ENABLED(CONFIG_IPV6) |
| interval = min_t(unsigned long, |
| NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME), |
| NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME)); |
| #else |
| interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME); |
| #endif |
| mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval); |
| } |
| |
| static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, |
| int ent_index) |
| { |
| u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); |
| struct net_device *dev; |
| struct neighbour *n; |
| __be32 dipn; |
| u32 dip; |
| u16 rif; |
| |
| mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip); |
| |
| if (WARN_ON_ONCE(rif >= max_rifs)) |
| return; |
| if (!mlxsw_sp->router->rifs[rif]) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n"); |
| return; |
| } |
| |
| dipn = htonl(dip); |
| dev = mlxsw_sp->router->rifs[rif]->dev; |
| n = neigh_lookup(&arp_tbl, &dipn, dev); |
| if (!n) |
| return; |
| |
| netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip); |
| neigh_event_send(n, NULL); |
| neigh_release(n); |
| } |
| |
| #if IS_ENABLED(CONFIG_IPV6) |
| static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, |
| int rec_index) |
| { |
| struct net_device *dev; |
| struct neighbour *n; |
| struct in6_addr dip; |
| u16 rif; |
| |
| mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif, |
| (char *) &dip); |
| |
| if (!mlxsw_sp->router->rifs[rif]) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n"); |
| return; |
| } |
| |
| dev = mlxsw_sp->router->rifs[rif]->dev; |
| n = neigh_lookup(&nd_tbl, &dip, dev); |
| if (!n) |
| return; |
| |
| netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip); |
| neigh_event_send(n, NULL); |
| neigh_release(n); |
| } |
| #else |
| static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, |
| int rec_index) |
| { |
| } |
| #endif |
| |
| static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, |
| int rec_index) |
| { |
| u8 num_entries; |
| int i; |
| |
| num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl, |
| rec_index); |
| /* Hardware starts counting at 0, so add 1. */ |
| num_entries++; |
| |
| /* Each record consists of several neighbour entries. */ |
| for (i = 0; i < num_entries; i++) { |
| int ent_index; |
| |
| ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i; |
| mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl, |
| ent_index); |
| } |
| |
| } |
| |
| static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, |
| int rec_index) |
| { |
| /* One record contains one entry. */ |
| mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl, |
| rec_index); |
| } |
| |
| static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, int rec_index) |
| { |
| switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) { |
| case MLXSW_REG_RAUHTD_TYPE_IPV4: |
| mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl, |
| rec_index); |
| break; |
| case MLXSW_REG_RAUHTD_TYPE_IPV6: |
| mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl, |
| rec_index); |
| break; |
| } |
| } |
| |
| static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl) |
| { |
| u8 num_rec, last_rec_index, num_entries; |
| |
| num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl); |
| last_rec_index = num_rec - 1; |
| |
| if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM) |
| return false; |
| if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) == |
| MLXSW_REG_RAUHTD_TYPE_IPV6) |
| return true; |
| |
| num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl, |
| last_rec_index); |
| if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC) |
| return true; |
| return false; |
| } |
| |
| static int |
| __mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp, |
| char *rauhtd_pl, |
| enum mlxsw_reg_rauhtd_type type) |
| { |
| int i, num_rec; |
| int err; |
| |
| /* Ensure the RIF we read from the device does not change mid-dump. */ |
| mutex_lock(&mlxsw_sp->router->lock); |
| do { |
| mlxsw_reg_rauhtd_pack(rauhtd_pl, type); |
| err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd), |
| rauhtd_pl); |
| if (err) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour table\n"); |
| break; |
| } |
| num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl); |
| for (i = 0; i < num_rec; i++) |
| mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl, |
| i); |
| } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl)); |
| mutex_unlock(&mlxsw_sp->router->lock); |
| |
| return err; |
| } |
| |
| static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp) |
| { |
| enum mlxsw_reg_rauhtd_type type; |
| char *rauhtd_pl; |
| int err; |
| |
| rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL); |
| if (!rauhtd_pl) |
| return -ENOMEM; |
| |
| type = MLXSW_REG_RAUHTD_TYPE_IPV4; |
| err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type); |
| if (err) |
| goto out; |
| |
| type = MLXSW_REG_RAUHTD_TYPE_IPV6; |
| err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type); |
| out: |
| kfree(rauhtd_pl); |
| return err; |
| } |
| |
| static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_neigh_entry *neigh_entry; |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list, |
| nexthop_neighs_list_node) |
| /* If this neigh have nexthops, make the kernel think this neigh |
| * is active regardless of the traffic. |
| */ |
| neigh_event_send(neigh_entry->key.n, NULL); |
| mutex_unlock(&mlxsw_sp->router->lock); |
| } |
| |
| static void |
| mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp) |
| { |
| unsigned long interval = mlxsw_sp->router->neighs_update.interval; |
| |
| mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, |
| msecs_to_jiffies(interval)); |
| } |
| |
| static void mlxsw_sp_router_neighs_update_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_router *router; |
| int err; |
| |
| router = container_of(work, struct mlxsw_sp_router, |
| neighs_update.dw.work); |
| err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp); |
| if (err) |
| dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity"); |
| |
| mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp); |
| |
| mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp); |
| } |
| |
| static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work) |
| { |
| struct mlxsw_sp_neigh_entry *neigh_entry; |
| struct mlxsw_sp_router *router; |
| |
| router = container_of(work, struct mlxsw_sp_router, |
| nexthop_probe_dw.work); |
| /* Iterate over nexthop neighbours, find those who are unresolved and |
| * send arp on them. This solves the chicken-egg problem when |
| * the nexthop wouldn't get offloaded until the neighbor is resolved |
| * but it wouldn't get resolved ever in case traffic is flowing in HW |
| * using different nexthop. |
| */ |
| mutex_lock(&router->lock); |
| list_for_each_entry(neigh_entry, &router->nexthop_neighs_list, |
| nexthop_neighs_list_node) |
| if (!neigh_entry->connected) |
| neigh_event_send(neigh_entry->key.n, NULL); |
| mutex_unlock(&router->lock); |
| |
| mlxsw_core_schedule_dw(&router->nexthop_probe_dw, |
| MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL); |
| } |
| |
| static void |
| mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry, |
| bool removing, bool dead); |
| |
| static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding) |
| { |
| return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD : |
| MLXSW_REG_RAUHT_OP_WRITE_DELETE; |
| } |
| |
| static int |
| mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry, |
| enum mlxsw_reg_rauht_op op) |
| { |
| struct neighbour *n = neigh_entry->key.n; |
| u32 dip = ntohl(*((__be32 *) n->primary_key)); |
| char rauht_pl[MLXSW_REG_RAUHT_LEN]; |
| |
| mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha, |
| dip); |
| if (neigh_entry->counter_valid) |
| mlxsw_reg_rauht_pack_counter(rauht_pl, |
| neigh_entry->counter_index); |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl); |
| } |
| |
| static int |
| mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry, |
| enum mlxsw_reg_rauht_op op) |
| { |
| struct neighbour *n = neigh_entry->key.n; |
| char rauht_pl[MLXSW_REG_RAUHT_LEN]; |
| const char *dip = n->primary_key; |
| |
| mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha, |
| dip); |
| if (neigh_entry->counter_valid) |
| mlxsw_reg_rauht_pack_counter(rauht_pl, |
| neigh_entry->counter_index); |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl); |
| } |
| |
| bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry) |
| { |
| struct neighbour *n = neigh_entry->key.n; |
| |
| /* Packets with a link-local destination address are trapped |
| * after LPM lookup and never reach the neighbour table, so |
| * there is no need to program such neighbours to the device. |
| */ |
| if (ipv6_addr_type((struct in6_addr *) &n->primary_key) & |
| IPV6_ADDR_LINKLOCAL) |
| return true; |
| return false; |
| } |
| |
| static void |
| mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry, |
| bool adding) |
| { |
| enum mlxsw_reg_rauht_op op = mlxsw_sp_rauht_op(adding); |
| int err; |
| |
| if (!adding && !neigh_entry->connected) |
| return; |
| neigh_entry->connected = adding; |
| if (neigh_entry->key.n->tbl->family == AF_INET) { |
| err = mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry, |
| op); |
| if (err) |
| return; |
| } else if (neigh_entry->key.n->tbl->family == AF_INET6) { |
| if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry)) |
| return; |
| err = mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry, |
| op); |
| if (err) |
| return; |
| } else { |
| WARN_ON_ONCE(1); |
| return; |
| } |
| |
| if (adding) |
| neigh_entry->key.n->flags |= NTF_OFFLOADED; |
| else |
| neigh_entry->key.n->flags &= ~NTF_OFFLOADED; |
| } |
| |
| void |
| mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_neigh_entry *neigh_entry, |
| bool adding) |
| { |
| if (adding) |
| mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry); |
| else |
| mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry); |
| mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true); |
| } |
| |
| struct mlxsw_sp_netevent_work { |
| struct work_struct work; |
| struct mlxsw_sp *mlxsw_sp; |
| struct neighbour *n; |
| }; |
| |
| static void mlxsw_sp_router_neigh_event_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_netevent_work *net_work = |
| container_of(work, struct mlxsw_sp_netevent_work, work); |
| struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp; |
| struct mlxsw_sp_neigh_entry *neigh_entry; |
| struct neighbour *n = net_work->n; |
| unsigned char ha[ETH_ALEN]; |
| bool entry_connected; |
| u8 nud_state, dead; |
| |
| /* If these parameters are changed after we release the lock, |
| * then we are guaranteed to receive another event letting us |
| * know about it. |
| */ |
| read_lock_bh(&n->lock); |
| memcpy(ha, n->ha, ETH_ALEN); |
| nud_state = n->nud_state; |
| dead = n->dead; |
| read_unlock_bh(&n->lock); |
| |
| mutex_lock(&mlxsw_sp->router->lock); |
| mlxsw_sp_span_respin(mlxsw_sp); |
| |
| entry_connected = nud_state & NUD_VALID && !dead; |
| neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n); |
| if (!entry_connected && !neigh_entry) |
| goto out; |
| if (!neigh_entry) { |
| neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n); |
| if (IS_ERR(neigh_entry)) |
| goto out; |
| } |
| |
| if (neigh_entry->connected && entry_connected && |
| !memcmp(neigh_entry->ha, ha, ETH_ALEN)) |
| goto out; |
| |
| memcpy(neigh_entry->ha, ha, ETH_ALEN); |
| mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected); |
| mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected, |
| dead); |
| |
| if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list)) |
| mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry); |
| |
| out: |
| mutex_unlock(&mlxsw_sp->router->lock); |
| neigh_release(n); |
| kfree(net_work); |
| } |
| |
| static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp); |
| |
| static void mlxsw_sp_router_mp_hash_event_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_netevent_work *net_work = |
| container_of(work, struct mlxsw_sp_netevent_work, work); |
| struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp; |
| |
| mlxsw_sp_mp_hash_init(mlxsw_sp); |
| kfree(net_work); |
| } |
| |
| static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp); |
| |
| static void mlxsw_sp_router_update_priority_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_netevent_work *net_work = |
| container_of(work, struct mlxsw_sp_netevent_work, work); |
| struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp; |
| |
| __mlxsw_sp_router_init(mlxsw_sp); |
| kfree(net_work); |
| } |
| |
| static int mlxsw_sp_router_schedule_work(struct net *net, |
| struct notifier_block *nb, |
| void (*cb)(struct work_struct *)) |
| { |
| struct mlxsw_sp_netevent_work *net_work; |
| struct mlxsw_sp_router *router; |
| |
| router = container_of(nb, struct mlxsw_sp_router, netevent_nb); |
| if (!net_eq(net, mlxsw_sp_net(router->mlxsw_sp))) |
| return NOTIFY_DONE; |
| |
| net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC); |
| if (!net_work) |
| return NOTIFY_BAD; |
| |
| INIT_WORK(&net_work->work, cb); |
| net_work->mlxsw_sp = router->mlxsw_sp; |
| mlxsw_core_schedule_work(&net_work->work); |
| return NOTIFY_DONE; |
| } |
| |
| static int mlxsw_sp_router_netevent_event(struct notifier_block *nb, |
| unsigned long event, void *ptr) |
| { |
| struct mlxsw_sp_netevent_work *net_work; |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| struct mlxsw_sp *mlxsw_sp; |
| unsigned long interval; |
| struct neigh_parms *p; |
| struct neighbour *n; |
| |
| switch (event) { |
| case NETEVENT_DELAY_PROBE_TIME_UPDATE: |
| p = ptr; |
| |
| /* We don't care about changes in the default table. */ |
| if (!p->dev || (p->tbl->family != AF_INET && |
| p->tbl->family != AF_INET6)) |
| return NOTIFY_DONE; |
| |
| /* We are in atomic context and can't take RTNL mutex, |
| * so use RCU variant to walk the device chain. |
| */ |
| mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(p->dev); |
| if (!mlxsw_sp_port) |
| return NOTIFY_DONE; |
| |
| mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME)); |
| mlxsw_sp->router->neighs_update.interval = interval; |
| |
| mlxsw_sp_port_dev_put(mlxsw_sp_port); |
| break; |
| case NETEVENT_NEIGH_UPDATE: |
| n = ptr; |
| |
| if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6) |
| return NOTIFY_DONE; |
| |
| mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(n->dev); |
| if (!mlxsw_sp_port) |
| return NOTIFY_DONE; |
| |
| net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC); |
| if (!net_work) { |
| mlxsw_sp_port_dev_put(mlxsw_sp_port); |
| return NOTIFY_BAD; |
| } |
| |
| INIT_WORK(&net_work->work, mlxsw_sp_router_neigh_event_work); |
| net_work->mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| net_work->n = n; |
| |
| /* Take a reference to ensure the neighbour won't be |
| * destructed until we drop the reference in delayed |
| * work. |
| */ |
| neigh_clone(n); |
| mlxsw_core_schedule_work(&net_work->work); |
| mlxsw_sp_port_dev_put(mlxsw_sp_port); |
| break; |
| case NETEVENT_IPV4_MPATH_HASH_UPDATE: |
| case NETEVENT_IPV6_MPATH_HASH_UPDATE: |
| return mlxsw_sp_router_schedule_work(ptr, nb, |
| mlxsw_sp_router_mp_hash_event_work); |
| |
| case NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE: |
| return mlxsw_sp_router_schedule_work(ptr, nb, |
| mlxsw_sp_router_update_priority_work); |
| } |
| |
| return NOTIFY_DONE; |
| } |
| |
| static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp) |
| { |
| int err; |
| |
| err = rhashtable_init(&mlxsw_sp->router->neigh_ht, |
| &mlxsw_sp_neigh_ht_params); |
| if (err) |
| return err; |
| |
| /* Initialize the polling interval according to the default |
| * table. |
| */ |
| mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp); |
| |
| /* Create the delayed works for the activity_update */ |
| INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw, |
| mlxsw_sp_router_neighs_update_work); |
| INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw, |
| mlxsw_sp_router_probe_unresolved_nexthops); |
| mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0); |
| mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0); |
| return 0; |
| } |
| |
| static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp) |
| { |
| cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw); |
| cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw); |
| rhashtable_destroy(&mlxsw_sp->router->neigh_ht); |
| } |
| |
| static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_rif *rif) |
| { |
| struct mlxsw_sp_neigh_entry *neigh_entry, *tmp; |
| |
| list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list, |
| rif_list_node) { |
| mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false); |
| mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry); |
| } |
| } |
| |
| enum mlxsw_sp_nexthop_type { |
| MLXSW_SP_NEXTHOP_TYPE_ETH, |
| MLXSW_SP_NEXTHOP_TYPE_IPIP, |
| }; |
| |
| enum mlxsw_sp_nexthop_action { |
| /* Nexthop forwards packets to an egress RIF */ |
| MLXSW_SP_NEXTHOP_ACTION_FORWARD, |
| /* Nexthop discards packets */ |
| MLXSW_SP_NEXTHOP_ACTION_DISCARD, |
| /* Nexthop traps packets */ |
| MLXSW_SP_NEXTHOP_ACTION_TRAP, |
| }; |
| |
| struct mlxsw_sp_nexthop_key { |
| struct fib_nh *fib_nh; |
| }; |
| |
| struct mlxsw_sp_nexthop { |
| struct list_head neigh_list_node; /* member of neigh entry list */ |
| struct list_head rif_list_node; |
| struct list_head router_list_node; |
| struct mlxsw_sp_nexthop_group_info *nhgi; /* pointer back to the group |
| * this nexthop belongs to |
| */ |
| struct rhash_head ht_node; |
| struct neigh_table *neigh_tbl; |
| struct mlxsw_sp_nexthop_key key; |
| unsigned char gw_addr[sizeof(struct in6_addr)]; |
| int ifindex; |
| int nh_weight; |
| int norm_nh_weight; |
| int num_adj_entries; |
| struct mlxsw_sp_rif *rif; |
| u8 should_offload:1, /* set indicates this nexthop should be written |
| * to the adjacency table. |
| */ |
| offloaded:1, /* set indicates this nexthop was written to the |
| * adjacency table. |
| */ |
| update:1; /* set indicates this nexthop should be updated in the |
| * adjacency table (f.e., its MAC changed). |
| */ |
| enum mlxsw_sp_nexthop_action action; |
| enum mlxsw_sp_nexthop_type type; |
| union { |
| struct mlxsw_sp_neigh_entry *neigh_entry; |
| struct mlxsw_sp_ipip_entry *ipip_entry; |
| }; |
| unsigned int counter_index; |
| bool counter_valid; |
| }; |
| |
| enum mlxsw_sp_nexthop_group_type { |
| MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4, |
| MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6, |
| MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ, |
| }; |
| |
| struct mlxsw_sp_nexthop_group_info { |
| struct mlxsw_sp_nexthop_group *nh_grp; |
| u32 adj_index; |
| u16 ecmp_size; |
| u16 count; |
| int sum_norm_weight; |
| u8 adj_index_valid:1, |
| gateway:1, /* routes using the group use a gateway */ |
| is_resilient:1; |
| struct list_head list; /* member in nh_res_grp_list */ |
| struct mlxsw_sp_nexthop nexthops[0]; |
| #define nh_rif nexthops[0].rif |
| }; |
| |
| struct mlxsw_sp_nexthop_group_vr_key { |
| u16 vr_id; |
| enum mlxsw_sp_l3proto proto; |
| }; |
| |
| struct mlxsw_sp_nexthop_group_vr_entry { |
| struct list_head list; /* member in vr_list */ |
| struct rhash_head ht_node; /* member in vr_ht */ |
| refcount_t ref_count; |
| struct mlxsw_sp_nexthop_group_vr_key key; |
| }; |
| |
| struct mlxsw_sp_nexthop_group { |
| struct rhash_head ht_node; |
| struct list_head fib_list; /* list of fib entries that use this group */ |
| union { |
| struct { |
| struct fib_info *fi; |
| } ipv4; |
| struct { |
| u32 id; |
| } obj; |
| }; |
| struct mlxsw_sp_nexthop_group_info *nhgi; |
| struct list_head vr_list; |
| struct rhashtable vr_ht; |
| enum mlxsw_sp_nexthop_group_type type; |
| bool can_destroy; |
| }; |
| |
| void mlxsw_sp_nexthop_counter_alloc(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_nexthop *nh) |
| { |
| struct devlink *devlink; |
| |
| devlink = priv_to_devlink(mlxsw_sp->core); |
| if (!devlink_dpipe_table_counter_enabled(devlink, |
| MLXSW_SP_DPIPE_TABLE_NAME_ADJ)) |
| return; |
| |
| if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &nh->counter_index)) |
| return; |
| |
| nh->counter_valid = true; |
| } |
| |
| void mlxsw_sp_nexthop_counter_free(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_nexthop *nh) |
| { |
| if (!nh->counter_valid) |
| return; |
| mlxsw_sp_flow_counter_free(mlxsw_sp, nh->counter_index); |
| nh->counter_valid = false; |
| } |
| |
| int mlxsw_sp_nexthop_counter_get(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_nexthop *nh, u64 *p_counter) |
| { |
| if (!nh->counter_valid) |
| return -EINVAL; |
| |
| return mlxsw_sp_flow_counter_get(mlxsw_sp, nh->counter_index, |
| p_counter, NULL); |
| } |
| |
| struct mlxsw_sp_nexthop *mlxsw_sp_nexthop_next(struct mlxsw_sp_router *router, |
| struct mlxsw_sp_nexthop *nh) |
| { |
| if (!nh) { |
| if (list_empty(&router->nexthop_list)) |
| return NULL; |
| else |
| return list_first_entry(&router->nexthop_list, |
| typeof(*nh), router_list_node); |
| } |
| if (list_is_last(&nh->router_list_node, &router->nexthop_list)) |
| return NULL; |
| return list_next_entry(nh, router_list_node); |
| } |
| |
| bool mlxsw_sp_nexthop_is_forward(const struct mlxsw_sp_nexthop *nh) |
| { |
| return nh->offloaded && nh->action == MLXSW_SP_NEXTHOP_ACTION_FORWARD; |
| } |
| |
| unsigned char *mlxsw_sp_nexthop_ha(struct mlxsw_sp_nexthop *nh) |
| { |
| if (nh->type != MLXSW_SP_NEXTHOP_TYPE_ETH || |
| !mlxsw_sp_nexthop_is_forward(nh)) |
| return NULL; |
| return nh->neigh_entry->ha; |
| } |
| |
| int mlxsw_sp_nexthop_indexes(struct mlxsw_sp_nexthop *nh, u32 *p_adj_index, |
| u32 *p_adj_size, u32 *p_adj_hash_index) |
| { |
| struct mlxsw_sp_nexthop_group_info *nhgi = nh->nhgi; |
| u32 adj_hash_index = 0; |
| int i; |
| |
| if (!nh->offloaded || !nhgi->adj_index_valid) |
| return -EINVAL; |
| |
| *p_adj_index = nhgi->adj_index; |
| *p_adj_size = nhgi->ecmp_size; |
| |
| for (i = 0; i < nhgi->count; i++) { |
| struct mlxsw_sp_nexthop *nh_iter = &nhgi->nexthops[i]; |
| |
| if (nh_iter == nh) |
| break; |
| if (nh_iter->offloaded) |
| adj_hash_index += nh_iter->num_adj_entries; |
| } |
| |
| *p_adj_hash_index = adj_hash_index; |
| return 0; |
| } |
| |
| struct mlxsw_sp_rif *mlxsw_sp_nexthop_rif(struct mlxsw_sp_nexthop *nh) |
| { |
| return nh->rif; |
| } |
| |
| bool mlxsw_sp_nexthop_group_has_ipip(struct mlxsw_sp_nexthop *nh) |
| { |
| struct mlxsw_sp_nexthop_group_info *nhgi = nh->nhgi; |
| int i; |
| |
| for (i = 0; i < nhgi->count; i++) { |
| struct mlxsw_sp_nexthop *nh_iter = &nhgi->nexthops[i]; |
| |
| if (nh_iter->type == MLXSW_SP_NEXTHOP_TYPE_IPIP) |
| return true; |
| } |
| return false; |
| } |
| |
| static const struct rhashtable_params mlxsw_sp_nexthop_group_vr_ht_params = { |
| .key_offset = offsetof(struct mlxsw_sp_nexthop_group_vr_entry, key), |
| .head_offset = offsetof(struct mlxsw_sp_nexthop_group_vr_entry, ht_node), |
| .key_len = sizeof(struct mlxsw_sp_nexthop_group_vr_key), |
| .automatic_shrinking = true, |
| }; |
| |
| static struct mlxsw_sp_nexthop_group_vr_entry * |
| mlxsw_sp_nexthop_group_vr_entry_lookup(struct mlxsw_sp_nexthop_group *nh_grp, |
| const struct mlxsw_sp_fib *fib) |
| { |
| struct mlxsw_sp_nexthop_group_vr_key key; |
| |
| memset(&key, 0, sizeof(key)); |
| key.vr_id = fib->vr->id; |
| key.proto = fib->proto; |
| return rhashtable_lookup_fast(&nh_grp->vr_ht, &key, |
| mlxsw_sp_nexthop_group_vr_ht_params); |
| } |
| |
| static int |
| mlxsw_sp_nexthop_group_vr_entry_create(struct mlxsw_sp_nexthop_group *nh_grp, |
| const struct mlxsw_sp_fib *fib) |
| { |
| struct mlxsw_sp_nexthop_group_vr_entry *vr_entry; |
| int err; |
| |
| vr_entry = kzalloc(sizeof(*vr_entry), GFP_KERNEL); |
| if (!vr_entry) |
| return -ENOMEM; |
| |
|