/**
* Packet IO worker thread using bursts from/to IO resources
*
* @param arg thread arguments of type 'thread_args_t *'
*/
static void *pktio_ifburst_thread(void *arg)
{
int thr;
thread_args_t *thr_args;
int pkts, pkts_ok;
odp_packet_t pkt_tbl[MAX_PKT_BURST];
int src_idx, dst_idx;
odp_pktio_t pktio_src, pktio_dst;
thr = odp_thread_id();
thr_args = arg;
stats_t *stats = calloc(1, sizeof(stats_t));
*thr_args->stats = stats;
src_idx = thr_args->src_idx;
dst_idx = (src_idx % 2 == 0) ? src_idx+1 : src_idx-1;
pktio_src = gbl_args->pktios[src_idx];
pktio_dst = gbl_args->pktios[dst_idx];
printf("[%02i] srcif:%s dstif:%s spktio:%02" PRIu64
" dpktio:%02" PRIu64 " BURST mode\n",
thr,
gbl_args->appl.if_names[src_idx],
gbl_args->appl.if_names[dst_idx],
odp_pktio_to_u64(pktio_src), odp_pktio_to_u64(pktio_dst));
odp_barrier_wait(&barrier);
/* Loop packets */
while (!exit_threads) {
pkts = odp_pktio_recv(pktio_src, pkt_tbl, MAX_PKT_BURST);
if (pkts <= 0)
continue;
/* Drop packets with errors */
pkts_ok = drop_err_pkts(pkt_tbl, pkts);
if (pkts_ok > 0) {
int sent = odp_pktio_send(pktio_dst, pkt_tbl, pkts_ok);
sent = sent > 0 ? sent : 0;
if (odp_unlikely(sent < pkts_ok)) {
stats->drops += pkts_ok - sent;
do
odp_packet_free(pkt_tbl[sent]);
while (++sent < pkts_ok);
}
}
if (odp_unlikely(pkts_ok != pkts))
stats->drops += pkts - pkts_ok;
if (pkts_ok == 0)
continue;
stats->packets += pkts_ok;
}
free(stats);
return NULL;
}
void pktio_test_send_on_ronly(void)
{
odp_pktio_t pktio;
odp_packet_t pkt;
int ret;
pktio = create_pktio(0, ODP_PKTIN_MODE_RECV,
ODP_PKTOUT_MODE_DISABLED);
if (pktio == ODP_PKTIO_INVALID) {
CU_FAIL("failed to open pktio");
return;
}
ret = odp_pktio_start(pktio);
CU_ASSERT_FATAL(ret == 0);
pkt = odp_packet_alloc(default_pkt_pool, packet_len);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID)
pktio_init_packet(pkt);
ret = odp_pktio_send(pktio, &pkt, 1);
CU_ASSERT(ret < 0);
if (ret <= 0)
odp_packet_free(pkt);
ret = odp_pktio_stop(pktio);
CU_ASSERT_FATAL(ret == 0);
ret = odp_pktio_close(pktio);
CU_ASSERT_FATAL(ret == 0);
}
int pktout_enqueue(queue_entry_t *qentry, odp_buffer_hdr_t *buf_hdr)
{
odp_packet_t pkt = _odp_packet_from_buffer(buf_hdr->handle.handle);
int len = 1;
int nbr;
nbr = odp_pktio_send(qentry->s.pktout, &pkt, len);
return (nbr == len ? 0 : -1);
}
int pktout_enq_multi(queue_entry_t *qentry, odp_buffer_hdr_t *buf_hdr[],
int num)
{
odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
int nbr;
int i;
for (i = 0; i < num; ++i)
pkt_tbl[i] = odp_packet_from_buffer(buf_hdr[i]->handle.handle);
nbr = odp_pktio_send(qentry->s.pktout, pkt_tbl, num);
return (nbr == num ? 0 : -1);
}
/**
* Packet IO loopback worker thread using bursts from/to IO resources
*
* @param arg thread arguments of type 'thread_args_t *'
*/
static void *pktio_ifburst_thread(void *arg)
{
int thr;
odp_buffer_pool_t pkt_pool;
odp_pktio_t pktio;
thread_args_t *thr_args;
int pkts, pkts_ok;
odp_packet_t pkt_tbl[MAX_PKT_BURST];
unsigned long pkt_cnt = 0;
unsigned long err_cnt = 0;
unsigned long tmp = 0;
odp_pktio_params_t params;
socket_params_t *sock_params = ¶ms.sock_params;
thr = odp_thread_id();
thr_args = arg;
printf("Pktio thread [%02i] starts, pktio_dev:%s\n", thr,
thr_args->pktio_dev);
/* Lookup the packet pool */
pkt_pool = odp_buffer_pool_lookup("packet_pool");
if (pkt_pool == ODP_BUFFER_POOL_INVALID || pkt_pool != thr_args->pool) {
ODP_ERR(" [%02i] Error: pkt_pool not found\n", thr);
return NULL;
}
/* Open a packet IO instance for this thread */
sock_params->type = thr_args->type;
sock_params->fanout = thr_args->fanout;
pktio = odp_pktio_open(thr_args->pktio_dev, pkt_pool, ¶ms);
if (pktio == ODP_PKTIO_INVALID) {
ODP_ERR(" [%02i] Error: pktio create failed.\n", thr);
return NULL;
}
printf(" [%02i] created pktio:%02i, burst mode\n",
thr, pktio);
/* Loop packets */
for (;;) {
pkts = odp_pktio_recv(pktio, pkt_tbl, MAX_PKT_BURST);
if (pkts > 0) {
/* Drop packets with errors */
pkts_ok = drop_err_pkts(pkt_tbl, pkts);
if (pkts_ok > 0) {
/* Swap Eth MACs and IP-addrs */
swap_pkt_addrs(pkt_tbl, pkts_ok);
odp_pktio_send(pktio, pkt_tbl, pkts_ok);
}
if (odp_unlikely(pkts_ok != pkts))
ODP_ERR("Dropped frames:%u - err_cnt:%lu\n",
pkts-pkts_ok, ++err_cnt);
/* Print packet counts every once in a while */
tmp += pkts_ok;
if (odp_unlikely((tmp >= 100000) || /* OR first print:*/
((pkt_cnt == 0) && ((tmp-1) < MAX_PKT_BURST)))) {
pkt_cnt += tmp;
printf(" [%02i] pkt_cnt:%lu\n", thr, pkt_cnt);
fflush(NULL);
tmp = 0;
}
}
}
/* unreachable */
}
/**
* Packet IO worker thread accessing IO resources directly
*
* @param arg thread arguments of type 'thread_args_t *'
*/
static void *pktio_direct_recv_thread(void *arg)
{
int thr;
int pkts;
odp_packet_t pkt_tbl[MAX_PKT_BURST];
int src_idx, dst_idx;
odp_pktio_t pktio_src, pktio_dst;
thread_args_t *thr_args = arg;
stats_t *stats = thr_args->stats;
thr = odp_thread_id();
src_idx = thr_args->src_idx;
dst_idx = gbl_args->dst_port[src_idx];
pktio_src = gbl_args->pktios[src_idx];
pktio_dst = gbl_args->pktios[dst_idx];
printf("[%02i] srcif:%s dstif:%s spktio:%02" PRIu64
" dpktio:%02" PRIu64 " DIRECT RECV mode\n",
thr,
gbl_args->appl.if_names[src_idx],
gbl_args->appl.if_names[dst_idx],
odp_pktio_to_u64(pktio_src), odp_pktio_to_u64(pktio_dst));
odp_barrier_wait(&barrier);
/* Loop packets */
while (!exit_threads) {
int sent, i;
unsigned tx_drops;
pkts = odp_pktio_recv(pktio_src, pkt_tbl, MAX_PKT_BURST);
if (odp_unlikely(pkts <= 0))
continue;
if (gbl_args->appl.error_check) {
int rx_drops;
/* Drop packets with errors */
rx_drops = drop_err_pkts(pkt_tbl, pkts);
if (odp_unlikely(rx_drops)) {
stats->s.rx_drops += rx_drops;
if (pkts == rx_drops)
continue;
pkts -= rx_drops;
}
}
fill_eth_addrs(pkt_tbl, pkts, dst_idx);
sent = odp_pktio_send(pktio_dst, pkt_tbl, pkts);
sent = odp_unlikely(sent < 0) ? 0 : sent;
tx_drops = pkts - sent;
if (odp_unlikely(tx_drops)) {
stats->s.tx_drops += tx_drops;
/* Drop rejected packets */
for (i = sent; i < pkts; i++)
odp_packet_free(pkt_tbl[i]);
}
stats->s.packets += pkts;
}
/* Make sure that latest stat writes are visible to other threads */
odp_mb_full();
return NULL;
}
/**
* Packet IO worker thread using ODP queues
*
* @param arg thread arguments of type 'thread_args_t *'
*/
static void *pktio_queue_thread(void *arg)
{
odp_event_t ev_tbl[MAX_PKT_BURST];
odp_packet_t pkt_tbl[MAX_PKT_BURST];
int pkts;
int thr;
uint64_t wait;
int dst_idx;
odp_pktio_t pktio_dst;
thread_args_t *thr_args = arg;
stats_t *stats = thr_args->stats;
thr = odp_thread_id();
printf("[%02i] QUEUE mode\n", thr);
odp_barrier_wait(&barrier);
wait = odp_schedule_wait_time(ODP_TIME_MSEC_IN_NS * 100);
/* Loop packets */
while (!exit_threads) {
int sent, i;
unsigned tx_drops;
pkts = odp_schedule_multi(NULL, wait, ev_tbl, MAX_PKT_BURST);
if (pkts <= 0)
continue;
for (i = 0; i < pkts; i++)
pkt_tbl[i] = odp_packet_from_event(ev_tbl[i]);
if (gbl_args->appl.error_check) {
int rx_drops;
/* Drop packets with errors */
rx_drops = drop_err_pkts(pkt_tbl, pkts);
if (odp_unlikely(rx_drops)) {
stats->s.rx_drops += rx_drops;
if (pkts == rx_drops)
continue;
pkts -= rx_drops;
}
}
/* packets from the same queue are from the same interface */
dst_idx = lookup_dest_port(pkt_tbl[0]);
fill_eth_addrs(pkt_tbl, pkts, dst_idx);
pktio_dst = gbl_args->pktios[dst_idx];
sent = odp_pktio_send(pktio_dst, pkt_tbl, pkts);
sent = odp_unlikely(sent < 0) ? 0 : sent;
tx_drops = pkts - sent;
if (odp_unlikely(tx_drops)) {
stats->s.tx_drops += tx_drops;
/* Drop rejected packets */
for (i = sent; i < pkts; i++)
odp_packet_free(pkt_tbl[i]);
}
stats->s.packets += pkts;
}
/* Make sure that latest stat writes are visible to other threads */
odp_mb_full();
return NULL;
}
void pktio_test_send_failure(void)
{
odp_pktio_t pktio_tx, pktio_rx;
odp_packet_t pkt_tbl[TX_BATCH_LEN];
uint32_t pkt_seq[TX_BATCH_LEN];
int ret, mtu, i, alloc_pkts;
odp_pool_param_t pool_params;
odp_pool_t pkt_pool;
int long_pkt_idx = TX_BATCH_LEN / 2;
pktio_info_t info_rx;
pktio_tx = create_pktio(0, ODP_PKTIN_MODE_RECV,
ODP_PKTOUT_MODE_SEND);
if (pktio_tx == ODP_PKTIO_INVALID) {
CU_FAIL("failed to open pktio");
return;
}
/* read the MTU from the transmit interface */
mtu = odp_pktio_mtu(pktio_tx);
ret = odp_pktio_start(pktio_tx);
CU_ASSERT_FATAL(ret == 0);
/* configure the pool so that we can generate test packets larger
* than the interface MTU */
memset(&pool_params, 0, sizeof(pool_params));
pool_params.pkt.len = mtu + 32;
pool_params.pkt.seg_len = pool_params.pkt.len;
pool_params.pkt.num = TX_BATCH_LEN + 1;
pool_params.type = ODP_POOL_PACKET;
pkt_pool = odp_pool_create("pkt_pool_oversize", &pool_params);
CU_ASSERT_FATAL(pkt_pool != ODP_POOL_INVALID);
if (num_ifaces > 1) {
pktio_rx = create_pktio(1, ODP_PKTIN_MODE_RECV,
ODP_PKTOUT_MODE_SEND);
ret = odp_pktio_start(pktio_rx);
CU_ASSERT_FATAL(ret == 0);
} else {
pktio_rx = pktio_tx;
}
/* generate a batch of packets with a single overly long packet
* in the middle */
for (i = 0; i < TX_BATCH_LEN; ++i) {
uint32_t pkt_len;
if (i == long_pkt_idx)
pkt_len = pool_params.pkt.len;
else
pkt_len = PKT_LEN_NORMAL;
pkt_tbl[i] = odp_packet_alloc(pkt_pool, pkt_len);
if (pkt_tbl[i] == ODP_PACKET_INVALID)
break;
pkt_seq[i] = pktio_init_packet(pkt_tbl[i]);
pktio_pkt_set_macs(pkt_tbl[i], pktio_tx, pktio_rx);
if (pktio_fixup_checksums(pkt_tbl[i]) != 0) {
odp_packet_free(pkt_tbl[i]);
break;
}
if (pkt_seq[i] == TEST_SEQ_INVALID) {
odp_packet_free(pkt_tbl[i]);
break;
}
}
alloc_pkts = i;
if (alloc_pkts == TX_BATCH_LEN) {
/* try to send the batch with the long packet in the middle,
* the initial short packets should be sent successfully */
odp_errno_zero();
ret = odp_pktio_send(pktio_tx, pkt_tbl, TX_BATCH_LEN);
CU_ASSERT(ret == long_pkt_idx);
CU_ASSERT(odp_errno() == 0);
info_rx.id = pktio_rx;
info_rx.outq = ODP_QUEUE_INVALID;
info_rx.inq = ODP_QUEUE_INVALID;
info_rx.in_mode = ODP_PKTIN_MODE_RECV;
for (i = 0; i < ret; ++i) {
pkt_tbl[i] = wait_for_packet(&info_rx, pkt_seq[i],
ODP_TIME_SEC_IN_NS);
if (pkt_tbl[i] == ODP_PACKET_INVALID)
break;
}
if (i == ret) {
/* now try to send starting with the too-long packet
* and verify it fails */
odp_errno_zero();
ret = odp_pktio_send(pktio_tx,
&pkt_tbl[long_pkt_idx],
TX_BATCH_LEN - long_pkt_idx);
CU_ASSERT(ret == -1);
CU_ASSERT(odp_errno() != 0);
} else {
CU_FAIL("failed to receive transmitted packets\n");
}
/* now reduce the size of the long packet and attempt to send
* again - should work this time */
i = long_pkt_idx;
odp_packet_pull_tail(pkt_tbl[i],
odp_packet_len(pkt_tbl[i]) -
PKT_LEN_NORMAL);
pkt_seq[i] = pktio_init_packet(pkt_tbl[i]);
pktio_pkt_set_macs(pkt_tbl[i], pktio_tx, pktio_rx);
ret = pktio_fixup_checksums(pkt_tbl[i]);
CU_ASSERT_FATAL(ret == 0);
CU_ASSERT_FATAL(pkt_seq[i] != TEST_SEQ_INVALID);
ret = odp_pktio_send(pktio_tx, &pkt_tbl[i], TX_BATCH_LEN - i);
CU_ASSERT_FATAL(ret == (TX_BATCH_LEN - i));
for (; i < TX_BATCH_LEN; ++i) {
pkt_tbl[i] = wait_for_packet(&info_rx,
pkt_seq[i],
ODP_TIME_SEC_IN_NS);
if (pkt_tbl[i] == ODP_PACKET_INVALID)
break;
}
CU_ASSERT(i == TX_BATCH_LEN);
} else {
CU_FAIL("failed to generate test packets\n");
}
for (i = 0; i < alloc_pkts; ++i) {
if (pkt_tbl[i] != ODP_PACKET_INVALID)
odp_packet_free(pkt_tbl[i]);
}
if (pktio_rx != pktio_tx)
CU_ASSERT(odp_pktio_close(pktio_rx) == 0);
CU_ASSERT(odp_pktio_close(pktio_tx) == 0);
CU_ASSERT(odp_pool_destroy(pkt_pool) == 0);
}
void* thread_fwd_routine(void *arg)
{
odp_packet_t pkt_tbl[PACKET_IO_BURST];
int rv_nb, sd_nb;
int thr_id;
int out_port;
int tuple[5];
int i;
thr_id = odp_thread_id();
printf("fwd thread %d start(on cpu %d)\n", thr_id, odp_cpu_id());
//match to port id
thr_id--;
memset(&port_stat.stat[thr_id], 0 , 3 * sizeof(uint64_t));
for(;;)
{
rv_nb = odp_pktio_recv(thr_data.nic_hdl[thr_id], pkt_tbl,
PACKET_IO_BURST);
port_stat.stat[thr_id].recv += rv_nb;
#ifdef EXECUTE_CLASSIFICATION
for(i = 0; i < rv_nb; i++)
{
if(extract_tuple(pkt_tbl[i], tuple) == 0)
{
int res;
res = packet_classifier_search(tuple);
}
}
#endif
#ifdef EXECUTE_HASH_LOOKUP
for(i = 0; i < rv_nb; i++)
{
if(extract_tuple(pkt_tbl[i], tuple) == 0)
{
int res;
res = odph_hash_lookup(hs_tbl, (void*)tuple);
}
}
#endif
#ifdef EXECUTE_DPI
unsigned char *payload;
int payload_len;
for(i = 0; i < rv_nb; i++)
{
if(get_payload(pkt_tbl[i], (unsigned char**)&payload, &payload_len) == 0)
{
int res;
//printf("%d %d %s\n", thr_id, strlen(payload), payload);
res = sm_search(sm_hdl, payload, payload_len);
//printf("search res: %d\n", res);
}
}
#endif
if((thr_id & 1) == 1)
{
out_port = thr_id - 1;
}
else
{
out_port = thr_id + 1 == glb_param.nic.num ? thr_id : thr_id + 1;
}
sd_nb = odp_pktio_send(thr_data.nic_hdl[out_port], pkt_tbl, rv_nb);
port_stat.stat[thr_id].send += sd_nb;
while(sd_nb < rv_nb)
{
odp_packet_free(pkt_tbl[sd_nb++]);
port_stat.stat[thr_id].drop++;
}
}
return NULL;
}
