Commit 62488e4b authored by Kumar Sanghvi's avatar Kumar Sanghvi Committed by David S. Miller

cxgb4: add basic tc flower offload support

Add support to add/remove flows for offload.  Following match
and action are supported for offloading a flow:

Match: ether-protocol, IPv4/IPv6 addresses, L4 ports (TCP/UDP)
Action: drop, redirect to another port on the device.

The qualifying flows can have accompanying mask information.
Signed-off-by: default avatarKumar Sanghvi <kumaras@chelsio.com>
Signed-off-by: default avatarRahul Lakkireddy <rahul.lakkireddy@chelsio.com>
Signed-off-by: default avatarGanesh Goudar <ganeshgr@chelsio.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 6a345b3d
...@@ -905,6 +905,9 @@ struct adapter { ...@@ -905,6 +905,9 @@ struct adapter {
/* TC u32 offload */ /* TC u32 offload */
struct cxgb4_tc_u32_table *tc_u32; struct cxgb4_tc_u32_table *tc_u32;
struct chcr_stats_debug chcr_stats; struct chcr_stats_debug chcr_stats;
/* TC flower offload */
DECLARE_HASHTABLE(flower_anymatch_tbl, 9);
}; };
/* Support for "sched-class" command to allow a TX Scheduling Class to be /* Support for "sched-class" command to allow a TX Scheduling Class to be
......
...@@ -148,6 +148,30 @@ static int get_filter_steerq(struct net_device *dev, ...@@ -148,6 +148,30 @@ static int get_filter_steerq(struct net_device *dev,
return iq; return iq;
} }
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) static int cxgb4_set_ftid(struct tid_info *t, int fidx, int family)
{ {
spin_lock_bh(&t->ftid_lock); spin_lock_bh(&t->ftid_lock);
......
...@@ -5105,6 +5105,8 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -5105,6 +5105,8 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
if (!adapter->tc_u32) if (!adapter->tc_u32)
dev_warn(&pdev->dev, dev_warn(&pdev->dev,
"could not offload tc u32, continuing\n"); "could not offload tc u32, continuing\n");
cxgb4_init_tc_flower(adapter);
} }
if (is_offload(adapter)) { if (is_offload(adapter)) {
......
...@@ -38,16 +38,287 @@ ...@@ -38,16 +38,287 @@
#include "cxgb4.h" #include "cxgb4.h"
#include "cxgb4_tc_flower.h" #include "cxgb4_tc_flower.h"
static struct ch_tc_flower_entry *allocate_flower_entry(void)
{
struct ch_tc_flower_entry *new = kzalloc(sizeof(*new), GFP_KERNEL);
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;
}
}
}
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 {
netdev_err(dev, "%s: Unsupported action\n", __func__);
return -EOPNOTSUPP;
}
}
return 0;
}
int cxgb4_tc_flower_replace(struct net_device *dev, int cxgb4_tc_flower_replace(struct net_device *dev,
struct tc_cls_flower_offload *cls) 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; 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, int cxgb4_tc_flower_destroy(struct net_device *dev,
struct tc_cls_flower_offload *cls) struct tc_cls_flower_offload *cls)
{ {
return -EOPNOTSUPP; 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;
} }
int cxgb4_tc_flower_stats(struct net_device *dev, int cxgb4_tc_flower_stats(struct net_device *dev,
...@@ -55,3 +326,8 @@ int cxgb4_tc_flower_stats(struct net_device *dev, ...@@ -55,3 +326,8 @@ int cxgb4_tc_flower_stats(struct net_device *dev,
{ {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
void cxgb4_init_tc_flower(struct adapter *adap)
{
hash_init(adap->flower_anymatch_tbl);
}
...@@ -37,10 +37,27 @@ ...@@ -37,10 +37,27 @@
#include <net/pkt_cls.h> #include <net/pkt_cls.h>
struct ch_tc_flower_stats {
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;
u32 filter_id;
};
int cxgb4_tc_flower_replace(struct net_device *dev, int cxgb4_tc_flower_replace(struct net_device *dev,
struct tc_cls_flower_offload *cls); struct tc_cls_flower_offload *cls);
int cxgb4_tc_flower_destroy(struct net_device *dev, int cxgb4_tc_flower_destroy(struct net_device *dev,
struct tc_cls_flower_offload *cls); struct tc_cls_flower_offload *cls);
int cxgb4_tc_flower_stats(struct net_device *dev, int cxgb4_tc_flower_stats(struct net_device *dev,
struct tc_cls_flower_offload *cls); struct tc_cls_flower_offload *cls);
void cxgb4_init_tc_flower(struct adapter *adap);
#endif /* __CXGB4_TC_FLOWER_H */ #endif /* __CXGB4_TC_FLOWER_H */
...@@ -212,6 +212,7 @@ struct filter_ctx { ...@@ -212,6 +212,7 @@ struct filter_ctx {
struct ch_filter_specification; 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, int __cxgb4_set_filter(struct net_device *dev, int filter_id,
struct ch_filter_specification *fs, struct ch_filter_specification *fs,
struct filter_ctx *ctx); struct filter_ctx *ctx);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment