/**
* 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_recv_on_wonly(void)
{
odp_pktio_t pktio;
odp_packet_t pkt;
int ret;
pktio = create_pktio(0, ODP_PKTIN_MODE_DISABLED,
ODP_PKTOUT_MODE_SEND);
if (pktio == ODP_PKTIO_INVALID) {
CU_FAIL("failed to open pktio");
return;
}
ret = odp_pktio_start(pktio);
CU_ASSERT_FATAL(ret == 0);
ret = odp_pktio_recv(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 pktin_deq_multi(queue_entry_t *qentry, odp_buffer_hdr_t *buf_hdr[], int num)
{
int nbr;
nbr = queue_deq_multi(qentry, buf_hdr, num);
if (nbr < num) {
odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
odp_buffer_t buf;
int pkts, i;
pkts = odp_pktio_recv(qentry->s.pktin, pkt_tbl,
QUEUE_MULTI_MAX);
if (pkts > 0) {
for (i = 0; i < pkts; ++i) {
buf = odp_buffer_from_packet(pkt_tbl[i]);
tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
}
queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
}
}
return nbr;
}
odp_buffer_hdr_t *pktin_dequeue(queue_entry_t *qentry)
{
odp_buffer_hdr_t *buf_hdr;
buf_hdr = queue_deq(qentry);
if (buf_hdr == NULL) {
odp_packet_t pkt;
odp_buffer_t buf;
odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
int pkts, i, j;
pkts = odp_pktio_recv(qentry->s.pktin, pkt_tbl,
QUEUE_MULTI_MAX);
if (pkts > 0) {
pkt = pkt_tbl[0];
buf = odp_buffer_from_packet(pkt);
buf_hdr = odp_buf_to_hdr(buf);
for (i = 1, j = 0; i < pkts; ++i) {
buf = odp_buffer_from_packet(pkt_tbl[i]);
tmp_hdr_tbl[j++] = odp_buf_to_hdr(buf);
}
queue_enq_multi(qentry, tmp_hdr_tbl, j);
}
}
return buf_hdr;
}
static void *iot_burst(void *arg) {
struct iofix fix = *((struct iofix*)arg);
odp_packet_t pkt_list [PKT_LIST_SIZE];
int packets,i;
for(;;){
packets = odp_pktio_recv(fix.pktio, pkt_list, PKT_LIST_SIZE);
//printf("packets: %d\n",packets);
for(i=0;i<packets;++i){
net_input(pkt_list[i]);
}
}
return NULL;
}
static void *pkt_io_recv(void *arg)
{
odp_pktio_t pktio;
odp_packet_t pkt, pkt_tbl[OFP_PKT_BURST_SIZE];
int pkt_idx, pkt_cnt;
struct pktio_thr_arg *thr_args;
ofp_pkt_processing_func pkt_func;
thr_args = arg;
pkt_func = thr_args->pkt_func;
if (odp_init_local(ODP_THREAD_WORKER)) {
OFP_ERR("Error: ODP local init failed.\n");
return NULL;
}
if (ofp_init_local()) {
OFP_ERR("Error: OFP local init failed.\n");
return NULL;
}
pktio = ofp_port_pktio_get(thr_args->port);
OFP_DBG("PKT-IO receive starting on port: %d, pktio-id: %"PRIX64"\n",
thr_args->port, odp_pktio_to_u64(pktio));
while (1) {
pkt_cnt = odp_pktio_recv(pktio, pkt_tbl, OFP_PKT_BURST_SIZE);
for (pkt_idx = 0; pkt_idx < pkt_cnt; pkt_idx++) {
pkt = pkt_tbl[pkt_idx];
if (odp_unlikely(odp_packet_has_error(pkt))) {
OFP_DBG("Packet with error dropped.\n");
odp_packet_free(pkt);
continue;
}
ofp_packet_input(pkt, ODP_QUEUE_INVALID, pkt_func);
}
#ifdef OFP_SEND_PKT_BURST
ofp_send_pending_pkt_burst();
#endif /*OFP_SEND_PKT_BURST*/
}
/* Never reached */
return NULL;
}
static odp_packet_t wait_for_packet(pktio_info_t *pktio_rx,
uint32_t seq, uint64_t ns)
{
odp_time_t wait_time, end;
odp_event_t ev;
odp_packet_t pkt;
uint64_t wait;
wait = odp_schedule_wait_time(ns);
wait_time = odp_time_local_from_ns(ns);
end = odp_time_sum(odp_time_local(), wait_time);
do {
pkt = ODP_PACKET_INVALID;
if (pktio_rx->in_mode == ODP_PKTIN_MODE_RECV) {
odp_pktio_recv(pktio_rx->id, &pkt, 1);
} else {
if (pktio_rx->in_mode == ODP_PKTIN_MODE_POLL)
ev = queue_deq_wait_time(pktio_rx->inq, ns);
else
ev = odp_schedule(NULL, wait);
if (ev != ODP_EVENT_INVALID) {
if (odp_event_type(ev) == ODP_EVENT_PACKET)
pkt = odp_packet_from_event(ev);
else
odp_event_free(ev);
}
}
if (pkt != ODP_PACKET_INVALID) {
if (pktio_pkt_seq(pkt) == seq)
return pkt;
odp_packet_free(pkt);
}
} while (odp_time_cmp(end, odp_time_local()) > 0);
CU_FAIL("failed to receive transmitted packet");
return ODP_PACKET_INVALID;
}
static int send_recv(odp_packet_t packet, int send_nb, int expt_nb)
{
static int test_id = 0;
printf("send_recv %d\n", test_id++);
odp_pktio_t pktio;
odp_queue_t outq_def;
odp_packet_t pkt_tbl[MAX_PKT_BURST];
pktio = odp_pktio_lookup(pktio_valid_name);
if (pktio == ODP_PKTIO_INVALID) {
printf("Error: lookup of pktio %s failed\n",
pktio_valid_name);
return 1;
}
outq_def = odp_pktio_outq_getdef(pktio);
if (outq_def == ODP_QUEUE_INVALID) {
printf("Error: def output-Q query\n");
return 1;
}
int i;
for ( i = 0; i < send_nb; ++i ) {
odp_queue_enq(outq_def, (odp_event_t)packet);
}
int ret = 0;
int start = __k1_read_dsu_timestamp();
while ( ret >= 0 && ret < expt_nb && ( __k1_read_dsu_timestamp() - start ) < 10 * __bsp_frequency ) {
int n_pkt = odp_pktio_recv(pktio, pkt_tbl, MAX_PKT_BURST);
ret += n_pkt;
if (n_pkt > 0)
odp_packet_free_multi(pkt_tbl, n_pkt);
}
test_assert_ret(ret == expt_nb);
odp_packet_free(packet);
printf("send_recv %d OK\n", test_id);
return 0;
}
/**
* 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;
}
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;
}
