uint32_t tc_id,
uint32_t queue_id)
{
- return queue_id +
- tc_id * RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE +
+ return queue_id + tc_id +
(pipe_id + subport_id * n_pps) * RTE_SCHED_QUEUES_PER_PIPE;
}
},
};
+ uint32_t *shared_shaper_id =
+ (uint32_t *)calloc(RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE,
+ sizeof(uint32_t));
+
+ if (shared_shaper_id == NULL)
+ return -1;
+
+ memcpy(shared_shaper_id, params->shared_shaper_id.tc,
+ sizeof(params->shared_shaper_id.tc));
+
struct rte_tm_node_params tc_node_params[] = {
[0] = {
.shaper_profile_id = params->shaper_profile_id.tc[0],
- .shared_shaper_id = ¶ms->shared_shaper_id.tc[0],
+ .shared_shaper_id = &shared_shaper_id[0],
.n_shared_shapers =
- (¶ms->shared_shaper_id.tc_valid[0]) ? 1 : 0,
+ (params->shared_shaper_id.tc_valid[0]) ? 1 : 0,
.nonleaf = {
.n_sp_priorities = 1,
},
[1] = {
.shaper_profile_id = params->shaper_profile_id.tc[1],
- .shared_shaper_id = ¶ms->shared_shaper_id.tc[1],
+ .shared_shaper_id = &shared_shaper_id[1],
.n_shared_shapers =
- (¶ms->shared_shaper_id.tc_valid[1]) ? 1 : 0,
+ (params->shared_shaper_id.tc_valid[1]) ? 1 : 0,
.nonleaf = {
.n_sp_priorities = 1,
},
[2] = {
.shaper_profile_id = params->shaper_profile_id.tc[2],
- .shared_shaper_id = ¶ms->shared_shaper_id.tc[2],
+ .shared_shaper_id = &shared_shaper_id[2],
.n_shared_shapers =
- (¶ms->shared_shaper_id.tc_valid[2]) ? 1 : 0,
+ (params->shared_shaper_id.tc_valid[2]) ? 1 : 0,
.nonleaf = {
.n_sp_priorities = 1,
},
[3] = {
.shaper_profile_id = params->shaper_profile_id.tc[3],
- .shared_shaper_id = ¶ms->shared_shaper_id.tc[3],
+ .shared_shaper_id = &shared_shaper_id[3],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[3]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [4] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[4],
+ .shared_shaper_id = &shared_shaper_id[4],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[4]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [5] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[5],
+ .shared_shaper_id = &shared_shaper_id[5],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[5]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [6] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[6],
+ .shared_shaper_id = &shared_shaper_id[6],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[6]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [7] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[7],
+ .shared_shaper_id = &shared_shaper_id[7],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[7]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [8] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[8],
+ .shared_shaper_id = &shared_shaper_id[8],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[8]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [9] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[9],
+ .shared_shaper_id = &shared_shaper_id[9],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[9]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [10] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[10],
+ .shared_shaper_id = &shared_shaper_id[10],
.n_shared_shapers =
- (¶ms->shared_shaper_id.tc_valid[3]) ? 1 : 0,
+ (params->shared_shaper_id.tc_valid[10]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [11] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[11],
+ .shared_shaper_id = &shared_shaper_id[11],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[11]) ? 1 : 0,
+ .nonleaf = {
+ .n_sp_priorities = 1,
+ },
+ },
+
+ [12] = {
+ .shaper_profile_id = params->shaper_profile_id.tc[12],
+ .shared_shaper_id = &shared_shaper_id[12],
+ .n_shared_shapers =
+ (params->shared_shaper_id.tc_valid[12]) ? 1 : 0,
.nonleaf = {
.n_sp_priorities = 1,
},
return -1;
/* Hierarchy level 4: Queue nodes */
- for (q = 0; q < RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS; q++) {
+ if (t < RTE_SCHED_TRAFFIC_CLASS_BE) {
+ /* Strict-priority traffic class queues */
+ q = 0;
+ status = rte_tm_node_add(port_id,
+ queue_node_id(n_spp, n_pps, s, p, t, q),
+ tc_node_id(n_spp, n_pps, s, p, t),
+ 0,
+ params->weight.queue[q],
+ RTE_TM_NODE_LEVEL_ID_ANY,
+ &queue_node_params,
+ &error);
+ if (status)
+ return -1;
+
+ continue;
+ }
+ /* Best-effort traffic class queues */
+ for (q = 0; q < RTE_SCHED_BE_QUEUES_PER_PIPE; q++) {
status = rte_tm_node_add(port_id,
queue_node_id(n_spp, n_pps, s, p, t, q),
tc_node_id(n_spp, n_pps, s, p, t),
&error);
if (status)
return -1;
- } /* Queue */
+ }
} /* TC */
} /* Pipe */
} /* Subport */
* tc1 <profile_id>
* tc2 <profile_id>
* tc3 <profile_id>
+ * tc4 <profile_id>
+ * tc5 <profile_id>
+ * tc6 <profile_id>
+ * tc7 <profile_id>
+ * tc8 <profile_id>
+ * tc9 <profile_id>
+ * tc10 <profile_id>
+ * tc11 <profile_id>
+ * tc12 <profile_id>
* shared shaper
* tc0 <id | none>
* tc1 <id | none>
* tc2 <id | none>
* tc3 <id | none>
+ * tc4 <id | none>
+ * tc5 <id | none>
+ * tc6 <id | none>
+ * tc7 <id | none>
+ * tc8 <id | none>
+ * tc9 <id | none>
+ * tc10 <id | none>
+ * tc11 <id | none>
+ * tc12 <id | none>
* weight
- * queue <q0> ... <q15>
+ * queue <q12> ... <q15>
*/
static void
cmd_tmgr_hierarchy_default(struct pmd_internals *softnic,
size_t out_size)
{
struct tmgr_hierarchy_default_params p;
- int i, status;
+ int i, j, status;
memset(&p, 0, sizeof(p));
- if (n_tokens != 50) {
+ if (n_tokens != 74) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
return;
}
+ if (strcmp(tokens[22], "tc4") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc4");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[4], tokens[23]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc4 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[24], "tc5") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc5");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[5], tokens[25]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc5 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[26], "tc6") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc6");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[6], tokens[27]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc6 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[28], "tc7") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc7");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[7], tokens[29]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc7 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[30], "tc8") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc8");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[8], tokens[31]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc8 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[32], "tc9") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc9");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[9], tokens[33]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc9 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[34], "tc10") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc10");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[10], tokens[35]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc10 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[36], "tc11") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc11");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[11], tokens[37]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc11 profile id");
+ return;
+ }
+
+ if (strcmp(tokens[38], "tc12") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc12");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(&p.shaper_profile_id.tc[12], tokens[39]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "tc12 profile id");
+ return;
+ }
+
/* Shared shaper */
- if (strcmp(tokens[22], "shared") != 0) {
+ if (strcmp(tokens[40], "shared") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "shared");
return;
}
- if (strcmp(tokens[23], "shaper") != 0) {
+ if (strcmp(tokens[41], "shaper") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "shaper");
return;
}
- if (strcmp(tokens[24], "tc0") != 0) {
+ if (strcmp(tokens[42], "tc0") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc0");
return;
}
- if (strcmp(tokens[25], "none") == 0)
+ if (strcmp(tokens[43], "none") == 0)
p.shared_shaper_id.tc_valid[0] = 0;
else {
- if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[0], tokens[25]) != 0) {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[0],
+ tokens[43]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc0");
return;
}
p.shared_shaper_id.tc_valid[0] = 1;
}
- if (strcmp(tokens[26], "tc1") != 0) {
+ if (strcmp(tokens[44], "tc1") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc1");
return;
}
- if (strcmp(tokens[27], "none") == 0)
+ if (strcmp(tokens[45], "none") == 0)
p.shared_shaper_id.tc_valid[1] = 0;
else {
- if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[1], tokens[27]) != 0) {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[1],
+ tokens[45]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc1");
return;
}
p.shared_shaper_id.tc_valid[1] = 1;
}
- if (strcmp(tokens[28], "tc2") != 0) {
+ if (strcmp(tokens[46], "tc2") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc2");
return;
}
- if (strcmp(tokens[29], "none") == 0)
+ if (strcmp(tokens[47], "none") == 0)
p.shared_shaper_id.tc_valid[2] = 0;
else {
- if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[2], tokens[29]) != 0) {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[2],
+ tokens[47]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc2");
return;
}
p.shared_shaper_id.tc_valid[2] = 1;
}
- if (strcmp(tokens[30], "tc3") != 0) {
+ if (strcmp(tokens[48], "tc3") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc3");
return;
}
- if (strcmp(tokens[31], "none") == 0)
+ if (strcmp(tokens[49], "none") == 0)
p.shared_shaper_id.tc_valid[3] = 0;
else {
- if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[3], tokens[31]) != 0) {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[3],
+ tokens[49]) != 0) {
snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc3");
return;
}
p.shared_shaper_id.tc_valid[3] = 1;
}
+ if (strcmp(tokens[50], "tc4") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc4");
+ return;
+ }
+
+ if (strcmp(tokens[51], "none") == 0) {
+ p.shared_shaper_id.tc_valid[4] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[4],
+ tokens[51]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc4");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[4] = 1;
+ }
+
+ if (strcmp(tokens[52], "tc5") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc5");
+ return;
+ }
+
+ if (strcmp(tokens[53], "none") == 0) {
+ p.shared_shaper_id.tc_valid[5] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[5],
+ tokens[53]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc5");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[5] = 1;
+ }
+
+ if (strcmp(tokens[54], "tc6") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc6");
+ return;
+ }
+
+ if (strcmp(tokens[55], "none") == 0) {
+ p.shared_shaper_id.tc_valid[6] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[6],
+ tokens[55]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc6");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[6] = 1;
+ }
+
+ if (strcmp(tokens[56], "tc7") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc7");
+ return;
+ }
+
+ if (strcmp(tokens[57], "none") == 0) {
+ p.shared_shaper_id.tc_valid[7] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[7],
+ tokens[57]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc7");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[7] = 1;
+ }
+
+ if (strcmp(tokens[58], "tc8") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc8");
+ return;
+ }
+
+ if (strcmp(tokens[59], "none") == 0) {
+ p.shared_shaper_id.tc_valid[8] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[8],
+ tokens[59]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc8");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[8] = 1;
+ }
+
+ if (strcmp(tokens[60], "tc9") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc9");
+ return;
+ }
+
+ if (strcmp(tokens[61], "none") == 0) {
+ p.shared_shaper_id.tc_valid[9] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[9],
+ tokens[61]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc9");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[9] = 1;
+ }
+
+ if (strcmp(tokens[62], "tc10") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc10");
+ return;
+ }
+
+ if (strcmp(tokens[63], "none") == 0) {
+ p.shared_shaper_id.tc_valid[10] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[10],
+ tokens[63]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc10");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[10] = 1;
+ }
+
+ if (strcmp(tokens[64], "tc11") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc11");
+ return;
+ }
+
+ if (strcmp(tokens[65], "none") == 0) {
+ p.shared_shaper_id.tc_valid[11] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[11],
+ tokens[65]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc11");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[11] = 1;
+ }
+
+ if (strcmp(tokens[66], "tc12") != 0) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc12");
+ return;
+ }
+
+ if (strcmp(tokens[67], "none") == 0) {
+ p.shared_shaper_id.tc_valid[12] = 0;
+ } else {
+ if (softnic_parser_read_uint32(&p.shared_shaper_id.tc[12],
+ tokens[67]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "shared shaper tc12");
+ return;
+ }
+
+ p.shared_shaper_id.tc_valid[12] = 1;
+ }
+
/* Weight */
- if (strcmp(tokens[32], "weight") != 0) {
+ if (strcmp(tokens[68], "weight") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "weight");
return;
}
- if (strcmp(tokens[33], "queue") != 0) {
+ if (strcmp(tokens[69], "queue") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "queue");
return;
}
- for (i = 0; i < 16; i++) {
- if (softnic_parser_read_uint32(&p.weight.queue[i], tokens[34 + i]) != 0) {
- snprintf(out, out_size, MSG_ARG_INVALID, "weight queue");
- return;
+ for (i = 0, j = 0; i < 16; i++) {
+ if (i < RTE_SCHED_TRAFFIC_CLASS_BE) {
+ p.weight.queue[i] = 1;
+ } else {
+ if (softnic_parser_read_uint32(&p.weight.queue[i],
+ tokens[70 + j]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID, "weight queue");
+ return;
+ }
+ j++;
}
}
/**
* cryptodev <tap_name> dev <device_name> | dev_id <device_id>
- * queue <n_queues> <queue_size>
+ * queue <n_queues> <queue_size> max_sessions <n_sessions>
**/
static void
char *name;
memset(¶ms, 0, sizeof(params));
- if (n_tokens != 7) {
+ if (n_tokens != 9) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
}
return;
}
+ if (strcmp(tokens[7], "max_sessions")) {
+ snprintf(out, out_size, MSG_ARG_NOT_FOUND,
+ "4");
+ return;
+ }
+
+ if (softnic_parser_read_uint32(¶ms.session_pool_size, tokens[8])
+ < 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID,
+ "q");
+ return;
+ }
+
if (softnic_cryptodev_create(softnic, name, ¶ms) == NULL) {
snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
return;
* tc <n_tc>
* stats none | pkts | bytes | both]
* [tm spp <n_subports_per_port> pps <n_pipes_per_subport>]
- * [encap ether | vlan | qinq | mpls | pppoe |
+ * [encap ether | vlan | qinq | mpls | pppoe | qinq_pppoe |
* vxlan offset <ether_offset> ipv4 | ipv6 vlan on | off]
* [nat src | dst
* proto udp | tcp]
p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VXLAN;
n_extra_tokens = 5;
+ } else if (strcmp(tokens[t0 + 1], "qinq_pppoe") == 0) {
+ p.encap.encap_mask =
+ 1LLU << RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE;
} else {
snprintf(out, out_size, MSG_ARG_MISMATCH, "encap");
return;
}
+
p.action_mask |= 1LLU << RTE_TABLE_ACTION_ENCAP;
t0 += 2 + n_extra_tokens;
} /* encap */
t0 += 1;
} /* decap */
+ if (t0 < n_tokens && (strcmp(tokens[t0], "sym_crypto") == 0)) {
+ struct softnic_cryptodev *cryptodev;
+
+ if (n_tokens < t0 + 5 ||
+ strcmp(tokens[t0 + 1], "dev") ||
+ strcmp(tokens[t0 + 3], "offset")) {
+ snprintf(out, out_size, MSG_ARG_MISMATCH,
+ "table action profile sym_crypto");
+ return;
+ }
+
+ cryptodev = softnic_cryptodev_find(softnic, tokens[t0 + 2]);
+ if (cryptodev == NULL) {
+ snprintf(out, out_size, MSG_ARG_INVALID,
+ "table action profile sym_crypto");
+ return;
+ }
+
+ p.sym_crypto.cryptodev_id = cryptodev->dev_id;
+
+ if (softnic_parser_read_uint32(&p.sym_crypto.op_offset,
+ tokens[t0 + 4]) != 0) {
+ snprintf(out, out_size, MSG_ARG_INVALID,
+ "table action profile sym_crypto");
+ return;
+ }
+
+ p.sym_crypto.mp_create = cryptodev->mp_create;
+ p.sym_crypto.mp_init = cryptodev->mp_init;
+
+ p.action_mask |= 1LLU << RTE_TABLE_ACTION_SYM_CRYPTO;
+
+ t0 += 5;
+ } /* sym_crypto */
+
if (t0 < n_tokens) {
snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
return;
p.type = PORT_IN_RXQ;
- strcpy(p.dev_name, tokens[t0 + 1]);
+ strlcpy(p.dev_name, tokens[t0 + 1], sizeof(p.dev_name));
if (strcmp(tokens[t0 + 2], "rxq") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
p.type = PORT_IN_SWQ;
- strcpy(p.dev_name, tokens[t0 + 1]);
+ strlcpy(p.dev_name, tokens[t0 + 1], sizeof(p.dev_name));
t0 += 2;
} else if (strcmp(tokens[t0], "tmgr") == 0) {
p.type = PORT_IN_TMGR;
- strcpy(p.dev_name, tokens[t0 + 1]);
+ strlcpy(p.dev_name, tokens[t0 + 1], sizeof(p.dev_name));
t0 += 2;
} else if (strcmp(tokens[t0], "tap") == 0) {
p.type = PORT_IN_TAP;
- strcpy(p.dev_name, tokens[t0 + 1]);
+ strlcpy(p.dev_name, tokens[t0 + 1], sizeof(p.dev_name));
if (strcmp(tokens[t0 + 2], "mempool") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND,
return;
}
- strcpy(p.action_profile_name, tokens[t0 + 1]);
+ strlcpy(p.action_profile_name, tokens[t0 + 1],
+ sizeof(p.action_profile_name));
t0 += 2;
}
p.type = PORT_OUT_TXQ;
- strcpy(p.dev_name, tokens[7]);
+ strlcpy(p.dev_name, tokens[7], sizeof(p.dev_name));
if (strcmp(tokens[8], "txq") != 0) {
snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
p.type = PORT_OUT_SWQ;
- strcpy(p.dev_name, tokens[7]);
+ strlcpy(p.dev_name, tokens[7], sizeof(p.dev_name));
} else if (strcmp(tokens[6], "tmgr") == 0) {
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
p.type = PORT_OUT_TMGR;
- strcpy(p.dev_name, tokens[7]);
+ strlcpy(p.dev_name, tokens[7], sizeof(p.dev_name));
} else if (strcmp(tokens[6], "tap") == 0) {
if (n_tokens != 8) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
p.type = PORT_OUT_TAP;
- strcpy(p.dev_name, tokens[7]);
+ strlcpy(p.dev_name, tokens[7], sizeof(p.dev_name));
} else if (strcmp(tokens[6], "sink") == 0) {
if ((n_tokens != 7) && (n_tokens != 11)) {
snprintf(out, out_size, MSG_ARG_MISMATCH,
return;
}
- strcpy(p.action_profile_name, tokens[t0 + 1]);
+ strlcpy(p.action_profile_name, tokens[t0 + 1],
+ sizeof(p.action_profile_name));
t0 += 2;
}
uint16_t svlan;
uint16_t ethertype_cvlan;
uint16_t cvlan;
-} __attribute__((__packed__));
+} __rte_packed;
struct pkt_key_ipv4_5tuple {
uint8_t time_to_live;
uint32_t da;
uint16_t sp;
uint16_t dp;
-} __attribute__((__packed__));
+} __rte_packed;
struct pkt_key_ipv6_5tuple {
uint16_t payload_length;
uint8_t da[16];
uint16_t sp;
uint16_t dp;
-} __attribute__((__packed__));
+} __rte_packed;
struct pkt_key_ipv4_addr {
uint32_t addr;
-} __attribute__((__packed__));
+} __rte_packed;
struct pkt_key_ipv6_addr {
uint8_t addr[16];
-} __attribute__((__packed__));
+} __rte_packed;
static uint32_t
parse_match(char **tokens,
* ether <da> <sa>
* | vlan <da> <sa> <pcp> <dei> <vid>
* | qinq <da> <sa> <pcp> <dei> <vid> <pcp> <dei> <vid>
+ * | qinq_pppoe <da> <sa> <pcp> <dei> <vid> <pcp> <dei> <vid> <session_id>
* | mpls unicast | multicast
* <da> <sa>
* label0 <label> <tc> <ttl>
softnic_parser_read_uint32(&mtr->meter_profile_id, tokens[1]) ||
strcmp(tokens[2], "policer") ||
strcmp(tokens[3], "g") ||
- parse_policer_action(tokens[4], &mtr->policer[e_RTE_METER_GREEN]) ||
+ parse_policer_action(tokens[4], &mtr->policer[RTE_COLOR_GREEN]) ||
strcmp(tokens[5], "y") ||
- parse_policer_action(tokens[6], &mtr->policer[e_RTE_METER_YELLOW]) ||
+ parse_policer_action(tokens[6], &mtr->policer[RTE_COLOR_YELLOW]) ||
strcmp(tokens[7], "r") ||
- parse_policer_action(tokens[8], &mtr->policer[e_RTE_METER_RED]))
+ parse_policer_action(tokens[8], &mtr->policer[RTE_COLOR_RED]))
return 0;
return 9;
return 1 + 9;
}
+ /* qinq_pppoe */
+ if (n_tokens && (strcmp(tokens[0], "qinq_pppoe") == 0)) {
+ uint32_t svlan_pcp, svlan_dei, svlan_vid;
+ uint32_t cvlan_pcp, cvlan_dei, cvlan_vid;
+
+ if (n_tokens < 10 ||
+ softnic_parse_mac_addr(tokens[1],
+ &a->encap.qinq_pppoe.ether.da) ||
+ softnic_parse_mac_addr(tokens[2],
+ &a->encap.qinq_pppoe.ether.sa) ||
+ softnic_parser_read_uint32(&svlan_pcp, tokens[3]) ||
+ svlan_pcp > 0x7 ||
+ softnic_parser_read_uint32(&svlan_dei, tokens[4]) ||
+ svlan_dei > 0x1 ||
+ softnic_parser_read_uint32(&svlan_vid, tokens[5]) ||
+ svlan_vid > 0xFFF ||
+ softnic_parser_read_uint32(&cvlan_pcp, tokens[6]) ||
+ cvlan_pcp > 0x7 ||
+ softnic_parser_read_uint32(&cvlan_dei, tokens[7]) ||
+ cvlan_dei > 0x1 ||
+ softnic_parser_read_uint32(&cvlan_vid, tokens[8]) ||
+ cvlan_vid > 0xFFF ||
+ softnic_parser_read_uint16(&a->encap.qinq_pppoe.pppoe.session_id,
+ tokens[9]))
+ return 0;
+
+ a->encap.qinq_pppoe.svlan.pcp = svlan_pcp & 0x7;
+ a->encap.qinq_pppoe.svlan.dei = svlan_dei & 0x1;
+ a->encap.qinq_pppoe.svlan.vid = svlan_vid & 0xFFF;
+ a->encap.qinq_pppoe.cvlan.pcp = cvlan_pcp & 0x7;
+ a->encap.qinq_pppoe.cvlan.dei = cvlan_dei & 0x1;
+ a->encap.qinq_pppoe.cvlan.vid = cvlan_vid & 0xFFF;
+ a->encap.type = RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE;
+ a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
+ return 1 + 10;
+ }
+
/* mpls */
if (n_tokens && (strcmp(tokens[0], "mpls") == 0)) {
uint32_t label, tc, ttl;
switch (xform[i]->type) {
case RTE_CRYPTO_SYM_XFORM_CIPHER:
- if (xform[i]->cipher.key.data)
- free(xform[i]->cipher.key.data);
- if (p->cipher_auth.cipher_iv.val)
- free(p->cipher_auth.cipher_iv.val);
- if (p->cipher_auth.cipher_iv_update.val)
- free(p->cipher_auth.cipher_iv_update.val);
+ free(p->cipher_auth.cipher_iv.val);
+ free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AUTH:
- if (xform[i]->auth.key.data)
- free(xform[i]->cipher.key.data);
if (p->cipher_auth.auth_iv.val)
free(p->cipher_auth.cipher_iv.val);
if (p->cipher_auth.auth_iv_update.val)
free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AEAD:
- if (xform[i]->aead.key.data)
- free(xform[i]->cipher.key.data);
- if (p->aead.iv.val)
- free(p->aead.iv.val);
- if (p->aead.aad.val)
- free(p->aead.aad.val);
+ free(p->aead.iv.val);
+ free(p->aead.aad.val);
break;
default:
continue;
static struct rte_crypto_sym_xform *
parse_table_action_cipher(struct rte_table_action_sym_crypto_params *p,
- char **tokens, uint32_t n_tokens, uint32_t encrypt,
- uint32_t *used_n_tokens)
+ uint8_t *key, uint32_t max_key_len, char **tokens,
+ uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
{
struct rte_crypto_sym_xform *xform_cipher;
int status;
/* cipher_key */
len = strlen(tokens[4]);
- xform_cipher->cipher.key.data = calloc(1, len / 2 + 1);
- if (xform_cipher->cipher.key.data == NULL)
+ if (len / 2 > max_key_len) {
+ status = -ENOMEM;
goto error_exit;
+ }
- status = softnic_parse_hex_string(tokens[4],
- xform_cipher->cipher.key.data,
- (uint32_t *)&len);
+ status = softnic_parse_hex_string(tokens[4], key, (uint32_t *)&len);
if (status < 0)
goto error_exit;
+ xform_cipher->cipher.key.data = key;
xform_cipher->cipher.key.length = (uint16_t)len;
/* cipher_iv */
return xform_cipher;
error_exit:
- if (xform_cipher->cipher.key.data)
- free(xform_cipher->cipher.key.data);
-
if (p->cipher_auth.cipher_iv.val) {
free(p->cipher_auth.cipher_iv.val);
p->cipher_auth.cipher_iv.val = NULL;
static struct rte_crypto_sym_xform *
parse_table_action_cipher_auth(struct rte_table_action_sym_crypto_params *p,
- char **tokens, uint32_t n_tokens, uint32_t encrypt,
- uint32_t *used_n_tokens)
+ uint8_t *key, uint32_t max_key_len, char **tokens,
+ uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
{
struct rte_crypto_sym_xform *xform_cipher;
struct rte_crypto_sym_xform *xform_auth;
/* auth_key */
len = strlen(tokens[10]);
- xform_auth->auth.key.data = calloc(1, len / 2 + 1);
- if (xform_auth->auth.key.data == NULL)
+ if (len / 2 > max_key_len) {
+ status = -ENOMEM;
goto error_exit;
+ }
- status = softnic_parse_hex_string(tokens[10],
- xform_auth->auth.key.data, (uint32_t *)&len);
+ status = softnic_parse_hex_string(tokens[10], key, (uint32_t *)&len);
if (status < 0)
goto error_exit;
+ xform_auth->auth.key.data = key;
xform_auth->auth.key.length = (uint16_t)len;
+ key += xform_auth->auth.key.length;
+ max_key_len -= xform_auth->auth.key.length;
+
if (strcmp(tokens[11], "digest_size"))
goto error_exit;
if (status < 0)
goto error_exit;
- xform_cipher = parse_table_action_cipher(p, tokens, 7, encrypt,
- used_n_tokens);
+ xform_cipher = parse_table_action_cipher(p, key, max_key_len, tokens, 7,
+ encrypt, used_n_tokens);
if (xform_cipher == NULL)
goto error_exit;
}
error_exit:
- if (xform_auth->auth.key.data)
- free(xform_auth->auth.key.data);
if (p->cipher_auth.auth_iv.val) {
free(p->cipher_auth.auth_iv.val);
p->cipher_auth.auth_iv.val = 0;
static struct rte_crypto_sym_xform *
parse_table_action_aead(struct rte_table_action_sym_crypto_params *p,
- char **tokens, uint32_t n_tokens, uint32_t encrypt,
- uint32_t *used_n_tokens)
+ uint8_t *key, uint32_t max_key_len, char **tokens,
+ uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
{
struct rte_crypto_sym_xform *xform_aead;
int status;
/* aead_key */
len = strlen(tokens[4]);
- xform_aead->aead.key.data = calloc(1, len / 2 + 1);
- if (xform_aead->aead.key.data == NULL)
+ if (len / 2 > max_key_len) {
+ status = -ENOMEM;
goto error_exit;
+ }
- status = softnic_parse_hex_string(tokens[4], xform_aead->aead.key.data,
- (uint32_t *)&len);
+ status = softnic_parse_hex_string(tokens[4], key, (uint32_t *)&len);
if (status < 0)
goto error_exit;
+ xform_aead->aead.key.data = key;
xform_aead->aead.key.length = (uint16_t)len;
/* aead_iv */
return xform_aead;
error_exit:
- if (xform_aead->aead.key.data)
- free(xform_aead->aead.key.data);
if (p->aead.iv.val) {
free(p->aead.iv.val);
p->aead.iv.val = NULL;
{
struct rte_table_action_sym_crypto_params *p = &a->sym_crypto;
struct rte_crypto_sym_xform *xform = NULL;
+ uint8_t *key = a->sym_crypto_key;
+ uint32_t max_key_len = SYM_CRYPTO_MAX_KEY_SIZE;
uint32_t used_n_tokens;
uint32_t encrypt;
int status;
tokens += 3;
n_tokens -= 3;
- xform = parse_table_action_cipher(p, tokens, n_tokens, encrypt,
- &used_n_tokens);
+ xform = parse_table_action_cipher(p, key, max_key_len, tokens,
+ n_tokens, encrypt, &used_n_tokens);
} else if (strcmp(tokens[3], "cipher_auth") == 0) {
tokens += 3;
n_tokens -= 3;
- xform = parse_table_action_cipher_auth(p, tokens, n_tokens,
- encrypt, &used_n_tokens);
+ xform = parse_table_action_cipher_auth(p, key, max_key_len,
+ tokens, n_tokens, encrypt, &used_n_tokens);
} else if (strcmp(tokens[3], "aead") == 0) {
tokens += 3;
n_tokens -= 3;
- xform = parse_table_action_aead(p, tokens, n_tokens, encrypt,
- &used_n_tokens);
+ xform = parse_table_action_aead(p, key, max_key_len, tokens,
+ n_tokens, encrypt, &used_n_tokens);
}
if (xform == NULL)
for (dscp = 0, l = 1; ; l++) {
char line[64];
char *tokens[3];
- enum rte_meter_color color;
+ enum rte_color color;
uint32_t tc_id, tc_queue_id, n_tokens = RTE_DIM(tokens);
if (fgets(line, sizeof(line), f) == NULL)
switch (tokens[2][0]) {
case 'g':
case 'G':
- color = e_RTE_METER_GREEN;
+ color = RTE_COLOR_GREEN;
break;
case 'y':
case 'Y':
- color = e_RTE_METER_YELLOW;
+ color = RTE_COLOR_YELLOW;
break;
case 'r':
case 'R':
- color = e_RTE_METER_RED;
+ color = RTE_COLOR_RED;
break;
default: