k = spec->dst.addr_bytes;
m = mask->dst.addr_bytes;
- flow->pattern |= F_DMAC;
+ flow->table_key.proto_field[flow->rule.num_fields].field.eth =
+ MV_NET_ETH_F_DA;
} else {
k = spec->src.addr_bytes;
m = mask->src.addr_bytes;
- flow->pattern |= F_SMAC;
+ flow->table_key.proto_field[flow->rule.num_fields].field.eth =
+ MV_NET_ETH_F_SA;
}
key_field = &flow->rule.fields[flow->rule.num_fields];
key_field->size = 6;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX,
- "%02x:%02x:%02x:%02x:%02x:%02x",
+ RTE_ETHER_ADDR_PRT_FMT,
k[0], k[1], k[2], k[3], k[4], k[5]);
snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX,
- "%02x:%02x:%02x:%02x:%02x:%02x",
+ RTE_ETHER_ADDR_PRT_FMT,
m[0], m[1], m[2], m[3], m[4], m[5]);
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_ETH;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
k = rte_be_to_cpu_16(spec->type);
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
- flow->pattern |= F_TYPE;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_ETH;
+ flow->table_key.proto_field[flow->rule.num_fields].field.eth =
+ MV_NET_ETH_F_TYPE;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
k = rte_be_to_cpu_16(spec->tci) & MRVL_VLAN_ID_MASK;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
- flow->pattern |= F_VLAN_ID;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_VLAN;
+ flow->table_key.proto_field[flow->rule.num_fields].field.vlan =
+ MV_NET_VLAN_F_ID;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
k = (rte_be_to_cpu_16(spec->tci) & MRVL_VLAN_PRI_MASK) >> 13;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
- flow->pattern |= F_VLAN_PRI;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_VLAN;
+ flow->table_key.proto_field[flow->rule.num_fields].field.vlan =
+ MV_NET_VLAN_F_PRI;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX, "%u", m);
- flow->pattern |= F_IP4_TOS;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_IP4;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv4 =
+ MV_NET_IP4_F_DSCP;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
k.s_addr = spec->hdr.dst_addr;
m = rte_be_to_cpu_32(mask->hdr.dst_addr);
- flow->pattern |= F_IP4_DIP;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv4 =
+ MV_NET_IP4_F_DA;
} else {
k.s_addr = spec->hdr.src_addr;
m = rte_be_to_cpu_32(mask->hdr.src_addr);
- flow->pattern |= F_IP4_SIP;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv4 =
+ MV_NET_IP4_F_SA;
}
key_field = &flow->rule.fields[flow->rule.num_fields];
inet_ntop(AF_INET, &k, (char *)key_field->key, MRVL_CLS_STR_SIZE_MAX);
snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX, "0x%x", m);
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_IP4;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
- flow->pattern |= F_IP4_PROTO;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_IP4;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv4 =
+ MV_NET_IP4_F_PROTO;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
memcpy(k.s6_addr, spec->hdr.dst_addr, size);
memcpy(m.s6_addr, mask->hdr.dst_addr, size);
- flow->pattern |= F_IP6_DIP;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv6 =
+ MV_NET_IP6_F_DA;
} else {
memcpy(k.s6_addr, spec->hdr.src_addr, size);
memcpy(m.s6_addr, mask->hdr.src_addr, size);
- flow->pattern |= F_IP6_SIP;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv6 =
+ MV_NET_IP6_F_SA;
}
key_field = &flow->rule.fields[flow->rule.num_fields];
inet_ntop(AF_INET6, &k, (char *)key_field->key, MRVL_CLS_STR_SIZE_MAX);
inet_ntop(AF_INET6, &m, (char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX);
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_IP6;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX, "%u", m);
- flow->pattern |= F_IP6_FLOW;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_IP6;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv6 =
+ MV_NET_IP6_F_FLOW;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
- flow->pattern |= F_IP6_NEXT_HDR;
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_IP6;
+ flow->table_key.proto_field[flow->rule.num_fields].field.ipv6 =
+ MV_NET_IP6_F_NEXT_HDR;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
if (parse_dst) {
k = rte_be_to_cpu_16(spec->hdr.dst_port);
- flow->pattern |= F_TCP_DPORT;
+ flow->table_key.proto_field[flow->rule.num_fields].field.tcp =
+ MV_NET_TCP_F_DP;
} else {
k = rte_be_to_cpu_16(spec->hdr.src_port);
- flow->pattern |= F_TCP_SPORT;
+ flow->table_key.proto_field[flow->rule.num_fields].field.tcp =
+ MV_NET_TCP_F_SP;
}
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_TCP;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
if (parse_dst) {
k = rte_be_to_cpu_16(spec->hdr.dst_port);
- flow->pattern |= F_UDP_DPORT;
+ flow->table_key.proto_field[flow->rule.num_fields].field.udp =
+ MV_NET_UDP_F_DP;
} else {
k = rte_be_to_cpu_16(spec->hdr.src_port);
- flow->pattern |= F_UDP_SPORT;
+ flow->table_key.proto_field[flow->rule.num_fields].field.udp =
+ MV_NET_UDP_F_SP;
}
snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_PROTO_UDP;
+ flow->table_key.key_size += key_field->size;
+
flow->rule.num_fields += 1;
return 0;
{
const struct rte_flow_item_vlan *spec = NULL, *mask = NULL;
uint16_t m;
- int ret;
+ int ret, i;
ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
&rte_flow_item_vlan_mask,
goto out;
}
- if (flow->pattern & F_TYPE) {
- rte_flow_error_set(error, ENOTSUP,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "VLAN TPID matching is not supported");
- return -rte_errno;
- }
if (mask->inner_type) {
struct rte_flow_item_eth spec_eth = {
.type = spec->inner_type,
.type = mask->inner_type,
};
+ /* TPID is not supported so if ETH_TYPE was selected,
+ * error is return. else, classify eth-type with the tpid value
+ */
+ for (i = 0; i < flow->rule.num_fields; i++)
+ if (flow->table_key.proto_field[i].proto ==
+ MV_NET_PROTO_ETH &&
+ flow->table_key.proto_field[i].field.eth ==
+ MV_NET_ETH_F_TYPE) {
+ rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ item,
+ "VLAN TPID matching is not supported");
+ return -rte_errno;
+ }
+
MRVL_LOG(WARNING, "inner eth type mask is ignored");
ret = mrvl_parse_type(&spec_eth, &mask_eth, flow);
if (ret)
return -rte_errno;
}
+static int
+mrvl_string_to_hex_values(const uint8_t *input_string,
+ uint8_t *hex_key,
+ uint8_t *length)
+{
+ char tmp_arr[3], tmp_string[MRVL_CLS_STR_SIZE_MAX], *string_iter;
+ int i;
+
+ strcpy(tmp_string, (const char *)input_string);
+ string_iter = tmp_string;
+
+ string_iter += 2; /* skip the '0x' */
+ *length = ((*length - 2) + 1) / 2;
+
+ for (i = 0; i < *length; i++) {
+ strncpy(tmp_arr, string_iter, 2);
+ tmp_arr[2] = '\0';
+ if (get_val_securely8(tmp_arr, 16,
+ &hex_key[*length - 1 - i]) < 0)
+ return -1;
+ string_iter += 2;
+ }
+
+ return 0;
+}
+
+/**
+ * Parse raw flow item.
+ *
+ * @param item Pointer to the flow item.
+ * @param flow Pointer to the flow.
+ * @param error Pointer to the flow error.
+ * @returns 0 on success, negative value otherwise.
+ */
+static int
+mrvl_parse_raw(const struct rte_flow_item *item,
+ struct rte_flow *flow,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_raw *spec = NULL, *mask = NULL;
+ struct pp2_cls_rule_key_field *key_field;
+ struct mv_net_udf *udf_params;
+ uint8_t length;
+ int ret;
+
+ ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
+ &rte_flow_item_raw_mask,
+ sizeof(struct rte_flow_item_raw), error);
+ if (ret)
+ return ret;
+
+ if (!spec->pattern) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "pattern pointer MUST be given\n");
+ return -rte_errno;
+ }
+
+ /* Only hex string is supported; so, it must start with '0x' */
+ if (strncmp((const char *)spec->pattern, "0x", 2) != 0) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "'pattern' string must start with '0x'\n");
+ return -rte_errno;
+ }
+
+ if (mask->pattern &&
+ strncmp((const char *)mask->pattern, "0x", 2) != 0) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "'mask-pattern' string must start with '0x'\n");
+ return -rte_errno;
+ }
+
+ if (mask->search && spec->search) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "'search' option must be '0'\n");
+ return -rte_errno;
+ }
+
+ if (mask->offset && spec->offset != 0) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "'offset' option must be '0'\n");
+ return -rte_errno;
+ }
+
+ if (!mask->relative || !spec->relative) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "'relative' option must be given and enabled\n");
+ return -rte_errno;
+ }
+
+ length = spec->length & mask->length;
+ if (!length) {
+ rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL, "'length' option must be given bigger than '0'\n");
+ return -rte_errno;
+ }
+
+ key_field = &flow->rule.fields[flow->rule.num_fields];
+ mrvl_alloc_key_mask(key_field);
+
+ /* pattern and length refer to string bytes. we need to convert it to
+ * values.
+ */
+ key_field->size = length;
+ ret = mrvl_string_to_hex_values(spec->pattern, key_field->key,
+ &key_field->size);
+ if (ret) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL,
+ "can't convert pattern from string to hex\n");
+ return -rte_errno;
+ }
+ if (mask->pattern) {
+ ret = mrvl_string_to_hex_values(mask->pattern, key_field->mask,
+ &length);
+ if (ret) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
+ NULL,
+ "can't convert mask-pattern from string to hex\n");
+ return -rte_errno;
+ }
+ } else {
+ rte_free(key_field->mask);
+ key_field->mask = NULL;
+ }
+
+ flow->table_key.proto_field[flow->rule.num_fields].proto =
+ MV_NET_UDF;
+ udf_params =
+ &flow->table_key.proto_field[flow->rule.num_fields].field.udf;
+ udf_params->id = flow->next_udf_id++;
+ udf_params->size = key_field->size;
+ flow->table_key.key_size += key_field->size;
+
+ flow->rule.num_fields += 1;
+
+ return 0;
+}
+
/**
* Structure used to map specific flow pattern to the pattern parse callback
* which will iterate over each pattern item and extract relevant data.
{ RTE_FLOW_ITEM_TYPE_IPV6, mrvl_parse_ip6 },
{ RTE_FLOW_ITEM_TYPE_TCP, mrvl_parse_tcp },
{ RTE_FLOW_ITEM_TYPE_UDP, mrvl_parse_udp },
+ { RTE_FLOW_ITEM_TYPE_RAW, mrvl_parse_raw },
{ RTE_FLOW_ITEM_TYPE_END, NULL }
};
}
}
+ flow->table_key.num_fields = flow->rule.num_fields;
+
return 0;
}
priv->cls_tbl_params.max_num_rules = MRVL_CLS_MAX_NUM_RULES;
priv->cls_tbl_params.default_act.type = PP2_CLS_TBL_ACT_DONE;
priv->cls_tbl_params.default_act.cos = &first_flow->cos;
-
- if (first_flow->pattern & F_DMAC) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_ETH;
- key->proto_field[key->num_fields].field.eth = MV_NET_ETH_F_DA;
- key->key_size += 6;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_SMAC) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_ETH;
- key->proto_field[key->num_fields].field.eth = MV_NET_ETH_F_SA;
- key->key_size += 6;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_TYPE) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_ETH;
- key->proto_field[key->num_fields].field.eth = MV_NET_ETH_F_TYPE;
- key->key_size += 2;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_VLAN_ID) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_VLAN;
- key->proto_field[key->num_fields].field.vlan = MV_NET_VLAN_F_ID;
- key->key_size += 2;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_VLAN_PRI) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_VLAN;
- key->proto_field[key->num_fields].field.vlan =
- MV_NET_VLAN_F_PRI;
- key->key_size += 1;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP4_TOS) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
- key->proto_field[key->num_fields].field.ipv4 =
- MV_NET_IP4_F_DSCP;
- key->key_size += 1;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP4_SIP) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
- key->proto_field[key->num_fields].field.ipv4 = MV_NET_IP4_F_SA;
- key->key_size += 4;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP4_DIP) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
- key->proto_field[key->num_fields].field.ipv4 = MV_NET_IP4_F_DA;
- key->key_size += 4;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP4_PROTO) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
- key->proto_field[key->num_fields].field.ipv4 =
- MV_NET_IP4_F_PROTO;
- key->key_size += 1;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP6_SIP) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
- key->proto_field[key->num_fields].field.ipv6 = MV_NET_IP6_F_SA;
- key->key_size += 16;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP6_DIP) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
- key->proto_field[key->num_fields].field.ipv6 = MV_NET_IP6_F_DA;
- key->key_size += 16;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP6_FLOW) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
- key->proto_field[key->num_fields].field.ipv6 =
- MV_NET_IP6_F_FLOW;
- key->key_size += 3;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_IP6_NEXT_HDR) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
- key->proto_field[key->num_fields].field.ipv6 =
- MV_NET_IP6_F_NEXT_HDR;
- key->key_size += 1;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_TCP_SPORT) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_TCP;
- key->proto_field[key->num_fields].field.tcp = MV_NET_TCP_F_SP;
- key->key_size += 2;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_TCP_DPORT) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_TCP;
- key->proto_field[key->num_fields].field.tcp = MV_NET_TCP_F_DP;
- key->key_size += 2;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_UDP_SPORT) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_UDP;
- key->proto_field[key->num_fields].field.udp = MV_NET_UDP_F_SP;
- key->key_size += 2;
- key->num_fields += 1;
- }
-
- if (first_flow->pattern & F_UDP_DPORT) {
- key->proto_field[key->num_fields].proto = MV_NET_PROTO_UDP;
- key->proto_field[key->num_fields].field.udp = MV_NET_UDP_F_DP;
- key->key_size += 2;
- key->num_fields += 1;
- }
+ memcpy(key, &first_flow->table_key, sizeof(struct pp2_cls_tbl_key));
ret = pp2_cls_tbl_init(&priv->cls_tbl_params, &priv->cls_tbl);
- if (!ret)
- priv->cls_tbl_pattern = first_flow->pattern;
return ret;
}
static inline int
mrvl_flow_can_be_added(struct mrvl_priv *priv, const struct rte_flow *flow)
{
- return flow->pattern == priv->cls_tbl_pattern &&
- mrvl_engine_type(flow) == priv->cls_tbl_params.type;
+ int same = memcmp(&flow->table_key, &priv->cls_tbl_params.key,
+ sizeof(struct pp2_cls_tbl_key)) == 0;
+
+ return same && mrvl_engine_type(flow) == priv->cls_tbl_params.type;
}
/**