bnxt_en: bnxt: add TC flower filter offload support
This patch adds support for offloading TC based flow rules and actions for the 'flower' classifier in the bnxt_en driver. It includes logic to parse flow rules and actions received from the TC subsystem, store them and issue the corresponding hwrm_cfa_flow_alloc/free FW cmds. L2/IPv4/IPv6 flows and drop, redir, vlan push/pop actions are supported in this patch. In this patch the hwrm_cfa_flow_xxx routines are just stubs. The code for these routines is introduced in the next patch for easier review. Also, the code to query the TC/flower action stats will be introduced in a subsequent patch. Signed-off-by: Sathya Perla <sathya.perla@broadcom.com> Signed-off-by: Michael Chan <michael.chan@broadcom.com> Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Sathya Perla
David S. Miller
parent
70855603e0
commit
2ae7408fed
|
|
@ -212,6 +212,15 @@ config BNXT_SRIOV
|
|||
Virtualization support in the NetXtreme-C/E products. This
|
||||
allows for virtual function acceleration in virtual environments.
|
||||
|
||||
config BNXT_FLOWER_OFFLOAD
|
||||
bool "TC Flower offload support for NetXtreme-C/E"
|
||||
depends on BNXT
|
||||
default y
|
||||
---help---
|
||||
This configuration parameter enables TC Flower packet classifier
|
||||
offload for eswitch. This option enables SR-IOV switchdev eswitch
|
||||
offload.
|
||||
|
||||
config BNXT_DCB
|
||||
bool "Data Center Bridging (DCB) Support"
|
||||
default n
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
obj-$(CONFIG_BNXT) += bnxt_en.o
|
||||
|
||||
bnxt_en-y := bnxt.o bnxt_sriov.o bnxt_ethtool.o bnxt_dcb.o bnxt_ulp.o bnxt_xdp.o bnxt_vfr.o
|
||||
bnxt_en-y := bnxt.o bnxt_sriov.o bnxt_ethtool.o bnxt_dcb.o bnxt_ulp.o bnxt_xdp.o bnxt_vfr.o bnxt_tc.o
|
||||
|
|
|
|||
|
|
@ -50,6 +50,7 @@
|
|||
#include <linux/bitmap.h>
|
||||
#include <linux/cpu_rmap.h>
|
||||
#include <linux/cpumask.h>
|
||||
#include <net/pkt_cls.h>
|
||||
|
||||
#include "bnxt_hsi.h"
|
||||
#include "bnxt.h"
|
||||
|
|
@ -59,6 +60,7 @@
|
|||
#include "bnxt_dcb.h"
|
||||
#include "bnxt_xdp.h"
|
||||
#include "bnxt_vfr.h"
|
||||
#include "bnxt_tc.h"
|
||||
|
||||
#define BNXT_TX_TIMEOUT (5 * HZ)
|
||||
|
||||
|
|
@ -7305,17 +7307,33 @@ int bnxt_setup_mq_tc(struct net_device *dev, u8 tc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int bnxt_setup_flower(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls_flower)
|
||||
{
|
||||
struct bnxt *bp = netdev_priv(dev);
|
||||
|
||||
if (BNXT_VF(bp))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
return bnxt_tc_setup_flower(bp, bp->pf.fw_fid, cls_flower);
|
||||
}
|
||||
|
||||
static int bnxt_setup_tc(struct net_device *dev, enum tc_setup_type type,
|
||||
void *type_data)
|
||||
{
|
||||
struct tc_mqprio_qopt *mqprio = type_data;
|
||||
switch (type) {
|
||||
case TC_SETUP_CLSFLOWER:
|
||||
return bnxt_setup_flower(dev, type_data);
|
||||
case TC_SETUP_MQPRIO: {
|
||||
struct tc_mqprio_qopt *mqprio = type_data;
|
||||
|
||||
if (type != TC_SETUP_MQPRIO)
|
||||
mqprio->hw = TC_MQPRIO_HW_OFFLOAD_TCS;
|
||||
|
||||
return bnxt_setup_mq_tc(dev, mqprio->num_tc);
|
||||
}
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
mqprio->hw = TC_MQPRIO_HW_OFFLOAD_TCS;
|
||||
|
||||
return bnxt_setup_mq_tc(dev, mqprio->num_tc);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_RFS_ACCEL
|
||||
|
|
@ -7711,6 +7729,7 @@ static void bnxt_remove_one(struct pci_dev *pdev)
|
|||
|
||||
pci_disable_pcie_error_reporting(pdev);
|
||||
unregister_netdev(dev);
|
||||
bnxt_shutdown_tc(bp);
|
||||
cancel_work_sync(&bp->sp_task);
|
||||
bp->sp_event = 0;
|
||||
|
||||
|
|
@ -8102,9 +8121,12 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
else
|
||||
device_set_wakeup_capable(&pdev->dev, false);
|
||||
|
||||
if (BNXT_PF(bp))
|
||||
bnxt_init_tc(bp);
|
||||
|
||||
rc = register_netdev(dev);
|
||||
if (rc)
|
||||
goto init_err_clr_int;
|
||||
goto init_err_cleanup_tc;
|
||||
|
||||
if (BNXT_PF(bp))
|
||||
bnxt_dl_register(bp);
|
||||
|
|
@ -8117,7 +8139,8 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
|
||||
return 0;
|
||||
|
||||
init_err_clr_int:
|
||||
init_err_cleanup_tc:
|
||||
bnxt_shutdown_tc(bp);
|
||||
bnxt_clear_int_mode(bp);
|
||||
|
||||
init_err_pci_clean:
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
#define DRV_VER_UPD 0
|
||||
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/rhashtable.h>
|
||||
#include <net/devlink.h>
|
||||
#include <net/dst_metadata.h>
|
||||
#include <net/switchdev.h>
|
||||
|
|
@ -943,6 +944,27 @@ struct bnxt_test_info {
|
|||
#define BNXT_CAG_REG_LEGACY_INT_STATUS 0x4014
|
||||
#define BNXT_CAG_REG_BASE 0x300000
|
||||
|
||||
struct bnxt_tc_info {
|
||||
bool enabled;
|
||||
|
||||
/* hash table to store TC offloaded flows */
|
||||
struct rhashtable flow_table;
|
||||
struct rhashtable_params flow_ht_params;
|
||||
|
||||
/* hash table to store L2 keys of TC flows */
|
||||
struct rhashtable l2_table;
|
||||
struct rhashtable_params l2_ht_params;
|
||||
|
||||
/* lock to atomically add/del an l2 node when a flow is
|
||||
* added or deleted.
|
||||
*/
|
||||
struct mutex lock;
|
||||
|
||||
/* Stat counter mask (width) */
|
||||
u64 bytes_mask;
|
||||
u64 packets_mask;
|
||||
};
|
||||
|
||||
struct bnxt_vf_rep_stats {
|
||||
u64 packets;
|
||||
u64 bytes;
|
||||
|
|
@ -1289,6 +1311,7 @@ struct bnxt {
|
|||
enum devlink_eswitch_mode eswitch_mode;
|
||||
struct bnxt_vf_rep **vf_reps; /* array of vf-rep ptrs */
|
||||
u16 *cfa_code_map; /* cfa_code -> vf_idx map */
|
||||
struct bnxt_tc_info tc_info;
|
||||
};
|
||||
|
||||
#define BNXT_RX_STATS_OFFSET(counter) \
|
||||
|
|
|
|||
|
|
@ -0,0 +1,602 @@
|
|||
/* Broadcom NetXtreme-C/E network driver.
|
||||
*
|
||||
* Copyright (c) 2017 Broadcom Limited
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/netdevice.h>
|
||||
#include <linux/inetdevice.h>
|
||||
#include <linux/if_vlan.h>
|
||||
#include <net/flow_dissector.h>
|
||||
#include <net/pkt_cls.h>
|
||||
#include <net/tc_act/tc_gact.h>
|
||||
#include <net/tc_act/tc_skbedit.h>
|
||||
#include <net/tc_act/tc_mirred.h>
|
||||
#include <net/tc_act/tc_vlan.h>
|
||||
|
||||
#include "bnxt_hsi.h"
|
||||
#include "bnxt.h"
|
||||
#include "bnxt_sriov.h"
|
||||
#include "bnxt_tc.h"
|
||||
#include "bnxt_vfr.h"
|
||||
|
||||
#ifdef CONFIG_BNXT_FLOWER_OFFLOAD
|
||||
|
||||
#define BNXT_FID_INVALID 0xffff
|
||||
#define VLAN_TCI(vid, prio) ((vid) | ((prio) << VLAN_PRIO_SHIFT))
|
||||
|
||||
/* Return the dst fid of the func for flow forwarding
|
||||
* For PFs: src_fid is the fid of the PF
|
||||
* For VF-reps: src_fid the fid of the VF
|
||||
*/
|
||||
static u16 bnxt_flow_get_dst_fid(struct bnxt *pf_bp, struct net_device *dev)
|
||||
{
|
||||
struct bnxt *bp;
|
||||
|
||||
/* check if dev belongs to the same switch */
|
||||
if (!switchdev_port_same_parent_id(pf_bp->dev, dev)) {
|
||||
netdev_info(pf_bp->dev, "dev(ifindex=%d) not on same switch",
|
||||
dev->ifindex);
|
||||
return BNXT_FID_INVALID;
|
||||
}
|
||||
|
||||
/* Is dev a VF-rep? */
|
||||
if (dev != pf_bp->dev)
|
||||
return bnxt_vf_rep_get_fid(dev);
|
||||
|
||||
bp = netdev_priv(dev);
|
||||
return bp->pf.fw_fid;
|
||||
}
|
||||
|
||||
static int bnxt_tc_parse_redir(struct bnxt *bp,
|
||||
struct bnxt_tc_actions *actions,
|
||||
const struct tc_action *tc_act)
|
||||
{
|
||||
int ifindex = tcf_mirred_ifindex(tc_act);
|
||||
struct net_device *dev;
|
||||
u16 dst_fid;
|
||||
|
||||
dev = __dev_get_by_index(dev_net(bp->dev), ifindex);
|
||||
if (!dev) {
|
||||
netdev_info(bp->dev, "no dev for ifindex=%d", ifindex);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* find the FID from dev */
|
||||
dst_fid = bnxt_flow_get_dst_fid(bp, dev);
|
||||
if (dst_fid == BNXT_FID_INVALID) {
|
||||
netdev_info(bp->dev, "can't get fid for ifindex=%d", ifindex);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
actions->flags |= BNXT_TC_ACTION_FLAG_FWD;
|
||||
actions->dst_fid = dst_fid;
|
||||
actions->dst_dev = dev;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void bnxt_tc_parse_vlan(struct bnxt *bp,
|
||||
struct bnxt_tc_actions *actions,
|
||||
const struct tc_action *tc_act)
|
||||
{
|
||||
if (tcf_vlan_action(tc_act) == TCA_VLAN_ACT_POP) {
|
||||
actions->flags |= BNXT_TC_ACTION_FLAG_POP_VLAN;
|
||||
} else if (tcf_vlan_action(tc_act) == TCA_VLAN_ACT_PUSH) {
|
||||
actions->flags |= BNXT_TC_ACTION_FLAG_PUSH_VLAN;
|
||||
actions->push_vlan_tci = htons(tcf_vlan_push_vid(tc_act));
|
||||
actions->push_vlan_tpid = tcf_vlan_push_proto(tc_act);
|
||||
}
|
||||
}
|
||||
|
||||
static int bnxt_tc_parse_actions(struct bnxt *bp,
|
||||
struct bnxt_tc_actions *actions,
|
||||
struct tcf_exts *tc_exts)
|
||||
{
|
||||
const struct tc_action *tc_act;
|
||||
LIST_HEAD(tc_actions);
|
||||
int rc;
|
||||
|
||||
if (!tcf_exts_has_actions(tc_exts)) {
|
||||
netdev_info(bp->dev, "no actions");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
tcf_exts_to_list(tc_exts, &tc_actions);
|
||||
list_for_each_entry(tc_act, &tc_actions, list) {
|
||||
/* Drop action */
|
||||
if (is_tcf_gact_shot(tc_act)) {
|
||||
actions->flags |= BNXT_TC_ACTION_FLAG_DROP;
|
||||
return 0; /* don't bother with other actions */
|
||||
}
|
||||
|
||||
/* Redirect action */
|
||||
if (is_tcf_mirred_egress_redirect(tc_act)) {
|
||||
rc = bnxt_tc_parse_redir(bp, actions, tc_act);
|
||||
if (rc)
|
||||
return rc;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Push/pop VLAN */
|
||||
if (is_tcf_vlan(tc_act)) {
|
||||
bnxt_tc_parse_vlan(bp, actions, tc_act);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define GET_KEY(flow_cmd, key_type) \
|
||||
skb_flow_dissector_target((flow_cmd)->dissector, key_type,\
|
||||
(flow_cmd)->key)
|
||||
#define GET_MASK(flow_cmd, key_type) \
|
||||
skb_flow_dissector_target((flow_cmd)->dissector, key_type,\
|
||||
(flow_cmd)->mask)
|
||||
|
||||
static int bnxt_tc_parse_flow(struct bnxt *bp,
|
||||
struct tc_cls_flower_offload *tc_flow_cmd,
|
||||
struct bnxt_tc_flow *flow)
|
||||
{
|
||||
struct flow_dissector *dissector = tc_flow_cmd->dissector;
|
||||
u16 addr_type = 0;
|
||||
|
||||
/* KEY_CONTROL and KEY_BASIC are needed for forming a meaningful key */
|
||||
if ((dissector->used_keys & BIT(FLOW_DISSECTOR_KEY_CONTROL)) == 0 ||
|
||||
(dissector->used_keys & BIT(FLOW_DISSECTOR_KEY_BASIC)) == 0) {
|
||||
netdev_info(bp->dev, "cannot form TC key: used_keys = 0x%x",
|
||||
dissector->used_keys);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_CONTROL)) {
|
||||
struct flow_dissector_key_control *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_CONTROL);
|
||||
|
||||
addr_type = key->addr_type;
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_BASIC)) {
|
||||
struct flow_dissector_key_basic *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_BASIC);
|
||||
struct flow_dissector_key_basic *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_BASIC);
|
||||
|
||||
flow->l2_key.ether_type = key->n_proto;
|
||||
flow->l2_mask.ether_type = mask->n_proto;
|
||||
|
||||
if (key->n_proto == htons(ETH_P_IP) ||
|
||||
key->n_proto == htons(ETH_P_IPV6)) {
|
||||
flow->l4_key.ip_proto = key->ip_proto;
|
||||
flow->l4_mask.ip_proto = mask->ip_proto;
|
||||
}
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
|
||||
struct flow_dissector_key_eth_addrs *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ETH_ADDRS);
|
||||
struct flow_dissector_key_eth_addrs *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ETH_ADDRS);
|
||||
|
||||
flow->flags |= BNXT_TC_FLOW_FLAGS_ETH_ADDRS;
|
||||
ether_addr_copy(flow->l2_key.dmac, key->dst);
|
||||
ether_addr_copy(flow->l2_mask.dmac, mask->dst);
|
||||
ether_addr_copy(flow->l2_key.smac, key->src);
|
||||
ether_addr_copy(flow->l2_mask.smac, mask->src);
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_VLAN)) {
|
||||
struct flow_dissector_key_vlan *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_VLAN);
|
||||
struct flow_dissector_key_vlan *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_VLAN);
|
||||
|
||||
flow->l2_key.inner_vlan_tci =
|
||||
cpu_to_be16(VLAN_TCI(key->vlan_id, key->vlan_priority));
|
||||
flow->l2_mask.inner_vlan_tci =
|
||||
cpu_to_be16((VLAN_TCI(mask->vlan_id, mask->vlan_priority)));
|
||||
flow->l2_key.inner_vlan_tpid = htons(ETH_P_8021Q);
|
||||
flow->l2_mask.inner_vlan_tpid = htons(0xffff);
|
||||
flow->l2_key.num_vlans = 1;
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {
|
||||
struct flow_dissector_key_ipv4_addrs *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV4_ADDRS);
|
||||
struct flow_dissector_key_ipv4_addrs *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV4_ADDRS);
|
||||
|
||||
flow->flags |= BNXT_TC_FLOW_FLAGS_IPV4_ADDRS;
|
||||
flow->l3_key.ipv4.daddr.s_addr = key->dst;
|
||||
flow->l3_mask.ipv4.daddr.s_addr = mask->dst;
|
||||
flow->l3_key.ipv4.saddr.s_addr = key->src;
|
||||
flow->l3_mask.ipv4.saddr.s_addr = mask->src;
|
||||
} else if (dissector_uses_key(dissector,
|
||||
FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {
|
||||
struct flow_dissector_key_ipv6_addrs *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV6_ADDRS);
|
||||
struct flow_dissector_key_ipv6_addrs *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV6_ADDRS);
|
||||
|
||||
flow->flags |= BNXT_TC_FLOW_FLAGS_IPV6_ADDRS;
|
||||
flow->l3_key.ipv6.daddr = key->dst;
|
||||
flow->l3_mask.ipv6.daddr = mask->dst;
|
||||
flow->l3_key.ipv6.saddr = key->src;
|
||||
flow->l3_mask.ipv6.saddr = mask->src;
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_PORTS)) {
|
||||
struct flow_dissector_key_ports *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_PORTS);
|
||||
struct flow_dissector_key_ports *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_PORTS);
|
||||
|
||||
flow->flags |= BNXT_TC_FLOW_FLAGS_PORTS;
|
||||
flow->l4_key.ports.dport = key->dst;
|
||||
flow->l4_mask.ports.dport = mask->dst;
|
||||
flow->l4_key.ports.sport = key->src;
|
||||
flow->l4_mask.ports.sport = mask->src;
|
||||
}
|
||||
|
||||
if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ICMP)) {
|
||||
struct flow_dissector_key_icmp *key =
|
||||
GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ICMP);
|
||||
struct flow_dissector_key_icmp *mask =
|
||||
GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ICMP);
|
||||
|
||||
flow->flags |= BNXT_TC_FLOW_FLAGS_ICMP;
|
||||
flow->l4_key.icmp.type = key->type;
|
||||
flow->l4_key.icmp.code = key->code;
|
||||
flow->l4_mask.icmp.type = mask->type;
|
||||
flow->l4_mask.icmp.code = mask->code;
|
||||
}
|
||||
|
||||
return bnxt_tc_parse_actions(bp, &flow->actions, tc_flow_cmd->exts);
|
||||
}
|
||||
|
||||
static int bnxt_hwrm_cfa_flow_free(struct bnxt *bp, __le16 flow_handle)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bnxt_hwrm_cfa_flow_alloc(struct bnxt *bp, struct bnxt_tc_flow *flow,
|
||||
__le16 ref_flow_handle, __le16 *flow_handle)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bnxt_tc_put_l2_node(struct bnxt *bp,
|
||||
struct bnxt_tc_flow_node *flow_node)
|
||||
{
|
||||
struct bnxt_tc_l2_node *l2_node = flow_node->l2_node;
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
int rc;
|
||||
|
||||
/* remove flow_node from the L2 shared flow list */
|
||||
list_del(&flow_node->l2_list_node);
|
||||
if (--l2_node->refcount == 0) {
|
||||
rc = rhashtable_remove_fast(&tc_info->l2_table, &l2_node->node,
|
||||
tc_info->l2_ht_params);
|
||||
if (rc)
|
||||
netdev_err(bp->dev,
|
||||
"Error: %s: rhashtable_remove_fast: %d",
|
||||
__func__, rc);
|
||||
kfree_rcu(l2_node, rcu);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct bnxt_tc_l2_node *
|
||||
bnxt_tc_get_l2_node(struct bnxt *bp, struct rhashtable *l2_table,
|
||||
struct rhashtable_params ht_params,
|
||||
struct bnxt_tc_l2_key *l2_key)
|
||||
{
|
||||
struct bnxt_tc_l2_node *l2_node;
|
||||
int rc;
|
||||
|
||||
l2_node = rhashtable_lookup_fast(l2_table, l2_key, ht_params);
|
||||
if (!l2_node) {
|
||||
l2_node = kzalloc(sizeof(*l2_node), GFP_KERNEL);
|
||||
if (!l2_node) {
|
||||
rc = -ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
l2_node->key = *l2_key;
|
||||
rc = rhashtable_insert_fast(l2_table, &l2_node->node,
|
||||
ht_params);
|
||||
if (rc) {
|
||||
kfree(l2_node);
|
||||
netdev_err(bp->dev,
|
||||
"Error: %s: rhashtable_insert_fast: %d",
|
||||
__func__, rc);
|
||||
return NULL;
|
||||
}
|
||||
INIT_LIST_HEAD(&l2_node->common_l2_flows);
|
||||
}
|
||||
return l2_node;
|
||||
}
|
||||
|
||||
/* Get the ref_flow_handle for a flow by checking if there are any other
|
||||
* flows that share the same L2 key as this flow.
|
||||
*/
|
||||
static int
|
||||
bnxt_tc_get_ref_flow_handle(struct bnxt *bp, struct bnxt_tc_flow *flow,
|
||||
struct bnxt_tc_flow_node *flow_node,
|
||||
__le16 *ref_flow_handle)
|
||||
{
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
struct bnxt_tc_flow_node *ref_flow_node;
|
||||
struct bnxt_tc_l2_node *l2_node;
|
||||
|
||||
l2_node = bnxt_tc_get_l2_node(bp, &tc_info->l2_table,
|
||||
tc_info->l2_ht_params,
|
||||
&flow->l2_key);
|
||||
if (!l2_node)
|
||||
return -1;
|
||||
|
||||
/* If any other flow is using this l2_node, use it's flow_handle
|
||||
* as the ref_flow_handle
|
||||
*/
|
||||
if (l2_node->refcount > 0) {
|
||||
ref_flow_node = list_first_entry(&l2_node->common_l2_flows,
|
||||
struct bnxt_tc_flow_node,
|
||||
l2_list_node);
|
||||
*ref_flow_handle = ref_flow_node->flow_handle;
|
||||
} else {
|
||||
*ref_flow_handle = cpu_to_le16(0xffff);
|
||||
}
|
||||
|
||||
/* Insert the l2_node into the flow_node so that subsequent flows
|
||||
* with a matching l2 key can use the flow_handle of this flow
|
||||
* as their ref_flow_handle
|
||||
*/
|
||||
flow_node->l2_node = l2_node;
|
||||
list_add(&flow_node->l2_list_node, &l2_node->common_l2_flows);
|
||||
l2_node->refcount++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* After the flow parsing is done, this routine is used for checking
|
||||
* if there are any aspects of the flow that prevent it from being
|
||||
* offloaded.
|
||||
*/
|
||||
static bool bnxt_tc_can_offload(struct bnxt *bp, struct bnxt_tc_flow *flow)
|
||||
{
|
||||
/* If L4 ports are specified then ip_proto must be TCP or UDP */
|
||||
if ((flow->flags & BNXT_TC_FLOW_FLAGS_PORTS) &&
|
||||
(flow->l4_key.ip_proto != IPPROTO_TCP &&
|
||||
flow->l4_key.ip_proto != IPPROTO_UDP)) {
|
||||
netdev_info(bp->dev, "Cannot offload non-TCP/UDP (%d) ports",
|
||||
flow->l4_key.ip_proto);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static int __bnxt_tc_del_flow(struct bnxt *bp,
|
||||
struct bnxt_tc_flow_node *flow_node)
|
||||
{
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
int rc;
|
||||
|
||||
/* send HWRM cmd to free the flow-id */
|
||||
bnxt_hwrm_cfa_flow_free(bp, flow_node->flow_handle);
|
||||
|
||||
mutex_lock(&tc_info->lock);
|
||||
|
||||
/* release reference to l2 node */
|
||||
bnxt_tc_put_l2_node(bp, flow_node);
|
||||
|
||||
mutex_unlock(&tc_info->lock);
|
||||
|
||||
rc = rhashtable_remove_fast(&tc_info->flow_table, &flow_node->node,
|
||||
tc_info->flow_ht_params);
|
||||
if (rc)
|
||||
netdev_err(bp->dev, "Error: %s: rhashtable_remove_fast rc=%d",
|
||||
__func__, rc);
|
||||
|
||||
kfree_rcu(flow_node, rcu);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Add a new flow or replace an existing flow.
|
||||
* Notes on locking:
|
||||
* There are essentially two critical sections here.
|
||||
* 1. while adding a new flow
|
||||
* a) lookup l2-key
|
||||
* b) issue HWRM cmd and get flow_handle
|
||||
* c) link l2-key with flow
|
||||
* 2. while deleting a flow
|
||||
* a) unlinking l2-key from flow
|
||||
* A lock is needed to protect these two critical sections.
|
||||
*
|
||||
* The hash-tables are already protected by the rhashtable API.
|
||||
*/
|
||||
static int bnxt_tc_add_flow(struct bnxt *bp, u16 src_fid,
|
||||
struct tc_cls_flower_offload *tc_flow_cmd)
|
||||
{
|
||||
struct bnxt_tc_flow_node *new_node, *old_node;
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
struct bnxt_tc_flow *flow;
|
||||
__le16 ref_flow_handle;
|
||||
int rc;
|
||||
|
||||
/* allocate memory for the new flow and it's node */
|
||||
new_node = kzalloc(sizeof(*new_node), GFP_KERNEL);
|
||||
if (!new_node) {
|
||||
rc = -ENOMEM;
|
||||
goto done;
|
||||
}
|
||||
new_node->cookie = tc_flow_cmd->cookie;
|
||||
flow = &new_node->flow;
|
||||
|
||||
rc = bnxt_tc_parse_flow(bp, tc_flow_cmd, flow);
|
||||
if (rc)
|
||||
goto free_node;
|
||||
flow->src_fid = src_fid;
|
||||
|
||||
if (!bnxt_tc_can_offload(bp, flow)) {
|
||||
rc = -ENOSPC;
|
||||
goto free_node;
|
||||
}
|
||||
|
||||
/* If a flow exists with the same cookie, delete it */
|
||||
old_node = rhashtable_lookup_fast(&tc_info->flow_table,
|
||||
&tc_flow_cmd->cookie,
|
||||
tc_info->flow_ht_params);
|
||||
if (old_node)
|
||||
__bnxt_tc_del_flow(bp, old_node);
|
||||
|
||||
/* Check if the L2 part of the flow has been offloaded already.
|
||||
* If so, bump up it's refcnt and get it's reference handle.
|
||||
*/
|
||||
mutex_lock(&tc_info->lock);
|
||||
rc = bnxt_tc_get_ref_flow_handle(bp, flow, new_node, &ref_flow_handle);
|
||||
if (rc)
|
||||
goto unlock;
|
||||
|
||||
/* send HWRM cmd to alloc the flow */
|
||||
rc = bnxt_hwrm_cfa_flow_alloc(bp, flow, ref_flow_handle,
|
||||
&new_node->flow_handle);
|
||||
if (rc)
|
||||
goto put_l2;
|
||||
|
||||
/* add new flow to flow-table */
|
||||
rc = rhashtable_insert_fast(&tc_info->flow_table, &new_node->node,
|
||||
tc_info->flow_ht_params);
|
||||
if (rc)
|
||||
goto hwrm_flow_free;
|
||||
|
||||
mutex_unlock(&tc_info->lock);
|
||||
return 0;
|
||||
|
||||
hwrm_flow_free:
|
||||
bnxt_hwrm_cfa_flow_free(bp, new_node->flow_handle);
|
||||
put_l2:
|
||||
bnxt_tc_put_l2_node(bp, new_node);
|
||||
unlock:
|
||||
mutex_unlock(&tc_info->lock);
|
||||
free_node:
|
||||
kfree(new_node);
|
||||
done:
|
||||
netdev_err(bp->dev, "Error: %s: cookie=0x%lx error=%d",
|
||||
__func__, tc_flow_cmd->cookie, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int bnxt_tc_del_flow(struct bnxt *bp,
|
||||
struct tc_cls_flower_offload *tc_flow_cmd)
|
||||
{
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
struct bnxt_tc_flow_node *flow_node;
|
||||
|
||||
flow_node = rhashtable_lookup_fast(&tc_info->flow_table,
|
||||
&tc_flow_cmd->cookie,
|
||||
tc_info->flow_ht_params);
|
||||
if (!flow_node) {
|
||||
netdev_info(bp->dev, "ERROR: no flow_node for cookie %lx",
|
||||
tc_flow_cmd->cookie);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return __bnxt_tc_del_flow(bp, flow_node);
|
||||
}
|
||||
|
||||
static int bnxt_tc_get_flow_stats(struct bnxt *bp,
|
||||
struct tc_cls_flower_offload *tc_flow_cmd)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bnxt_tc_setup_flower(struct bnxt *bp, u16 src_fid,
|
||||
struct tc_cls_flower_offload *cls_flower)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
switch (cls_flower->command) {
|
||||
case TC_CLSFLOWER_REPLACE:
|
||||
rc = bnxt_tc_add_flow(bp, src_fid, cls_flower);
|
||||
break;
|
||||
|
||||
case TC_CLSFLOWER_DESTROY:
|
||||
rc = bnxt_tc_del_flow(bp, cls_flower);
|
||||
break;
|
||||
|
||||
case TC_CLSFLOWER_STATS:
|
||||
rc = bnxt_tc_get_flow_stats(bp, cls_flower);
|
||||
break;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
static const struct rhashtable_params bnxt_tc_flow_ht_params = {
|
||||
.head_offset = offsetof(struct bnxt_tc_flow_node, node),
|
||||
.key_offset = offsetof(struct bnxt_tc_flow_node, cookie),
|
||||
.key_len = sizeof(((struct bnxt_tc_flow_node *)0)->cookie),
|
||||
.automatic_shrinking = true
|
||||
};
|
||||
|
||||
static const struct rhashtable_params bnxt_tc_l2_ht_params = {
|
||||
.head_offset = offsetof(struct bnxt_tc_l2_node, node),
|
||||
.key_offset = offsetof(struct bnxt_tc_l2_node, key),
|
||||
.key_len = BNXT_TC_L2_KEY_LEN,
|
||||
.automatic_shrinking = true
|
||||
};
|
||||
|
||||
/* convert counter width in bits to a mask */
|
||||
#define mask(width) ((u64)~0 >> (64 - (width)))
|
||||
|
||||
int bnxt_init_tc(struct bnxt *bp)
|
||||
{
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
int rc;
|
||||
|
||||
if (bp->hwrm_spec_code < 0x10800) {
|
||||
netdev_warn(bp->dev,
|
||||
"Firmware does not support TC flower offload.\n");
|
||||
return -ENOTSUPP;
|
||||
}
|
||||
mutex_init(&tc_info->lock);
|
||||
|
||||
/* Counter widths are programmed by FW */
|
||||
tc_info->bytes_mask = mask(36);
|
||||
tc_info->packets_mask = mask(28);
|
||||
|
||||
tc_info->flow_ht_params = bnxt_tc_flow_ht_params;
|
||||
rc = rhashtable_init(&tc_info->flow_table, &tc_info->flow_ht_params);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
tc_info->l2_ht_params = bnxt_tc_l2_ht_params;
|
||||
rc = rhashtable_init(&tc_info->l2_table, &tc_info->l2_ht_params);
|
||||
if (rc)
|
||||
goto destroy_flow_table;
|
||||
|
||||
tc_info->enabled = true;
|
||||
bp->dev->hw_features |= NETIF_F_HW_TC;
|
||||
bp->dev->features |= NETIF_F_HW_TC;
|
||||
return 0;
|
||||
|
||||
destroy_flow_table:
|
||||
rhashtable_destroy(&tc_info->flow_table);
|
||||
return rc;
|
||||
}
|
||||
|
||||
void bnxt_shutdown_tc(struct bnxt *bp)
|
||||
{
|
||||
struct bnxt_tc_info *tc_info = &bp->tc_info;
|
||||
|
||||
if (!tc_info->enabled)
|
||||
return;
|
||||
|
||||
rhashtable_destroy(&tc_info->flow_table);
|
||||
rhashtable_destroy(&tc_info->l2_table);
|
||||
}
|
||||
|
||||
#else
|
||||
#endif
|
||||
|
|
@ -0,0 +1,158 @@
|
|||
/* Broadcom NetXtreme-C/E network driver.
|
||||
*
|
||||
* Copyright (c) 2017 Broadcom Limited
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#ifndef BNXT_TC_H
|
||||
#define BNXT_TC_H
|
||||
|
||||
#ifdef CONFIG_BNXT_FLOWER_OFFLOAD
|
||||
|
||||
/* Structs used for storing the filter/actions of the TC cmd.
|
||||
*/
|
||||
struct bnxt_tc_l2_key {
|
||||
u8 dmac[ETH_ALEN];
|
||||
u8 smac[ETH_ALEN];
|
||||
__be16 inner_vlan_tpid;
|
||||
__be16 inner_vlan_tci;
|
||||
__be16 ether_type;
|
||||
u8 num_vlans;
|
||||
};
|
||||
|
||||
struct bnxt_tc_l3_key {
|
||||
union {
|
||||
struct {
|
||||
struct in_addr daddr;
|
||||
struct in_addr saddr;
|
||||
} ipv4;
|
||||
struct {
|
||||
struct in6_addr daddr;
|
||||
struct in6_addr saddr;
|
||||
} ipv6;
|
||||
};
|
||||
};
|
||||
|
||||
struct bnxt_tc_l4_key {
|
||||
u8 ip_proto;
|
||||
union {
|
||||
struct {
|
||||
__be16 sport;
|
||||
__be16 dport;
|
||||
} ports;
|
||||
struct {
|
||||
u8 type;
|
||||
u8 code;
|
||||
} icmp;
|
||||
};
|
||||
};
|
||||
|
||||
struct bnxt_tc_actions {
|
||||
u32 flags;
|
||||
#define BNXT_TC_ACTION_FLAG_FWD BIT(0)
|
||||
#define BNXT_TC_ACTION_FLAG_FWD_VXLAN BIT(1)
|
||||
#define BNXT_TC_ACTION_FLAG_PUSH_VLAN BIT(3)
|
||||
#define BNXT_TC_ACTION_FLAG_POP_VLAN BIT(4)
|
||||
#define BNXT_TC_ACTION_FLAG_DROP BIT(5)
|
||||
|
||||
u16 dst_fid;
|
||||
struct net_device *dst_dev;
|
||||
__be16 push_vlan_tpid;
|
||||
__be16 push_vlan_tci;
|
||||
};
|
||||
|
||||
struct bnxt_tc_flow_stats {
|
||||
u64 packets;
|
||||
u64 bytes;
|
||||
};
|
||||
|
||||
struct bnxt_tc_flow {
|
||||
u32 flags;
|
||||
#define BNXT_TC_FLOW_FLAGS_ETH_ADDRS BIT(1)
|
||||
#define BNXT_TC_FLOW_FLAGS_IPV4_ADDRS BIT(2)
|
||||
#define BNXT_TC_FLOW_FLAGS_IPV6_ADDRS BIT(3)
|
||||
#define BNXT_TC_FLOW_FLAGS_PORTS BIT(4)
|
||||
#define BNXT_TC_FLOW_FLAGS_ICMP BIT(5)
|
||||
|
||||
/* flow applicable to pkts ingressing on this fid */
|
||||
u16 src_fid;
|
||||
struct bnxt_tc_l2_key l2_key;
|
||||
struct bnxt_tc_l2_key l2_mask;
|
||||
struct bnxt_tc_l3_key l3_key;
|
||||
struct bnxt_tc_l3_key l3_mask;
|
||||
struct bnxt_tc_l4_key l4_key;
|
||||
struct bnxt_tc_l4_key l4_mask;
|
||||
|
||||
struct bnxt_tc_actions actions;
|
||||
|
||||
/* updated stats accounting for hw-counter wrap-around */
|
||||
struct bnxt_tc_flow_stats stats;
|
||||
/* previous snap-shot of stats */
|
||||
struct bnxt_tc_flow_stats prev_stats;
|
||||
unsigned long lastused; /* jiffies */
|
||||
};
|
||||
|
||||
/* L2 hash table
|
||||
* This data-struct is used for L2-flow table.
|
||||
* The L2 part of a flow is stored in a hash table.
|
||||
* A flow that shares the same L2 key/mask with an
|
||||
* already existing flow must refer to it's flow handle.
|
||||
*/
|
||||
struct bnxt_tc_l2_node {
|
||||
/* hash key: first 16b of key */
|
||||
#define BNXT_TC_L2_KEY_LEN 16
|
||||
struct bnxt_tc_l2_key key;
|
||||
struct rhash_head node;
|
||||
|
||||
/* a linked list of flows that share the same l2 key */
|
||||
struct list_head common_l2_flows;
|
||||
|
||||
/* number of flows sharing the l2 key */
|
||||
u16 refcount;
|
||||
|
||||
struct rcu_head rcu;
|
||||
};
|
||||
|
||||
struct bnxt_tc_flow_node {
|
||||
/* hash key: provided by TC */
|
||||
unsigned long cookie;
|
||||
struct rhash_head node;
|
||||
|
||||
struct bnxt_tc_flow flow;
|
||||
|
||||
__le16 flow_handle;
|
||||
|
||||
/* L2 node in l2 hashtable that shares flow's l2 key */
|
||||
struct bnxt_tc_l2_node *l2_node;
|
||||
/* for the shared_flows list maintained in l2_node */
|
||||
struct list_head l2_list_node;
|
||||
|
||||
struct rcu_head rcu;
|
||||
};
|
||||
|
||||
int bnxt_tc_setup_flower(struct bnxt *bp, u16 src_fid,
|
||||
struct tc_cls_flower_offload *cls_flower);
|
||||
int bnxt_init_tc(struct bnxt *bp);
|
||||
void bnxt_shutdown_tc(struct bnxt *bp);
|
||||
|
||||
#else /* CONFIG_BNXT_FLOWER_OFFLOAD */
|
||||
|
||||
static inline int bnxt_tc_setup_flower(struct bnxt *bp, u16 src_fid,
|
||||
struct tc_cls_flower_offload *cls_flower)
|
||||
{
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static inline int bnxt_init_tc(struct bnxt *bp)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void bnxt_shutdown_tc(struct bnxt *bp)
|
||||
{
|
||||
}
|
||||
#endif /* CONFIG_BNXT_FLOWER_OFFLOAD */
|
||||
#endif /* BNXT_TC_H */
|
||||
|
|
@ -11,10 +11,12 @@
|
|||
#include <linux/etherdevice.h>
|
||||
#include <linux/rtnetlink.h>
|
||||
#include <linux/jhash.h>
|
||||
#include <net/pkt_cls.h>
|
||||
|
||||
#include "bnxt_hsi.h"
|
||||
#include "bnxt.h"
|
||||
#include "bnxt_vfr.h"
|
||||
#include "bnxt_tc.h"
|
||||
|
||||
#ifdef CONFIG_BNXT_SRIOV
|
||||
|
||||
|
|
@ -113,6 +115,21 @@ bnxt_vf_rep_get_stats64(struct net_device *dev,
|
|||
stats->tx_bytes = vf_rep->tx_stats.bytes;
|
||||
}
|
||||
|
||||
static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
|
||||
void *type_data)
|
||||
{
|
||||
struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
|
||||
struct bnxt *bp = vf_rep->bp;
|
||||
int vf_fid = bp->pf.vf[vf_rep->vf_idx].fw_fid;
|
||||
|
||||
switch (type) {
|
||||
case TC_SETUP_CLSFLOWER:
|
||||
return bnxt_tc_setup_flower(bp, vf_fid, type_data);
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
}
|
||||
|
||||
struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code)
|
||||
{
|
||||
u16 vf_idx;
|
||||
|
|
@ -182,6 +199,7 @@ static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
|
|||
.ndo_stop = bnxt_vf_rep_close,
|
||||
.ndo_start_xmit = bnxt_vf_rep_xmit,
|
||||
.ndo_get_stats64 = bnxt_vf_rep_get_stats64,
|
||||
.ndo_setup_tc = bnxt_vf_rep_setup_tc,
|
||||
.ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -45,6 +45,14 @@ void bnxt_vf_reps_open(struct bnxt *bp);
|
|||
void bnxt_vf_rep_rx(struct bnxt *bp, struct sk_buff *skb);
|
||||
struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code);
|
||||
|
||||
static inline u16 bnxt_vf_rep_get_fid(struct net_device *dev)
|
||||
{
|
||||
struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
|
||||
struct bnxt *bp = vf_rep->bp;
|
||||
|
||||
return bp->pf.vf[vf_rep->vf_idx].fw_fid;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static inline int bnxt_dl_register(struct bnxt *bp)
|
||||
|
|
|
|||
Loading…
Reference in New Issue