void *packet_consumer_thread(void *data) {
if (bind_core >= 0)
bind2core(bind_core);
while(!do_shutdown) {
if(pfring_zc_recv_pkt(inzq, &tmpbuff, wait_for_packet) > 0) {
if (unlikely(verbose)) {
char bigbuf[4096];
pfring_print_pkt(bigbuf, sizeof(bigbuf), tmpbuff->data, tmpbuff->len, tmpbuff->len);
fputs(bigbuf, stdout);
}
#if 0
int i;
for(i = 0; i < tmpbuff->len; i++)
printf("%02X ", tmpbuff->data[i]);
printf("\n");
#endif
numPkts++;
numBytes += tmpbuff->len + 24; /* 8 Preamble + 4 CRC + 12 IFG */
while (unlikely(pfring_zc_send_pkt(outzq, &tmpbuff, flush_packet) < 0 && !do_shutdown))
usleep(1);
}
}
if (!flush_packet) pfring_zc_sync_queue(outzq, tx_only);
pfring_zc_sync_queue(inzq, rx_only);
return NULL;
}
void *pipeline_stage_thread(void* _id) {
long id = (long) _id;
pfring_zc_pkt_buff *b = buffers[id];
bind2core(bind_core[id]);
while(!do_shutdown) {
if(pfring_zc_recv_pkt(zq[id], &b, wait_for_packet) > 0) {
#ifdef METADATA_TEST
if (id == 0) { /* first pipeline stage */
static u_int64_t counter = 0;
u_int64_t *meta_p = (u_int64_t *) b->user;
*meta_p = counter;
counter++;
}
#endif
if (id < num_threads-1) { /* send to the next pipeline stage */
pfring_zc_send_pkt(zq[id+1], &b, flush_packet);
} else {/* last pipeline stage */
#ifdef METADATA_TEST
u_int64_t *meta_p = (u_int64_t *) b->user;
if (*meta_p != numPkts)
printf("Buffer Metadata contains unexpected value: %llu != %llu\n",
(long long unsigned) *meta_p, (long long unsigned) numPkts);
#endif
#if 0
int i;
for(i = 0; i < b->len; i++)
printf("%02X ", b->data[i]);
printf("\n");
#endif
numPkts++;
numBytes += b->len + 24; /* 8 Preamble + 4 CRC + 12 IFG */
}
}
}
if (id < num_threads-1) pfring_zc_sync_queue(zq[id+1], tx_only);
pfring_zc_sync_queue(zq[id], rx_only);
return NULL;
}
void *packet_consumer_thread(void *_i) {
struct dir_info *i = (struct dir_info *) _i;
int tx_queue_not_empty = 0;
if (i->bind_core >= 0)
bind2core(i->bind_core);
while(!do_shutdown) {
if(pfring_zc_recv_pkt(i->inzq, &i->tmpbuff, 0 /* wait_for_packet */) > 0) {
if (unlikely(verbose)) {
#if 1
char bigbuf[4096];
pfring_print_pkt(bigbuf, sizeof(bigbuf), pfring_zc_pkt_buff_data(i->tmpbuff, i->inzq), i->tmpbuff->len, i->tmpbuff->len);
fputs(bigbuf, stdout);
#else
u_char *pkt_data = pfring_zc_pkt_buff_data(i->tmpbuff, i->inzq);
int j;
for(j = 0; j < i->tmpbuff->len; j++)
printf("%02X ", pkt_data[j]);
printf("\n");
#endif
}
i->numPkts++;
i->numBytes += i->tmpbuff->len + 24; /* 8 Preamble + 4 CRC + 12 IFG */
errno = 0;
while (unlikely(pfring_zc_send_pkt(i->outzq, &i->tmpbuff, flush_packet) < 0 && errno != EMSGSIZE && !do_shutdown))
if (wait_for_packet) usleep(1);
tx_queue_not_empty = 1;
} else {
if (tx_queue_not_empty) {
pfring_zc_sync_queue(i->outzq, tx_only);
tx_queue_not_empty = 0;
}
if (wait_for_packet)
usleep(1);
}
}
if (!flush_packet) pfring_zc_sync_queue(i->outzq, tx_only);
pfring_zc_sync_queue(i->inzq, rx_only);
return NULL;
}
void *forwarder_thread(void *_info) {
forwarder_info_t *info = (forwarder_info_t *) _info;
pfring_zc_pkt_buff *b = info->buffer;
bind2core(info->bind_core);
while(!do_shutdown)
if(pfring_zc_recv_pkt(info->inzq, &b, wait_for_packet) > 0)
while (unlikely(pfring_zc_send_pkt(info->outzq, &b, flush_packet) < 0 && !do_shutdown)) usleep(1);
pfring_zc_sync_queue(info->outzq, tx_only);
pfring_zc_sync_queue(info->inzq, rx_only);
return NULL;
}
void recv_cleanup()
{
if (!pf_recv) {
return;
}
pfring_zc_sync_queue(pf_recv, rx_only);
}
void* consumer_thread(void* _id) {
long id = (long) _id;
pfring_zc_pkt_buff *b = buffers[id];
bind2core(bind_core[id]);
while(!consumers_stats[id].do_shutdown) {
if(pfring_zc_recv_pkt(outzq[id], &b, wait_for_packet) > 0) {
#if 0
int i;
for(i = 0; i < b->len; i++)
printf("%02X ", pfring_zc_pkt_buff_data(b, outzq[id])[i]);
printf("\n");
#endif
consumers_stats[id].numPkts++;
consumers_stats[id].numBytes += b->len + 24; /* 8 Preamble + 4 CRC + 12 IFG */
}
}
pfring_zc_sync_queue(outzq[id], rx_only);
return NULL;
}
void *packet_consumer_thread(void *_id) {
struct volatile_globals *g = globals;
bind2core(bind_core);
while(!g->do_shutdown) {
if(pfring_zc_recv_pkt(zq, &buffer, g->wait_for_packet) > 0) {
if (unlikely(g->verbose)) {
u_char *pkt_data = pfring_zc_pkt_buff_data(buffer, zq);
if (buffer->ts.tv_nsec)
printf("[%u.%u] ", buffer->ts.tv_sec, buffer->ts.tv_nsec);
if(g->dump_as_sysdig_event) {
struct sysdig_event_header *ev = (struct sysdig_event_header*)pkt_data;
printf("[cpu_id=%u][tid=%lu][%u|%s]",
buffer->hash, ev->thread_id,
ev->event_type, sysdig_event2name(ev->event_type));
} else {
int i;
for(i = 0; i < buffer->len; i++)
printf("%02X ", pkt_data[i]);
}
printf("\n");
}
g->numPkts++;
g->numBytes += buffer->len + 24; /* 8 Preamble + 4 CRC + 12 IFG */
}
}
pfring_zc_sync_queue(zq, rx_only);
return NULL;
}
void send_traffic() {
ticks hz, tick_start = 0, tick_delta = 0;
u_int32_t buffer_id = 0;
int sent_bytes;
#ifdef BURST_API
int i, sent_packets;
#endif
if (bind_core >= 0)
bind2core(bind_core);
if(pps > 0) {
/* cumputing usleep delay */
tick_start = getticks();
usleep(1);
tick_delta = getticks() - tick_start;
/* cumputing CPU freq */
tick_start = getticks();
usleep(1001);
hz = (getticks() - tick_start - tick_delta) * 1000 /*kHz -> Hz*/;
printf("Estimated CPU freq: %lu Hz\n", (long unsigned int) hz);
tick_delta = (double) (hz / pps);
tick_start = getticks();
}
#ifdef BURST_API
/****** Burst API ******/
if (use_pkt_burst_api) {
while (likely(!do_shutdown && (!num_to_send || numPkts < num_to_send))) {
if (numPkts < num_queue_buffers + NBUFF || num_ips > 1) { /* forge all buffers 1 time */
for (i = 0; i < BURSTLEN; i++) {
buffers[buffer_id + i]->len = packet_len;
if (stdin_packet_len > 0)
memcpy(buffers[buffer_id + i]->data, stdin_packet, stdin_packet_len);
else
forge_udp_packet(buffers[buffer_id + i]->data, numPkts + i);
}
}
/* TODO send unsent packets when a burst is partially sent */
while (unlikely((sent_packets = pfring_zc_send_pkt_burst(zq, &buffers[buffer_id], BURSTLEN, flush_packet)) <= 0)) {
if (unlikely(do_shutdown)) break;
if (!active) usleep(1);
}
numPkts += sent_packets;
numBytes += ((packet_len + 24 /* 8 Preamble + 4 CRC + 12 IFG */ ) * sent_packets);
buffer_id += BURSTLEN;
buffer_id &= NBUFFMASK;
if(pps > 0) {
u_int8_t synced = 0;
while((getticks() - tick_start) < (numPkts * tick_delta))
if (!synced) pfring_zc_sync_queue(zq, tx_only), synced = 1;
}
}
} else {
#endif
/****** Packet API ******/
while (likely(!do_shutdown && (!num_to_send || numPkts < num_to_send))) {
buffers[buffer_id]->len = packet_len;
#if 1
if (numPkts < num_queue_buffers + NBUFF || num_ips > 1) { /* forge all buffers 1 time */
if (stdin_packet_len > 0)
memcpy(buffers[buffer_id]->data, stdin_packet, stdin_packet_len);
else
forge_udp_packet(buffers[buffer_id]->data, numPkts);
}
#else
{
int k;
u_int8_t j = numPkts;
for(k = 0; k < buffers[buffer_id]->len; k++)
buffers[buffer_id]->data[k] = j++;
buffers[buffer_id]->data[k-1] = cluster_id;
}
#endif
while (unlikely((sent_bytes = pfring_zc_send_pkt(zq, &buffers[buffer_id], flush_packet)) < 0)) {
if (unlikely(do_shutdown)) break;
if (!active) usleep(1);
}
numPkts++;
numBytes += sent_bytes + 24; /* 8 Preamble + 4 CRC + 12 IFG */
buffer_id++;
buffer_id &= NBUFFMASK;
if(pps > 0) {
u_int8_t synced = 0;
while((getticks() - tick_start) < (numPkts * tick_delta))
if (!synced) pfring_zc_sync_queue(zq, tx_only), synced = 1;
}
}
#ifdef BURST_API
}
#endif
if (!flush_packet)
pfring_zc_sync_queue(zq, tx_only);
}