void configure_pktio_error_cos(void)
{
int retval;
odp_queue_param_t qparam;
char queuename[ODP_QUEUE_NAME_LEN];
char cosname[ODP_COS_NAME_LEN];
qparam.sched.prio = ODP_SCHED_PRIO_LOWEST;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "ErrorCos");
queue_list[CLS_ERROR] = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_ERROR] != ODP_QUEUE_INVALID);
sprintf(cosname, "%s", "ErrorCos");
cos_list[CLS_ERROR] = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_list[CLS_ERROR] != ODP_COS_INVALID);
retval = odp_cos_set_queue(cos_list[CLS_ERROR], queue_list[CLS_ERROR]);
CU_ASSERT(retval == 0);
retval = odp_pktio_error_cos_set(pktio_loop, cos_list[CLS_ERROR]);
CU_ASSERT(retval == 0);
}
void configure_pktio_default_cos(void)
{
int retval;
odp_queue_param_t qparam;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
sprintf(cosname, "DefaultCoS");
cos_list[CLS_DEFAULT] = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_list[CLS_DEFAULT] != ODP_COS_INVALID);
qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "DefaultQueue");
queue_list[CLS_DEFAULT] = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED, &qparam);
CU_ASSERT_FATAL(queue_list[CLS_DEFAULT] != ODP_QUEUE_INVALID);
retval = odp_cos_set_queue(cos_list[CLS_DEFAULT],
queue_list[CLS_DEFAULT]);
CU_ASSERT(retval == 0);
retval = odp_pktio_default_cos_set(pktio_loop, cos_list[CLS_DEFAULT]);
CU_ASSERT(retval == 0);
}
void configure_pktio_pmr_match_set_cos(void)
{
int retval;
odp_pmr_match_t pmr_terms[2];
uint16_t val;
uint16_t maskport;
int num_terms = 2; /* one pmr for each L3 and L4 */
odp_queue_param_t qparam;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
uint32_t addr = 0;
uint32_t mask;
parse_ipv4_string(CLS_PMR_SET_SADDR, &addr, &mask);
pmr_terms[0].term = ODP_PMR_SIP_ADDR;
pmr_terms[0].val = &addr;
pmr_terms[0].mask = &mask;
pmr_terms[0].val_sz = sizeof(addr);
val = CLS_PMR_SET_SPORT;
maskport = 0xffff;
pmr_terms[1].term = ODP_PMR_UDP_SPORT;
pmr_terms[1].val = &val;
pmr_terms[1].mask = &maskport;
pmr_terms[1].val_sz = sizeof(val);
retval = odp_pmr_match_set_create(num_terms, pmr_terms, &pmr_set);
CU_ASSERT(retval > 0);
sprintf(cosname, "cos_pmr_set");
cos_list[CLS_PMR_SET] = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_list[CLS_PMR_SET] != ODP_COS_INVALID)
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "cos_pmr_set_queue");
queue_list[CLS_PMR_SET] = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR_SET] != ODP_QUEUE_INVALID);
retval = odp_cos_set_queue(cos_list[CLS_PMR_SET],
queue_list[CLS_PMR_SET]);
CU_ASSERT(retval == 0);
retval = odp_pktio_pmr_match_set_cos(pmr_set, pktio_loop,
cos_list[CLS_PMR_SET]);
CU_ASSERT(retval == 0);
}
void configure_cos_with_l2_priority(void)
{
uint8_t num_qos = CLS_L2_QOS_MAX;
odp_cos_t cos_tbl[CLS_L2_QOS_MAX];
odp_queue_t queue_tbl[CLS_L2_QOS_MAX];
uint8_t qos_tbl[CLS_L2_QOS_MAX];
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
int retval;
int i;
odp_queue_param_t qparam;
/** Initialize scalar variable qos_tbl **/
for (i = 0; i < CLS_L2_QOS_MAX; i++)
qos_tbl[i] = 0;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
for (i = 0; i < num_qos; i++) {
qparam.sched.prio = ODP_SCHED_PRIO_LOWEST - i;
sprintf(cosname, "%s_%d", "L2_Cos", i);
cos_tbl[i] = odp_cos_create(cosname);
if (cos_tbl[i] == ODP_COS_INVALID)
break;
cos_list[CLS_L2_QOS_0 + i] = cos_tbl[i];
sprintf(queuename, "%s_%d", "L2_Queue", i);
queue_tbl[i] = odp_queue_create(queuename, ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_tbl[i] != ODP_QUEUE_INVALID);
queue_list[CLS_L2_QOS_0 + i] = queue_tbl[i];
retval = odp_cos_set_queue(cos_tbl[i], queue_tbl[i]);
CU_ASSERT(retval == 0);
qos_tbl[i] = i;
}
/* count 'i' is passed instead of num_qos to handle the rare scenario
if the odp_cos_create() failed in the middle*/
retval = odp_cos_with_l2_priority(pktio_loop, i, qos_tbl, cos_tbl);
CU_ASSERT(retval == 0);
}
void configure_pmr_cos(void)
{
uint16_t val;
uint16_t mask;
int retval;
val = CLS_PMR_SPORT;
mask = 0xffff;
odp_queue_param_t qparam;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
pmr_list[CLS_PMR] = odp_pmr_create(ODP_PMR_UDP_SPORT, &val,
&mask, sizeof(val));
CU_ASSERT(pmr_list[CLS_PMR] != ODP_PMR_INVAL);
sprintf(cosname, "PMR_CoS");
cos_list[CLS_PMR] = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_list[CLS_PMR] != ODP_COS_INVALID);
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "PMR_CoS");
queue_list[CLS_PMR] = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR] != ODP_QUEUE_INVALID);
retval = odp_cos_set_queue(cos_list[CLS_PMR],
queue_list[CLS_PMR]);
CU_ASSERT(retval == 0);
retval = odp_pktio_pmr_cos(pmr_list[CLS_PMR], pktio_loop,
cos_list[CLS_PMR]);
CU_ASSERT(retval == 0);
}
static void classification_test_cos_set_queue(void)
{
int retval;
char cosname[ODP_COS_NAME_LEN];
char queuename[ODP_QUEUE_NAME_LEN];
odp_queue_param_t qparam;
odp_queue_t queue_cos;
odp_cos_t cos_queue;
sprintf(cosname, "CoSQueue");
cos_queue = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_queue != ODP_COS_INVALID);
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "QueueCoS");
queue_cos = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED, &qparam);
retval = odp_cos_set_queue(cos_queue, queue_cos);
CU_ASSERT(retval == 0);
odp_cos_destroy(cos_queue);
odp_queue_destroy(queue_cos);
}
void configure_cls_pmr_chain(void)
{
/* PKTIO --> PMR_SRC(SRC IP ADDR) --> PMR_DST (TCP SPORT) */
/* Packet matching only the SRC IP ADDR should be delivered
in queue[CLS_PMR_CHAIN_SRC] and a packet matching both SRC IP ADDR and
TCP SPORT should be delivered to queue[CLS_PMR_CHAIN_DST] */
uint16_t val;
uint16_t maskport;
int retval;
char cosname[ODP_QUEUE_NAME_LEN];
odp_queue_param_t qparam;
char queuename[ODP_QUEUE_NAME_LEN];
uint32_t addr;
uint32_t mask;
sprintf(cosname, "SrcCos");
cos_list[CLS_PMR_CHAIN_SRC] = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_SRC] != ODP_COS_INVALID)
qparam.sched.prio = ODP_SCHED_PRIO_NORMAL;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "SrcQueue");
queue_list[CLS_PMR_CHAIN_SRC] = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR_CHAIN_SRC] != ODP_QUEUE_INVALID);
retval = odp_cos_set_queue(cos_list[CLS_PMR_CHAIN_SRC],
queue_list[CLS_PMR_CHAIN_SRC]);
CU_ASSERT(retval == 0);
sprintf(cosname, "DstCos");
cos_list[CLS_PMR_CHAIN_DST] = odp_cos_create(cosname);
CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_DST] != ODP_COS_INVALID);
qparam.sched.prio = ODP_SCHED_PRIO_NORMAL;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
sprintf(queuename, "%s", "DstQueue");
queue_list[CLS_PMR_CHAIN_DST] = odp_queue_create(queuename,
ODP_QUEUE_TYPE_SCHED,
&qparam);
CU_ASSERT_FATAL(queue_list[CLS_PMR_CHAIN_DST] != ODP_QUEUE_INVALID);
retval = odp_cos_set_queue(cos_list[CLS_PMR_CHAIN_DST],
queue_list[CLS_PMR_CHAIN_DST]);
parse_ipv4_string(CLS_PMR_CHAIN_SADDR, &addr, &mask);
pmr_list[CLS_PMR_CHAIN_SRC] = odp_pmr_create(ODP_PMR_SIP_ADDR, &addr,
&mask, sizeof(addr));
CU_ASSERT_FATAL(pmr_list[CLS_PMR_CHAIN_SRC] != ODP_PMR_INVAL);
val = CLS_PMR_CHAIN_SPORT;
maskport = 0xffff;
pmr_list[CLS_PMR_CHAIN_DST] = odp_pmr_create(ODP_PMR_UDP_SPORT, &val,
&maskport, sizeof(val));
CU_ASSERT_FATAL(pmr_list[CLS_PMR_CHAIN_DST] != ODP_PMR_INVAL);
retval = odp_pktio_pmr_cos(pmr_list[CLS_PMR_CHAIN_SRC], pktio_loop,
cos_list[CLS_PMR_CHAIN_SRC]);
CU_ASSERT(retval == 0);
retval = odp_cos_pmr_cos(pmr_list[CLS_PMR_CHAIN_DST],
cos_list[CLS_PMR_CHAIN_SRC],
cos_list[CLS_PMR_CHAIN_DST]);
CU_ASSERT(retval == 0);
}
static odp_cos_t build_cos_w_queue(const char *name)
{
odp_cos_t cos;
odp_queue_t queue_cos;
odp_queue_param_t qparam;
cos = odp_cos_create(name);
if (cos == ODP_COS_INVALID) {
OFP_ERR("Failed to create COS");
return ODP_COS_INVALID;
}
memset(&qparam, 0, sizeof(odp_queue_param_t));
qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qparam.sched.sync = ODP_SCHED_SYNC_ATOMIC;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
queue_cos = odp_queue_create(name,
ODP_QUEUE_TYPE_SCHED,
&qparam);
if (queue_cos == ODP_QUEUE_INVALID) {
OFP_ERR("Failed to create queue\n");
odp_cos_destroy(cos);
return ODP_COS_INVALID;
}
#if ODP_VERSION < 104
if (odp_cos_set_queue(cos, queue_cos) < 0) {
#else
if (odp_cos_queue_set(cos, queue_cos) < 0) {
#endif
OFP_ERR("Failed to set queue on COS");
odp_cos_destroy(cos);
odp_queue_destroy(queue_cos);
return ODP_COS_INVALID;
}
return cos;
}
static odp_cos_t build_cos_set_queue(const char *name, odp_queue_t queue_cos)
{
odp_cos_t cos;
cos = odp_cos_create(name);
if (cos == ODP_COS_INVALID) {
OFP_ERR("Failed to create COS");
return ODP_COS_INVALID;
}
#if ODP_VERSION < 104
if (odp_cos_set_queue(cos, queue_cos) < 0) {
#else
if (odp_cos_queue_set(cos, queue_cos) < 0) {
#endif
OFP_ERR("Failed to set queue on COS");
odp_cos_destroy(cos);
return ODP_COS_INVALID;
}
return cos;
}
static odp_pmr_t build_udp_prm(void)
{
uint32_t pmr_udp_val = TEST_PORT;
uint32_t pmr_udp_mask = 0xffffffff;
#if ODP_VERSION < 104
return odp_pmr_create(ODP_PMR_UDP_DPORT,
&pmr_udp_val,
&pmr_udp_mask,
1);
#else
const odp_pmr_match_t match = {
.term = ODP_PMR_UDP_DPORT,
.val = &pmr_udp_val,
.mask = &pmr_udp_mask,
.val_sz = 1
};
return odp_pmr_create(&match);
#endif
}
static void app_processing(void)
{
int fd_rcv = -1;
char buf[1500];
int len = sizeof(buf);
do {
struct ofp_sockaddr_in addr = {0};
fd_rcv = ofp_socket(OFP_AF_INET, OFP_SOCK_DGRAM,
OFP_IPPROTO_UDP);
if (fd_rcv == -1) {
OFP_ERR("Faild to create RCV socket (errno = %d)\n",
ofp_errno);
break;
}
addr.sin_len = sizeof(struct ofp_sockaddr_in);
addr.sin_family = OFP_AF_INET;
addr.sin_port = odp_cpu_to_be_16(TEST_PORT);
addr.sin_addr.s_addr = IP4(192, 168, 100, 1);
if (ofp_bind(fd_rcv, (const struct ofp_sockaddr *)&addr,
sizeof(struct ofp_sockaddr_in)) == -1) {
OFP_ERR("Faild to bind socket (errno = %d)\n",
ofp_errno);
break;
}
len = ofp_recv(fd_rcv, buf, len, 0);
if (len == -1)
OFP_ERR("Faild to receive data (errno = %d)\n",
ofp_errno);
else
OFP_INFO("Data received: length = %d.\n", len);
} while (0);
if (fd_rcv != -1) {
ofp_close(fd_rcv);
fd_rcv = -1;
}
OFP_INFO("Test ended.\n");
}
