Merge branch 'cxgb4-tc-flower'
Rahul Lakkireddy says: ==================== cxgb4: add support to offload tc flower This series of patches add support to offload tc flower onto Chelsio NICs. Patch 1 adds basic skeleton to prepare for offloading tc flower flows. Patch 2 adds support to add/remove flows for offload. Flows can have accompanying masks. Following match and action are currently supported for offload: Match: ether-protocol, IPv4/IPv6 addresses, L4 ports (TCP/UDP) Action: drop, redirect to another port on the device. Patch 3 adds support to offload tc-flower flows having vlan actions: pop, push, and modify. Patch 4 adds support to fetch stats for the offloaded tc flower flows from hardware. Support for offloading more match and action types are to be followed in subsequent series. v2: - Setting ftid to -1 not required after bitmap_find_free_region in cxgb4_get_free_ftid. - Direct return can be used as jumping to error path is not needed if flower entry allocation failed in cxgb4_tc_flower_replace. Same applies if flower entry not found in cxgb4_tc_flower_destroy. - Also, removed an extra return from cxgb4_tc_flower_destroy. - Avoid wrapping line for netdev_err message. Also, use consistent error message string. ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
commit
cddd95231f
|
|
@ -4,7 +4,9 @@
|
|||
|
||||
obj-$(CONFIG_CHELSIO_T4) += cxgb4.o
|
||||
|
||||
cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o cxgb4_uld.o sched.o cxgb4_filter.o cxgb4_tc_u32.o cxgb4_ptp.o
|
||||
cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o \
|
||||
cxgb4_uld.o sched.o cxgb4_filter.o cxgb4_tc_u32.o \
|
||||
cxgb4_ptp.o cxgb4_tc_flower.o
|
||||
cxgb4-$(CONFIG_CHELSIO_T4_DCB) += cxgb4_dcb.o
|
||||
cxgb4-$(CONFIG_CHELSIO_T4_FCOE) += cxgb4_fcoe.o
|
||||
cxgb4-$(CONFIG_DEBUG_FS) += cxgb4_debugfs.o
|
||||
|
|
|
|||
|
|
@ -905,6 +905,10 @@ struct adapter {
|
|||
/* TC u32 offload */
|
||||
struct cxgb4_tc_u32_table *tc_u32;
|
||||
struct chcr_stats_debug chcr_stats;
|
||||
|
||||
/* TC flower offload */
|
||||
DECLARE_HASHTABLE(flower_anymatch_tbl, 9);
|
||||
struct timer_list flower_stats_timer;
|
||||
};
|
||||
|
||||
/* Support for "sched-class" command to allow a TX Scheduling Class to be
|
||||
|
|
|
|||
|
|
@ -148,6 +148,106 @@ static int get_filter_steerq(struct net_device *dev,
|
|||
return iq;
|
||||
}
|
||||
|
||||
static int get_filter_count(struct adapter *adapter, unsigned int fidx,
|
||||
u64 *pkts, u64 *bytes)
|
||||
{
|
||||
unsigned int tcb_base, tcbaddr;
|
||||
unsigned int word_offset;
|
||||
struct filter_entry *f;
|
||||
__be64 be64_byte_count;
|
||||
int ret;
|
||||
|
||||
tcb_base = t4_read_reg(adapter, TP_CMM_TCB_BASE_A);
|
||||
if ((fidx != (adapter->tids.nftids + adapter->tids.nsftids - 1)) &&
|
||||
fidx >= adapter->tids.nftids)
|
||||
return -E2BIG;
|
||||
|
||||
f = &adapter->tids.ftid_tab[fidx];
|
||||
if (!f->valid)
|
||||
return -EINVAL;
|
||||
|
||||
tcbaddr = tcb_base + f->tid * TCB_SIZE;
|
||||
|
||||
spin_lock(&adapter->win0_lock);
|
||||
if (is_t4(adapter->params.chip)) {
|
||||
__be64 be64_count;
|
||||
|
||||
/* T4 doesn't maintain byte counts in hw */
|
||||
*bytes = 0;
|
||||
|
||||
/* Get pkts */
|
||||
word_offset = 4;
|
||||
ret = t4_memory_rw(adapter, MEMWIN_NIC, MEM_EDC0,
|
||||
tcbaddr + (word_offset * sizeof(__be32)),
|
||||
sizeof(be64_count),
|
||||
(__be32 *)&be64_count,
|
||||
T4_MEMORY_READ);
|
||||
if (ret < 0)
|
||||
goto out;
|
||||
*pkts = be64_to_cpu(be64_count);
|
||||
} else {
|
||||
__be32 be32_count;
|
||||
|
||||
/* Get bytes */
|
||||
word_offset = 4;
|
||||
ret = t4_memory_rw(adapter, MEMWIN_NIC, MEM_EDC0,
|
||||
tcbaddr + (word_offset * sizeof(__be32)),
|
||||
sizeof(be64_byte_count),
|
||||
&be64_byte_count,
|
||||
T4_MEMORY_READ);
|
||||
if (ret < 0)
|
||||
goto out;
|
||||
*bytes = be64_to_cpu(be64_byte_count);
|
||||
|
||||
/* Get pkts */
|
||||
word_offset = 6;
|
||||
ret = t4_memory_rw(adapter, MEMWIN_NIC, MEM_EDC0,
|
||||
tcbaddr + (word_offset * sizeof(__be32)),
|
||||
sizeof(be32_count),
|
||||
&be32_count,
|
||||
T4_MEMORY_READ);
|
||||
if (ret < 0)
|
||||
goto out;
|
||||
*pkts = (u64)be32_to_cpu(be32_count);
|
||||
}
|
||||
|
||||
out:
|
||||
spin_unlock(&adapter->win0_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int cxgb4_get_filter_counters(struct net_device *dev, unsigned int fidx,
|
||||
u64 *hitcnt, u64 *bytecnt)
|
||||
{
|
||||
struct adapter *adapter = netdev2adap(dev);
|
||||
|
||||
return get_filter_count(adapter, fidx, hitcnt, bytecnt);
|
||||
}
|
||||
|
||||
int cxgb4_get_free_ftid(struct net_device *dev, int family)
|
||||
{
|
||||
struct adapter *adap = netdev2adap(dev);
|
||||
struct tid_info *t = &adap->tids;
|
||||
int ftid;
|
||||
|
||||
spin_lock_bh(&t->ftid_lock);
|
||||
if (family == PF_INET) {
|
||||
ftid = find_first_zero_bit(t->ftid_bmap, t->nftids);
|
||||
if (ftid >= t->nftids)
|
||||
ftid = -1;
|
||||
} else {
|
||||
ftid = bitmap_find_free_region(t->ftid_bmap, t->nftids, 2);
|
||||
if (ftid < 0)
|
||||
goto out_unlock;
|
||||
|
||||
/* this is only a lookup, keep the found region unallocated */
|
||||
bitmap_release_region(t->ftid_bmap, ftid, 2);
|
||||
}
|
||||
out_unlock:
|
||||
spin_unlock_bh(&t->ftid_lock);
|
||||
return ftid;
|
||||
}
|
||||
|
||||
static int cxgb4_set_ftid(struct tid_info *t, int fidx, int family)
|
||||
{
|
||||
spin_lock_bh(&t->ftid_lock);
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@
|
|||
#include "l2t.h"
|
||||
#include "sched.h"
|
||||
#include "cxgb4_tc_u32.h"
|
||||
#include "cxgb4_tc_flower.h"
|
||||
#include "cxgb4_ptp.h"
|
||||
|
||||
char cxgb4_driver_name[] = KBUILD_MODNAME;
|
||||
|
|
@ -2873,6 +2874,25 @@ static int cxgb_set_tx_maxrate(struct net_device *dev, int index, u32 rate)
|
|||
return err;
|
||||
}
|
||||
|
||||
static int cxgb_setup_tc_flower(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls_flower)
|
||||
{
|
||||
if (!is_classid_clsact_ingress(cls_flower->common.classid) ||
|
||||
cls_flower->common.chain_index)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
switch (cls_flower->command) {
|
||||
case TC_CLSFLOWER_REPLACE:
|
||||
return cxgb4_tc_flower_replace(dev, cls_flower);
|
||||
case TC_CLSFLOWER_DESTROY:
|
||||
return cxgb4_tc_flower_destroy(dev, cls_flower);
|
||||
case TC_CLSFLOWER_STATS:
|
||||
return cxgb4_tc_flower_stats(dev, cls_flower);
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
}
|
||||
|
||||
static int cxgb_setup_tc_cls_u32(struct net_device *dev,
|
||||
struct tc_cls_u32_offload *cls_u32)
|
||||
{
|
||||
|
|
@ -2907,6 +2927,8 @@ static int cxgb_setup_tc(struct net_device *dev, enum tc_setup_type type,
|
|||
switch (type) {
|
||||
case TC_SETUP_CLSU32:
|
||||
return cxgb_setup_tc_cls_u32(dev, type_data);
|
||||
case TC_SETUP_CLSFLOWER:
|
||||
return cxgb_setup_tc_flower(dev, type_data);
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
|
@ -4615,6 +4637,7 @@ static void free_some_resources(struct adapter *adapter)
|
|||
kvfree(adapter->l2t);
|
||||
t4_cleanup_sched(adapter);
|
||||
kvfree(adapter->tids.tid_tab);
|
||||
cxgb4_cleanup_tc_flower(adapter);
|
||||
cxgb4_cleanup_tc_u32(adapter);
|
||||
kfree(adapter->sge.egr_map);
|
||||
kfree(adapter->sge.ingr_map);
|
||||
|
|
@ -5083,6 +5106,8 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
if (!adapter->tc_u32)
|
||||
dev_warn(&pdev->dev,
|
||||
"could not offload tc u32, continuing\n");
|
||||
|
||||
cxgb4_init_tc_flower(adapter);
|
||||
}
|
||||
|
||||
if (is_offload(adapter)) {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,452 @@
|
|||
/*
|
||||
* This file is part of the Chelsio T4/T5/T6 Ethernet driver for Linux.
|
||||
*
|
||||
* Copyright (c) 2017 Chelsio Communications, Inc. All rights reserved.
|
||||
*
|
||||
* This software is available to you under a choice of one of two
|
||||
* licenses. You may choose to be licensed under the terms of the GNU
|
||||
* General Public License (GPL) Version 2, available from the file
|
||||
* COPYING in the main directory of this source tree, or the
|
||||
* OpenIB.org BSD license below:
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or
|
||||
* without modification, are permitted provided that the following
|
||||
* conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer.
|
||||
*
|
||||
* - Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <net/tc_act/tc_gact.h>
|
||||
#include <net/tc_act/tc_mirred.h>
|
||||
#include <net/tc_act/tc_vlan.h>
|
||||
|
||||
#include "cxgb4.h"
|
||||
#include "cxgb4_tc_flower.h"
|
||||
|
||||
#define STATS_CHECK_PERIOD (HZ / 2)
|
||||
|
||||
static struct ch_tc_flower_entry *allocate_flower_entry(void)
|
||||
{
|
||||
struct ch_tc_flower_entry *new = kzalloc(sizeof(*new), GFP_KERNEL);
|
||||
spin_lock_init(&new->lock);
|
||||
return new;
|
||||
}
|
||||
|
||||
/* Must be called with either RTNL or rcu_read_lock */
|
||||
static struct ch_tc_flower_entry *ch_flower_lookup(struct adapter *adap,
|
||||
unsigned long flower_cookie)
|
||||
{
|
||||
struct ch_tc_flower_entry *flower_entry;
|
||||
|
||||
hash_for_each_possible_rcu(adap->flower_anymatch_tbl, flower_entry,
|
||||
link, flower_cookie)
|
||||
if (flower_entry->tc_flower_cookie == flower_cookie)
|
||||
return flower_entry;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void cxgb4_process_flow_match(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls,
|
||||
struct ch_filter_specification *fs)
|
||||
{
|
||||
u16 addr_type = 0;
|
||||
|
||||
if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_CONTROL)) {
|
||||
struct flow_dissector_key_control *key =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_CONTROL,
|
||||
cls->key);
|
||||
|
||||
addr_type = key->addr_type;
|
||||
}
|
||||
|
||||
if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_BASIC)) {
|
||||
struct flow_dissector_key_basic *key =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_BASIC,
|
||||
cls->key);
|
||||
struct flow_dissector_key_basic *mask =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_BASIC,
|
||||
cls->mask);
|
||||
u16 ethtype_key = ntohs(key->n_proto);
|
||||
u16 ethtype_mask = ntohs(mask->n_proto);
|
||||
|
||||
if (ethtype_key == ETH_P_ALL) {
|
||||
ethtype_key = 0;
|
||||
ethtype_mask = 0;
|
||||
}
|
||||
|
||||
fs->val.ethtype = ethtype_key;
|
||||
fs->mask.ethtype = ethtype_mask;
|
||||
fs->val.proto = key->ip_proto;
|
||||
fs->mask.proto = mask->ip_proto;
|
||||
}
|
||||
|
||||
if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
|
||||
struct flow_dissector_key_ipv4_addrs *key =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_IPV4_ADDRS,
|
||||
cls->key);
|
||||
struct flow_dissector_key_ipv4_addrs *mask =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_IPV4_ADDRS,
|
||||
cls->mask);
|
||||
fs->type = 0;
|
||||
memcpy(&fs->val.lip[0], &key->dst, sizeof(key->dst));
|
||||
memcpy(&fs->val.fip[0], &key->src, sizeof(key->src));
|
||||
memcpy(&fs->mask.lip[0], &mask->dst, sizeof(mask->dst));
|
||||
memcpy(&fs->mask.fip[0], &mask->src, sizeof(mask->src));
|
||||
}
|
||||
|
||||
if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
|
||||
struct flow_dissector_key_ipv6_addrs *key =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_IPV6_ADDRS,
|
||||
cls->key);
|
||||
struct flow_dissector_key_ipv6_addrs *mask =
|
||||
skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_IPV6_ADDRS,
|
||||
cls->mask);
|
||||
|
||||
fs->type = 1;
|
||||
memcpy(&fs->val.lip[0], key->dst.s6_addr, sizeof(key->dst));
|
||||
memcpy(&fs->val.fip[0], key->src.s6_addr, sizeof(key->src));
|
||||
memcpy(&fs->mask.lip[0], mask->dst.s6_addr, sizeof(mask->dst));
|
||||
memcpy(&fs->mask.fip[0], mask->src.s6_addr, sizeof(mask->src));
|
||||
}
|
||||
|
||||
if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_PORTS)) {
|
||||
struct flow_dissector_key_ports *key, *mask;
|
||||
|
||||
key = skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_PORTS,
|
||||
cls->key);
|
||||
mask = skb_flow_dissector_target(cls->dissector,
|
||||
FLOW_DISSECTOR_KEY_PORTS,
|
||||
cls->mask);
|
||||
fs->val.lport = cpu_to_be16(key->dst);
|
||||
fs->mask.lport = cpu_to_be16(mask->dst);
|
||||
fs->val.fport = cpu_to_be16(key->src);
|
||||
fs->mask.fport = cpu_to_be16(mask->src);
|
||||
}
|
||||
|
||||
/* Match only packets coming from the ingress port where this
|
||||
* filter will be created.
|
||||
*/
|
||||
fs->val.iport = netdev2pinfo(dev)->port_id;
|
||||
fs->mask.iport = ~0;
|
||||
}
|
||||
|
||||
static int cxgb4_validate_flow_match(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls)
|
||||
{
|
||||
if (cls->dissector->used_keys &
|
||||
~(BIT(FLOW_DISSECTOR_KEY_CONTROL) |
|
||||
BIT(FLOW_DISSECTOR_KEY_BASIC) |
|
||||
BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |
|
||||
BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |
|
||||
BIT(FLOW_DISSECTOR_KEY_PORTS))) {
|
||||
netdev_warn(dev, "Unsupported key used: 0x%x\n",
|
||||
cls->dissector->used_keys);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cxgb4_process_flow_actions(struct net_device *in,
|
||||
struct tc_cls_flower_offload *cls,
|
||||
struct ch_filter_specification *fs)
|
||||
{
|
||||
const struct tc_action *a;
|
||||
LIST_HEAD(actions);
|
||||
|
||||
tcf_exts_to_list(cls->exts, &actions);
|
||||
list_for_each_entry(a, &actions, list) {
|
||||
if (is_tcf_gact_shot(a)) {
|
||||
fs->action = FILTER_DROP;
|
||||
} else if (is_tcf_mirred_egress_redirect(a)) {
|
||||
int ifindex = tcf_mirred_ifindex(a);
|
||||
struct net_device *out = __dev_get_by_index(dev_net(in),
|
||||
ifindex);
|
||||
struct port_info *pi = netdev_priv(out);
|
||||
|
||||
fs->action = FILTER_SWITCH;
|
||||
fs->eport = pi->port_id;
|
||||
} else if (is_tcf_vlan(a)) {
|
||||
u32 vlan_action = tcf_vlan_action(a);
|
||||
u8 prio = tcf_vlan_push_prio(a);
|
||||
u16 vid = tcf_vlan_push_vid(a);
|
||||
u16 vlan_tci = (prio << VLAN_PRIO_SHIFT) | vid;
|
||||
|
||||
switch (vlan_action) {
|
||||
case TCA_VLAN_ACT_POP:
|
||||
fs->newvlan |= VLAN_REMOVE;
|
||||
break;
|
||||
case TCA_VLAN_ACT_PUSH:
|
||||
fs->newvlan |= VLAN_INSERT;
|
||||
fs->vlan = vlan_tci;
|
||||
break;
|
||||
case TCA_VLAN_ACT_MODIFY:
|
||||
fs->newvlan |= VLAN_REWRITE;
|
||||
fs->vlan = vlan_tci;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int cxgb4_validate_flow_actions(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls)
|
||||
{
|
||||
const struct tc_action *a;
|
||||
LIST_HEAD(actions);
|
||||
|
||||
tcf_exts_to_list(cls->exts, &actions);
|
||||
list_for_each_entry(a, &actions, list) {
|
||||
if (is_tcf_gact_shot(a)) {
|
||||
/* Do nothing */
|
||||
} else if (is_tcf_mirred_egress_redirect(a)) {
|
||||
struct adapter *adap = netdev2adap(dev);
|
||||
struct net_device *n_dev;
|
||||
unsigned int i, ifindex;
|
||||
bool found = false;
|
||||
|
||||
ifindex = tcf_mirred_ifindex(a);
|
||||
for_each_port(adap, i) {
|
||||
n_dev = adap->port[i];
|
||||
if (ifindex == n_dev->ifindex) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* If interface doesn't belong to our hw, then
|
||||
* the provided output port is not valid
|
||||
*/
|
||||
if (!found) {
|
||||
netdev_err(dev, "%s: Out port invalid\n",
|
||||
__func__);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else if (is_tcf_vlan(a)) {
|
||||
u16 proto = be16_to_cpu(tcf_vlan_push_proto(a));
|
||||
u32 vlan_action = tcf_vlan_action(a);
|
||||
|
||||
switch (vlan_action) {
|
||||
case TCA_VLAN_ACT_POP:
|
||||
break;
|
||||
case TCA_VLAN_ACT_PUSH:
|
||||
case TCA_VLAN_ACT_MODIFY:
|
||||
if (proto != ETH_P_8021Q) {
|
||||
netdev_err(dev, "%s: Unsupported vlan proto\n",
|
||||
__func__);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
netdev_err(dev, "%s: Unsupported vlan action\n",
|
||||
__func__);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
} else {
|
||||
netdev_err(dev, "%s: Unsupported action\n", __func__);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int cxgb4_tc_flower_replace(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls)
|
||||
{
|
||||
struct adapter *adap = netdev2adap(dev);
|
||||
struct ch_tc_flower_entry *ch_flower;
|
||||
struct ch_filter_specification *fs;
|
||||
struct filter_ctx ctx;
|
||||
int fidx;
|
||||
int ret;
|
||||
|
||||
if (cxgb4_validate_flow_actions(dev, cls))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (cxgb4_validate_flow_match(dev, cls))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
ch_flower = allocate_flower_entry();
|
||||
if (!ch_flower) {
|
||||
netdev_err(dev, "%s: ch_flower alloc failed.\n", __func__);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
fs = &ch_flower->fs;
|
||||
fs->hitcnts = 1;
|
||||
cxgb4_process_flow_actions(dev, cls, fs);
|
||||
cxgb4_process_flow_match(dev, cls, fs);
|
||||
|
||||
fidx = cxgb4_get_free_ftid(dev, fs->type ? PF_INET6 : PF_INET);
|
||||
if (fidx < 0) {
|
||||
netdev_err(dev, "%s: No fidx for offload.\n", __func__);
|
||||
ret = -ENOMEM;
|
||||
goto free_entry;
|
||||
}
|
||||
|
||||
init_completion(&ctx.completion);
|
||||
ret = __cxgb4_set_filter(dev, fidx, fs, &ctx);
|
||||
if (ret) {
|
||||
netdev_err(dev, "%s: filter creation err %d\n",
|
||||
__func__, ret);
|
||||
goto free_entry;
|
||||
}
|
||||
|
||||
/* Wait for reply */
|
||||
ret = wait_for_completion_timeout(&ctx.completion, 10 * HZ);
|
||||
if (!ret) {
|
||||
ret = -ETIMEDOUT;
|
||||
goto free_entry;
|
||||
}
|
||||
|
||||
ret = ctx.result;
|
||||
/* Check if hw returned error for filter creation */
|
||||
if (ret) {
|
||||
netdev_err(dev, "%s: filter creation err %d\n",
|
||||
__func__, ret);
|
||||
goto free_entry;
|
||||
}
|
||||
|
||||
INIT_HLIST_NODE(&ch_flower->link);
|
||||
ch_flower->tc_flower_cookie = cls->cookie;
|
||||
ch_flower->filter_id = ctx.tid;
|
||||
hash_add_rcu(adap->flower_anymatch_tbl, &ch_flower->link, cls->cookie);
|
||||
|
||||
return ret;
|
||||
|
||||
free_entry:
|
||||
kfree(ch_flower);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int cxgb4_tc_flower_destroy(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls)
|
||||
{
|
||||
struct adapter *adap = netdev2adap(dev);
|
||||
struct ch_tc_flower_entry *ch_flower;
|
||||
int ret;
|
||||
|
||||
ch_flower = ch_flower_lookup(adap, cls->cookie);
|
||||
if (!ch_flower)
|
||||
return -ENOENT;
|
||||
|
||||
ret = cxgb4_del_filter(dev, ch_flower->filter_id);
|
||||
if (ret)
|
||||
goto err;
|
||||
|
||||
hash_del_rcu(&ch_flower->link);
|
||||
kfree_rcu(ch_flower, rcu);
|
||||
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ch_flower_stats_cb(unsigned long data)
|
||||
{
|
||||
struct adapter *adap = (struct adapter *)data;
|
||||
struct ch_tc_flower_entry *flower_entry;
|
||||
struct ch_tc_flower_stats *ofld_stats;
|
||||
unsigned int i;
|
||||
u64 packets;
|
||||
u64 bytes;
|
||||
int ret;
|
||||
|
||||
rcu_read_lock();
|
||||
hash_for_each_rcu(adap->flower_anymatch_tbl, i, flower_entry, link) {
|
||||
ret = cxgb4_get_filter_counters(adap->port[0],
|
||||
flower_entry->filter_id,
|
||||
&packets, &bytes);
|
||||
if (!ret) {
|
||||
spin_lock(&flower_entry->lock);
|
||||
ofld_stats = &flower_entry->stats;
|
||||
|
||||
if (ofld_stats->prev_packet_count != packets) {
|
||||
ofld_stats->prev_packet_count = packets;
|
||||
ofld_stats->last_used = jiffies;
|
||||
}
|
||||
spin_unlock(&flower_entry->lock);
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
mod_timer(&adap->flower_stats_timer, jiffies + STATS_CHECK_PERIOD);
|
||||
}
|
||||
|
||||
int cxgb4_tc_flower_stats(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls)
|
||||
{
|
||||
struct adapter *adap = netdev2adap(dev);
|
||||
struct ch_tc_flower_stats *ofld_stats;
|
||||
struct ch_tc_flower_entry *ch_flower;
|
||||
u64 packets;
|
||||
u64 bytes;
|
||||
int ret;
|
||||
|
||||
ch_flower = ch_flower_lookup(adap, cls->cookie);
|
||||
if (!ch_flower) {
|
||||
ret = -ENOENT;
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = cxgb4_get_filter_counters(dev, ch_flower->filter_id,
|
||||
&packets, &bytes);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
spin_lock_bh(&ch_flower->lock);
|
||||
ofld_stats = &ch_flower->stats;
|
||||
if (ofld_stats->packet_count != packets) {
|
||||
if (ofld_stats->prev_packet_count != packets)
|
||||
ofld_stats->last_used = jiffies;
|
||||
tcf_exts_stats_update(cls->exts, bytes - ofld_stats->byte_count,
|
||||
packets - ofld_stats->packet_count,
|
||||
ofld_stats->last_used);
|
||||
|
||||
ofld_stats->packet_count = packets;
|
||||
ofld_stats->byte_count = bytes;
|
||||
ofld_stats->prev_packet_count = packets;
|
||||
}
|
||||
spin_unlock_bh(&ch_flower->lock);
|
||||
return 0;
|
||||
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
void cxgb4_init_tc_flower(struct adapter *adap)
|
||||
{
|
||||
hash_init(adap->flower_anymatch_tbl);
|
||||
setup_timer(&adap->flower_stats_timer, ch_flower_stats_cb,
|
||||
(unsigned long)adap);
|
||||
mod_timer(&adap->flower_stats_timer, jiffies + STATS_CHECK_PERIOD);
|
||||
}
|
||||
|
||||
void cxgb4_cleanup_tc_flower(struct adapter *adap)
|
||||
{
|
||||
if (adap->flower_stats_timer.function)
|
||||
del_timer_sync(&adap->flower_stats_timer);
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
/*
|
||||
* This file is part of the Chelsio T4/T5/T6 Ethernet driver for Linux.
|
||||
*
|
||||
* Copyright (c) 2017 Chelsio Communications, Inc. All rights reserved.
|
||||
*
|
||||
* This software is available to you under a choice of one of two
|
||||
* licenses. You may choose to be licensed under the terms of the GNU
|
||||
* General Public License (GPL) Version 2, available from the file
|
||||
* COPYING in the main directory of this source tree, or the
|
||||
* OpenIB.org BSD license below:
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or
|
||||
* without modification, are permitted provided that the following
|
||||
* conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer.
|
||||
*
|
||||
* - Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __CXGB4_TC_FLOWER_H
|
||||
#define __CXGB4_TC_FLOWER_H
|
||||
|
||||
#include <net/pkt_cls.h>
|
||||
|
||||
struct ch_tc_flower_stats {
|
||||
u64 prev_packet_count;
|
||||
u64 packet_count;
|
||||
u64 byte_count;
|
||||
u64 last_used;
|
||||
};
|
||||
|
||||
struct ch_tc_flower_entry {
|
||||
struct ch_filter_specification fs;
|
||||
struct ch_tc_flower_stats stats;
|
||||
unsigned long tc_flower_cookie;
|
||||
struct hlist_node link;
|
||||
struct rcu_head rcu;
|
||||
spinlock_t lock; /* lock for stats */
|
||||
u32 filter_id;
|
||||
};
|
||||
|
||||
int cxgb4_tc_flower_replace(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls);
|
||||
int cxgb4_tc_flower_destroy(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls);
|
||||
int cxgb4_tc_flower_stats(struct net_device *dev,
|
||||
struct tc_cls_flower_offload *cls);
|
||||
|
||||
void cxgb4_init_tc_flower(struct adapter *adap);
|
||||
void cxgb4_cleanup_tc_flower(struct adapter *adap);
|
||||
#endif /* __CXGB4_TC_FLOWER_H */
|
||||
|
|
@ -212,6 +212,7 @@ struct filter_ctx {
|
|||
|
||||
struct ch_filter_specification;
|
||||
|
||||
int cxgb4_get_free_ftid(struct net_device *dev, int family);
|
||||
int __cxgb4_set_filter(struct net_device *dev, int filter_id,
|
||||
struct ch_filter_specification *fs,
|
||||
struct filter_ctx *ctx);
|
||||
|
|
@ -220,6 +221,8 @@ int __cxgb4_del_filter(struct net_device *dev, int filter_id,
|
|||
int cxgb4_set_filter(struct net_device *dev, int filter_id,
|
||||
struct ch_filter_specification *fs);
|
||||
int cxgb4_del_filter(struct net_device *dev, int filter_id);
|
||||
int cxgb4_get_filter_counters(struct net_device *dev, unsigned int fidx,
|
||||
u64 *hitcnt, u64 *bytecnt);
|
||||
|
||||
static inline void set_wr_txq(struct sk_buff *skb, int prio, int queue)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in New Issue