// SPDX-License-Identifier: GPL-2.0+
#include "lan966x_main.h"
#include "vcap_api.h"
#include "vcap_api_client.h"
#include "vcap_tc.h"
#define LAN966X_FORCE_UNTAGED 3
static bool lan966x_tc_is_known_etype(struct vcap_tc_flower_parse_usage *st,
u16 etype)
{
switch (st->admin->vtype) {
case VCAP_TYPE_IS1:
switch (etype) {
case ETH_P_ALL:
case ETH_P_ARP:
case ETH_P_IP:
case ETH_P_IPV6:
return true;
}
break;
case VCAP_TYPE_IS2:
switch (etype) {
case ETH_P_ALL:
case ETH_P_ARP:
case ETH_P_IP:
case ETH_P_IPV6:
case ETH_P_SNAP:
case ETH_P_802_2:
return true;
}
break;
case VCAP_TYPE_ES0:
return true;
default:
NL_SET_ERR_MSG_MOD(st->fco->common.extack,
"VCAP type not supported");
return false;
}
return false;
}
static int
lan966x_tc_flower_handler_control_usage(struct vcap_tc_flower_parse_usage *st)
{
struct netlink_ext_ack *extack = st->fco->common.extack;
struct flow_match_control match;
int err = 0;
flow_rule_match_control(st->frule, &match);
if (match.mask->flags & FLOW_DIS_IS_FRAGMENT) {
if (match.key->flags & FLOW_DIS_IS_FRAGMENT)
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_L3_FRAGMENT,
VCAP_BIT_1);
else
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_L3_FRAGMENT,
VCAP_BIT_0);
if (err)
goto bad_frag_out;
}
if (match.mask->flags & FLOW_DIS_FIRST_FRAG) {
if (match.key->flags & FLOW_DIS_FIRST_FRAG)
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_L3_FRAG_OFS_GT0,
VCAP_BIT_0);
else
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_L3_FRAG_OFS_GT0,
VCAP_BIT_1);
if (err)
goto bad_frag_out;
}
if (!flow_rule_is_supp_control_flags(FLOW_DIS_IS_FRAGMENT |
FLOW_DIS_FIRST_FRAG,
match.mask->flags, extack))
return -EOPNOTSUPP;
st->used_keys |= BIT_ULL(FLOW_DISSECTOR_KEY_CONTROL);
return err;
bad_frag_out:
NL_SET_ERR_MSG_MOD(extack, "ip_frag parse error");
return err;
}
static int
lan966x_tc_flower_handler_basic_usage(struct vcap_tc_flower_parse_usage *st)
{
struct flow_match_basic match;
int err = 0;
flow_rule_match_basic(st->frule, &match);
if (match.mask->n_proto) {
st->l3_proto = be16_to_cpu(match.key->n_proto);
if (!lan966x_tc_is_known_etype(st, st->l3_proto)) {
err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_ETYPE,
st->l3_proto, ~0);
if (err)
goto out;
} else if (st->l3_proto == ETH_P_IP) {
err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_IP4_IS,
VCAP_BIT_1);
if (err)
goto out;
} else if (st->l3_proto == ETH_P_IPV6 &&
st->admin->vtype == VCAP_TYPE_IS1) {
/* Don't set any keys in this case */
} else if (st->l3_proto == ETH_P_SNAP &&
st->admin->vtype == VCAP_TYPE_IS1) {
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_ETYPE_LEN_IS,
VCAP_BIT_0);
if (err)
goto out;
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_IP_SNAP_IS,
VCAP_BIT_1);
if (err)
goto out;
} else if (st->admin->vtype == VCAP_TYPE_IS1) {
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_ETYPE_LEN_IS,
VCAP_BIT_1);
if (err)
goto out;
err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_ETYPE,
st->l3_proto, ~0);
if (err)
goto out;
}
}
if (match.mask->ip_proto) {
st->l4_proto = match.key->ip_proto;
if (st->l4_proto == IPPROTO_TCP) {
if (st->admin->vtype == VCAP_TYPE_IS1) {
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_TCP_UDP_IS,
VCAP_BIT_1);
if (err)
goto out;
}
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_TCP_IS,
VCAP_BIT_1);
if (err)
goto out;
} else if (st->l4_proto == IPPROTO_UDP) {
if (st->admin->vtype == VCAP_TYPE_IS1) {
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_TCP_UDP_IS,
VCAP_BIT_1);
if (err)
goto out;
}
err = vcap_rule_add_key_bit(st->vrule,
VCAP_KF_TCP_IS,
VCAP_BIT_0);
if (err)
goto out;
} else {
err = vcap_rule_add_key_u32(st->vrule,
VCAP_KF_L3_IP_PROTO,
st->l4_proto, ~0);
if (err)
goto out;
}
}
st->used_keys |= BIT_ULL(FLOW_DISSECTOR_KEY_BASIC);
return err;
out:
NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ip_proto parse error");
return err;
}
static int
lan966x_tc_flower_handler_cvlan_usage(struct vcap_tc_flower_parse_usage *st)
{
if (st->admin->vtype != VCAP_TYPE_IS1) {
NL_SET_ERR_MSG_MOD(st->fco->common.extack,
"cvlan not supported in this VCAP");
return -EINVAL;
}
return vcap_tc_flower_handler_cvlan_usage(st);
}
static int
lan966x_tc_flower_handler_vlan_usage(struct vcap_tc_flower_parse_usage *st)
{
enum vcap_key_field vid_key = VCAP_KF_8021Q_VID_CLS;
enum vcap_key_field pcp_key = VCAP_KF_8021Q_PCP_CLS;
if (st->admin->vtype == VCAP_TYPE_IS1) {
vid_key = VCAP_KF_8021Q_VID0;
pcp_key = VCAP_KF_8021Q_PCP0;
}
return vcap_tc_flower_handler_vlan_usage(st, vid_key, pcp_key);
}
static int
(*lan966x_tc_flower_handlers_usage[])(struct vcap_tc_flower_parse_usage *st) = {
[FLOW_DISSECTOR_KEY_ETH_ADDRS] = vcap_tc_flower_handler_ethaddr_usage,
[FLOW_DISSECTOR_KEY_IPV4_ADDRS] = vcap_tc_flower_handler_ipv4_usage,
[FLOW_DISSECTOR_KEY_IPV6_ADDRS] = vcap_tc_flower_handler_ipv6_usage,
[FLOW_DISSECTOR_KEY_CONTROL] = lan966x_tc_flower_handler_control_usage,
[FLOW_DISSECTOR_KEY_PORTS] = vcap_tc_flower_handler_portnum_usage,
[FLOW_DISSECTOR_KEY_BASIC] = lan966x_tc_flower_handler_basic_usage,
[FLOW_DISSECTOR_KEY_CVLAN] = lan966x_tc_flower_handler_cvlan_usage,
[FLOW_DISSECTOR_KEY_VLAN] = lan966x_tc_flower_handler_vlan_usage,
[FLOW_DISSECTOR_KEY_TCP] = vcap_tc_flower_handler_tcp_usage,
[FLOW_DISSECTOR_KEY_ARP] = vcap_tc_flower_handler_arp_usage,
[FLOW_DISSECTOR_KEY_IP] = vcap_tc_flower_handler_ip_usage,
};
static int lan966x_tc_flower_use_dissectors(struct flow_cls_offload *f,
struct vcap_admin *admin,
struct vcap_rule *vrule,
u16 *l3_proto)
{
struct vcap_tc_flower_parse_usage state = {
.fco = f,
.vrule = vrule,
.l3_proto = ETH_P_ALL,
.admin = admin,
};
int err = 0;
state.frule = flow_cls_offload_flow_rule(f);
for (int i = 0; i < ARRAY_SIZE(lan966x_tc_flower_handlers_usage); ++i) {
if (!flow_rule_match_key(state.frule, i) ||
!lan966x_tc_flower_handlers_usage[i])
continue;
err = lan966x_tc_flower_handlers_usage[i](&state);
if (err)
return err;
}
if (l3_proto)
*l3_proto = state.l3_proto;
return err;
}
static int lan966x_tc_flower_action_check(struct vcap_control *vctrl,
struct net_device *dev,
struct flow_cls_offload *fco,
bool ingress)
{
struct flow_rule *rule = flow_cls_offload_flow_rule(fco);
struct flow_action_entry *actent, *last_actent = NULL;
struct flow_action *act = &rule->action;
u64 action_mask = 0;
int idx;
if (!flow_action_has_entries(act)) {
NL_SET_ERR_MSG_MOD(fco->common.extack, "No actions");
return -EINVAL;
}
if (!flow_action_basic_hw_stats_check(act, fco->common.extack))
return -EOPNOTSUPP;
flow_action_for_each(idx, actent, act) {
if (action_mask & BIT(actent->id)) {
NL_SET_ERR_MSG_MOD(fco->common.extack,
"More actions of the same type");
return -EINVAL;
}
action_mask |= BIT(actent->id);
last_actent = actent; /* Save last action for later check */
}
/* Check that last action is a goto
* The last chain/lookup does not need to have goto action
*/
if (last_actent->id == FLOW_ACTION_GOTO) {
/* Check if the destination chain is in one of the VCAPs */
if (!vcap_is_next_lookup(vctrl, fco->common.chain_index,
last_actent->chain_index)) {
NL_SET_ERR_MSG_MOD(fco->common.extack,
"Invalid goto chain");
return -EINVAL;
}
} else if (!vcap_is_last_chain(vctrl, fco->common.chain_index,
ingress)) {
NL_SET_ERR_MSG_MOD(fco->common.extack,
"Last action must be 'goto'");
return -EINVAL;
}
/* Catch unsupported combinations of actions */
if (action_mask & BIT(FLOW_ACTION_TRAP) &&
action_mask & BIT(FLOW_ACTION_ACCEPT)) {
NL_SET_ERR_MSG_MOD(fco->common.extack,
"Cannot combine pass and trap action");
return -EOPNOTSUPP;
}
return 0;
}
/* Add the actionset that is the default for the VCAP type */
static int lan966x_tc_set_actionset(struct vcap_admin *admin,
struct vcap_rule *vrule)
{
enum vcap_actionfield_set aset;
int err = 0;
switch (admin->vtype) {
case VCAP_TYPE_IS1:
aset = VCAP_AFS_S1;
break;
case VCAP_TYPE_IS2:
aset = VCAP_AFS_BASE_TYPE;
break;
case VCAP_TYPE_ES0:
aset = VCAP_AFS_VID;
break;
default:
return -EINVAL;
}
/* Do not overwrite any current actionset */
if (vrule->actionset == VCAP_AFS_NO_VALUE)
err = vcap_set_rule_set_actionset(vrule, aset);
return err;
}
static int lan966x_tc_add_rule_link_target(struct vcap_admin *admin,
struct vcap_rule *vrule,
int target_cid)
{
int link_val = target_cid % VCAP_CID_LOOKUP_SIZE;
int err;
if (!link_val)
return 0;
switch (admin->vtype) {
case VCAP_TYPE_IS1:
/* Choose IS1 specific NXT_IDX key (for chaining rules from IS1) */
err = vcap_rule_add_key_u32(vrule, VCAP_KF_LOOKUP_GEN_IDX_SEL,
1, ~0);
if (err)
return err;
return vcap_rule_add_key_u32(vrule, VCAP_KF_LOOKUP_GEN_IDX,
link_val, ~0);
case VCAP_TYPE_IS2:
/* Add IS2 specific PAG key (for chaining rules from IS1) */
return vcap_rule_add_key_u32(vrule, VCAP_KF_LOOKUP_PAG,
link_val, ~0);
case VCAP_TYPE_ES0:
/* Add ES0 specific ISDX key (for chaining rules from IS1) */
return vcap_rule_add_key_u32(vrule, VCAP_KF_ISDX_CLS,
link_val, ~0);
default:
break;
}
return 0;
}
static int lan966x_tc_add_rule_link(struct vcap_control *vctrl,
struct vcap_admin *admin,
struct vcap_rule *vrule,
struct flow_cls_offload *f,
int to_cid)
{
struct vcap_admin *to_admin = vcap_find_admin(vctrl, to_cid);
int diff, err = 0;
if (!to_admin) {
NL_SET_ERR_MSG_MOD(f->common.extack,
"Unknown destination chain");
return -EINVAL;
}
diff = vcap_chain_offset(vctrl, f->common.chain_index, to_cid);
if (!diff)
return 0;
/* Between IS1 and IS2 the PAG value is used */
if (admin->vtype == VCAP_TYPE_IS1 && to_admin->vtype == VCAP_TYPE_IS2) {
/* This works for IS1->IS2 */
err = vcap_rule_add_action_u32(vrule, VCAP_AF_PAG_VAL, diff);
if (err)
return err;
err = vcap_rule_add_action_u32(vrule, VCAP_AF_PAG_OVERRIDE_MASK,
0xff);
if (err)
return err;
} else if (admin->vtype == VCAP_TYPE_IS1 &&
to_admin->vtype == VCAP_TYPE_ES0) {
/* This works for IS1->ES0 */
err = vcap_rule_add_action_u32(vrule, VCAP_AF_ISDX_ADD_VAL,
diff);
if (err)
return err;
err = vcap_rule_add_action_bit(vrule, VCAP_AF_ISDX_REPLACE_ENA,
VCAP_BIT_1);
if (err)
return err;
} else {
NL_SET_ERR_MSG_MOD(f->common.extack,
"Unsupported chain destination");
return -EOPNOTSUPP;
}
return err;
}
static int lan966x_tc_add_rule_counter(struct vcap_admin *admin,
struct vcap_rule *vrule)
{
int err = 0;
switch (admin->vtype) {
case VCAP_TYPE_ES0:
err = vcap_rule_mod_action_u32(vrule, VCAP_AF_ESDX,
vrule->id);
break;
default:
break;
}
return err;
}
static int lan966x_tc_flower_add(struct lan966x_port *port,
struct flow_cls_offload *f,
struct vcap_admin *admin,
bool ingress)
{
struct flow_action_entry *act;
u16 l3_proto = ETH_P_ALL;
struct flow_rule *frule;
struct vcap_rule *vrule;
int err, idx;
err = lan966x_tc_flower_action_check(port->lan966x->vcap_ctrl,
port->dev, f, ingress);
if (err)
return err;
vrule = vcap_alloc_rule(port->lan966x->vcap_ctrl, port->dev,
f->common.chain_index, VCAP_USER_TC,
f->common.prio, 0);
if (IS_ERR(vrule))
return PTR_ERR(vrule);
vrule->cookie = f->cookie;
err = lan966x_tc_flower_use_dissectors(f, admin, vrule, &l3_proto);
if (err)
goto out;
err = lan966x_tc_add_rule_link_target(admin, vrule,
f->common.chain_index);
if (err)
goto out;
frule = flow_cls_offload_flow_rule(f);
flow_action_for_each(idx, act, &frule->action) {
switch (act->id) {
case FLOW_ACTION_TRAP:
if (admin->vtype != VCAP_TYPE_IS2) {
NL_SET_ERR_MSG_MOD(f->common.extack,
"Trap action not supported in this VCAP");
err = -EOPNOTSUPP;
goto out;
}
err = vcap_rule_add_action_bit(vrule,
VCAP_AF_CPU_COPY_ENA,
VCAP_BIT_1);
err |= vcap_rule_add_action_u32(vrule,
VCAP_AF_CPU_QUEUE_NUM,
0);
err |= vcap_rule_add_action_u32(vrule, VCAP_AF_MASK_MODE,
LAN966X_PMM_REPLACE);
if (err)
goto out;
break;
case FLOW_ACTION_GOTO:
err = lan966x_tc_set_actionset(admin, vrule);
if (err)
goto out;
err = lan966x_tc_add_rule_link(port->lan966x->vcap_ctrl,
admin, vrule,
f, act->chain_index);
if (err)
goto out;
break;
case FLOW_ACTION_VLAN_POP:
if (admin->vtype != VCAP_TYPE_ES0) {
NL_SET_ERR_MSG_MOD(f->common.extack,
"Cannot use vlan pop on non es0");
err = -EOPNOTSUPP;
goto out;
}
/* Force untag */
err = vcap_rule_add_action_u32(vrule, VCAP_AF_PUSH_OUTER_TAG,
LAN966X_FORCE_UNTAGED);
if (err)
goto out;
break;
default:
NL_SET_ERR_MSG_MOD(f->common.extack,
"Unsupported TC action");
err = -EOPNOTSUPP;
goto out;
}
}
err = lan966x_tc_add_rule_counter(admin, vrule);
if (err) {
vcap_set_tc_exterr(f, vrule);
goto out;
}
err = vcap_val_rule(vrule, l3_proto);
if (err) {
vcap_set_tc_exterr(f, vrule);
goto out;
}
err = vcap_add_rule(vrule);
if (err)
NL_SET_ERR_MSG_MOD(f->common.extack,
"Could not add the filter");
out:
vcap_free_rule(vrule);
return err;
}
static int lan966x_tc_flower_del(struct lan966x_port *port,
struct flow_cls_offload *f,
struct vcap_admin *admin)
{
struct vcap_control *vctrl;
int err = -ENOENT, rule_id;
vctrl = port->lan966x->vcap_ctrl;
while (true) {
rule_id = vcap_lookup_rule_by_cookie(vctrl, f->cookie);
if (rule_id <= 0)
break;
err = vcap_del_rule(vctrl, port->dev, rule_id);
if (err) {
NL_SET_ERR_MSG_MOD(f->common.extack,
"Cannot delete rule");
break;
}
}
return err;
}
static int lan966x_tc_flower_stats(struct lan966x_port *port,
struct flow_cls_offload *f,
struct vcap_admin *admin)
{
struct vcap_counter count = {};
int err;
err = vcap_get_rule_count_by_cookie(port->lan966x->vcap_ctrl,
&count, f->cookie);
if (err)
return err;
flow_stats_update(&f->stats, 0x0, count.value, 0, 0,
FLOW_ACTION_HW_STATS_IMMEDIATE);
return err;
}
int lan966x_tc_flower(struct lan966x_port *port,
struct flow_cls_offload *f,
bool ingress)
{
struct vcap_admin *admin;
admin = vcap_find_admin(port->lan966x->vcap_ctrl,
f->common.chain_index);
if (!admin) {
NL_SET_ERR_MSG_MOD(f->common.extack, "Invalid chain");
return -EINVAL;
}
switch (f->command) {
case FLOW_CLS_REPLACE:
return lan966x_tc_flower_add(port, f, admin, ingress);
case FLOW_CLS_DESTROY:
return lan966x_tc_flower_del(port, f, admin);
case FLOW_CLS_STATS:
return lan966x_tc_flower_stats(port, f, admin);
default:
return -EOPNOTSUPP;
}
return 0;
}
Codebase Browser
linux