static void pfring_zc_daq_shutdown(void *handle) {
Pfring_Context_t *context = (Pfring_Context_t *) handle;
int i;
if (!context->ipc_attach) {
if (context->cluster)
pfring_zc_destroy_cluster(context->cluster);
} else {
for (i = 0; i < context->num_devices; i++)
if (context->rx_queues[i])
pfring_zc_ipc_detach_queue(context->rx_queues[i]);
if (context->ipc_pool)
pfring_zc_ipc_detach_buffer_pool(context->ipc_pool);
}
if (context->devices[DAQ_PF_RING_PASSIVE_DEV_IDX])
free(context->devices[DAQ_PF_RING_PASSIVE_DEV_IDX]);
free(context);
}
int main(int argc, char* argv[]) {
char c;
int cluster_id = -1, queue_id = -1;
pthread_t my_thread;
int wait_for_packet = 1, verbose = 0, dump_as_sysdig_event = 0;
startTime.tv_sec = 0;
while((c = getopt(argc,argv,"ac:g:hi:svu")) != '?') {
if((c == 255) || (c == -1)) break;
switch(c) {
case 'h':
printHelp();
break;
case 'a':
wait_for_packet = 0;
break;
case 'c':
cluster_id = atoi(optarg);
break;
case 'i':
queue_id = atoi(optarg);
break;
case 'g':
bind_core = atoi(optarg);
break;
case 's':
dump_as_sysdig_event = 1;
break;
case 'v':
verbose = 1;
break;
case 'u':
vm_guest = 1;
break;
}
}
if (cluster_id < 0) printHelp();
if (queue_id < 0) printHelp();
bind2node(bind_core);
/* volatile global variables initialization */
globals = calloc(1, sizeof(*globals));
globals->wait_for_packet = wait_for_packet;
globals->verbose = verbose;
globals->dump_as_sysdig_event = dump_as_sysdig_event;
globals->numPkts = 0;
globals->numBytes = 0;
globals->do_shutdown = 0;
if (vm_guest)
pfring_zc_vm_guest_init(NULL /* auto */);
zq = pfring_zc_ipc_attach_queue(cluster_id, queue_id, rx_only);
if(zq == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_queue error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
zp = pfring_zc_ipc_attach_buffer_pool(cluster_id, queue_id);
if(zp == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_buffer_pool error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
buffer = pfring_zc_get_packet_handle_from_pool(zp);
if (buffer == NULL) {
fprintf(stderr, "pfring_zc_get_packet_handle_from_pool error\n");
return -1;
}
signal(SIGINT, sigproc);
signal(SIGTERM, sigproc);
signal(SIGINT, sigproc);
pthread_create(&my_thread, NULL, packet_consumer_thread, (void*) NULL);
if (!verbose) while (!globals->do_shutdown) {
sleep(ALARM_SLEEP);
print_stats();
}
pthread_join(my_thread, NULL);
sleep(1);
pfring_zc_release_packet_handle_to_pool(zp, buffer);
pfring_zc_ipc_detach_queue(zq);
pfring_zc_ipc_detach_buffer_pool(zp);
return 0;
}
int main(int argc, char* argv[]) {
char c;
int cluster_id = -1, in_queue_id = -1, out_queue_id = -1;
pthread_t my_thread;
startTime.tv_sec = 0;
while((c = getopt(argc,argv,"ac:g:hi:o:fvu")) != '?') {
if((c == 255) || (c == -1)) break;
switch(c) {
case 'h':
printHelp();
break;
case 'a':
wait_for_packet = 0;
break;
case 'f':
flush_packet = 1;
break;
case 'v':
verbose = 1;
break;
case 'c':
cluster_id = atoi(optarg);
break;
case 'i':
in_queue_id = atoi(optarg);
break;
case 'o':
out_queue_id = atoi(optarg);
break;
case 'g':
bind_core = atoi(optarg);
break;
case 'u':
vm_guest = 1;
break;
}
}
if (in_queue_id < 0) printHelp();
if (out_queue_id < 0) printHelp();
if (cluster_id < 0) printHelp();
if (vm_guest)
pfring_zc_vm_guest_init(NULL /* auto */);
inzq = pfring_zc_ipc_attach_queue(cluster_id, in_queue_id, rx_only);
if(inzq == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_queue error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
outzq = pfring_zc_ipc_attach_queue(cluster_id, out_queue_id, tx_only);
if(outzq == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_queue error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
zp = pfring_zc_ipc_attach_buffer_pool(cluster_id, in_queue_id);
if(zp == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_buffer_pool error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
tmpbuff = pfring_zc_get_packet_handle_from_pool(zp);
if (tmpbuff == NULL) {
fprintf(stderr, "pfring_zc_get_packet_handle_from_pool error\n");
return -1;
}
signal(SIGINT, sigproc);
signal(SIGTERM, sigproc);
signal(SIGINT, sigproc);
if (!verbose) { /* periodic stats */
signal(SIGALRM, my_sigalarm);
alarm(ALARM_SLEEP);
}
pthread_create(&my_thread, NULL, packet_consumer_thread, (void*) NULL);
pthread_join(my_thread, NULL);
sleep(1);
pfring_zc_release_packet_handle_to_pool(zp, tmpbuff);
pfring_zc_ipc_detach_queue(inzq);
pfring_zc_ipc_detach_queue(outzq);
pfring_zc_ipc_detach_buffer_pool(zp);
return 0;
}
int main(int argc, char* argv[]) {
char *device = NULL, c;
pthread_t thread;
pthread_t time_thread;
char *vm_sock = NULL;
int i, rc, ipc_q_attach = 0;
startTime.tv_sec = 0;
while((c = getopt(argc,argv,"ab:c:g:hi:n:p:l:zN:S:P:Q:")) != '?') {
if((c == 255) || (c == -1)) break;
switch(c) {
case 'h':
printHelp();
break;
case 'a':
active = 1;
break;
case 'b':
num_ips = atoi(optarg);
break;
case 'c':
cluster_id = atoi(optarg);
break;
case 'i':
device = strdup(optarg);
break;
case 'l':
packet_len = atoi(optarg);
break;
case 'n':
num_to_send = atoi(optarg);
break;
case 'p':
pps = atoi(optarg);
/* auto flush on wait flush_packet = 1; */
break;
case 'g':
bind_core = atoi(optarg);
break;
case 'Q':
enable_vm_support = 1;
vm_sock = strdup(optarg);
break;
#ifdef BURST_API
case 'z':
use_pkt_burst_api = 1;
break;
#endif
case 'N':
n2disk_producer = 1;
n2disk_threads = atoi(optarg);
break;
case 'S':
append_timestamp = 1;
bind_time_pulse_core = atoi(optarg);
break;
case 'P':
use_pulse_time = 1;
bind_time_pulse_core = atoi(optarg);
break;
}
}
if (n2disk_producer)
device = NULL;
/* checking if the interface is a queue allocated by an external cluster (ipc) */
if (device != NULL && is_a_queue(device, &cluster_id, &queue_id))
ipc_q_attach = 1;
if (cluster_id < 0) printHelp();
stdin_packet_len = read_packet_hex(stdin_packet, sizeof(stdin_packet));
if (stdin_packet_len > 0)
packet_len = stdin_packet_len;
if (n2disk_producer) {
if (device != NULL || ipc_q_attach) printHelp();
if (n2disk_threads < 1) printHelp();
metadata_len = N2DISK_METADATA;
num_consumer_buffers += (n2disk_threads * (N2DISK_CONSUMER_QUEUE_LEN + 1)) + N2DISK_PREFETCH_BUFFERS;
}
if (!ipc_q_attach) {
if (device != NULL)
num_queue_buffers = MAX_CARD_SLOTS;
else
num_queue_buffers = QUEUE_LEN;
zc = pfring_zc_create_cluster(
cluster_id,
max_packet_len(device),
metadata_len,
num_queue_buffers + NBUFF + num_consumer_buffers,
numa_node_of_cpu(bind_core),
NULL /* auto hugetlb mountpoint */
);
if(zc == NULL) {
fprintf(stderr, "pfring_zc_create_cluster error [%s] Please check your hugetlb configuration\n",
strerror(errno));
return -1;
}
for (i = 0; i < NBUFF; i++) {
buffers[i] = pfring_zc_get_packet_handle(zc);
if (buffers[i] == NULL) {
fprintf(stderr, "pfring_zc_get_packet_handle error\n");
return -1;
}
}
if (device) {
zq = pfring_zc_open_device(zc, device, tx_only, 0);
if(zq == NULL) {
fprintf(stderr, "pfring_zc_open_device error [%s] Please check that %s is up and not already used\n",
strerror(errno), device);
return -1;
}
fprintf(stderr, "Sending packets to %s\n", device);
} else {
zq = pfring_zc_create_queue(zc, num_queue_buffers);
if(zq == NULL) {
fprintf(stderr, "pfring_zc_create_queue error [%s]\n", strerror(errno));
return -1;
}
if (pfring_zc_create_buffer_pool(zc, n2disk_producer ? (N2DISK_PREFETCH_BUFFERS + n2disk_threads) : 1) == NULL) {
fprintf(stderr, "pfring_zc_create_buffer_pool error\n");
return -1;
}
fprintf(stderr, "Sending packets to cluster %u queue %u\n", cluster_id, 0);
if (n2disk_producer) {
char queues_list[256];
queues_list[0] = '\0';
for (i = 0; i < n2disk_threads; i++) {
if(pfring_zc_create_queue(zc, N2DISK_CONSUMER_QUEUE_LEN) == NULL) {
fprintf(stderr, "pfring_zc_create_queue error [%s]\n", strerror(errno));
return -1;
}
sprintf(&queues_list[strlen(queues_list)], "%d,", i+1);
}
queues_list[strlen(queues_list)-1] = '\0';
fprintf(stderr, "Run n2disk with: --cluster-ipc-attach --cluster-id %d --cluster-ipc-queues %s --cluster-ipc-pool 0\n", cluster_id, queues_list);
}
}
if (enable_vm_support) {
rc = pfring_zc_vm_register(zc, vm_sock);
if (rc < 0) {
fprintf(stderr, "pfring_zc_vm_register(%s) error\n", vm_sock);
return -1;
}
rc = pfring_zc_vm_backend_enable(zc);
if (rc < 0) {
fprintf(stderr, "pfring_zc_vm_backend_enable error\n");
return -1;
}
}
} else { /* IPC */
fprintf(stderr, "Attaching to cluster %d queue %d (IPC)\n", cluster_id, queue_id);
zq = pfring_zc_ipc_attach_queue(cluster_id, queue_id, tx_only);
if(zq == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_queue error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
zp = pfring_zc_ipc_attach_buffer_pool(cluster_id, queue_id);
if(zp == NULL) {
fprintf(stderr, "pfring_zc_ipc_attach_buffer_pool error [%s] Please check that cluster %d is running\n",
strerror(errno), cluster_id);
return -1;
}
for (i = 0; i < NBUFF; i++) {
buffers[i] = pfring_zc_get_packet_handle_from_pool(zp);
if (buffers[i] == NULL) {
fprintf(stderr, "pfring_zc_get_packet_handle_from_pool error\n");
return -1;
}
}
}
signal(SIGINT, sigproc);
signal(SIGTERM, sigproc);
signal(SIGINT, sigproc);
if (use_pulse_time) pulse_timestamp_ns = calloc(CACHE_LINE_LEN/sizeof(u_int64_t), sizeof(u_int64_t));
if (append_timestamp) pulse_timestamp_ns_n = calloc(CACHE_LINE_LEN/sizeof(u_int64_t), sizeof(u_int64_t));
if (append_timestamp || use_pulse_time) pthread_create(&time_thread, NULL, time_pulse_thread, NULL);
if (use_pulse_time) while (!*pulse_timestamp_ns && !do_shutdown); /* wait for ts */
if (append_timestamp) while (!*pulse_timestamp_ns_n && !do_shutdown); /* wait for ts */
pthread_create(&thread, NULL, send_traffic, NULL);
while (!do_shutdown) {
sleep(ALARM_SLEEP);
print_stats();
}
pthread_join(thread, NULL);
print_stats();
if (append_timestamp || use_pulse_time)
pthread_join(time_thread, NULL);
if (!ipc_q_attach) {
pfring_zc_destroy_cluster(zc);
} else {
for (i = 0; i < NBUFF; i++)
pfring_zc_release_packet_handle_to_pool(zp, buffers[i]);
pfring_zc_ipc_detach_queue(zq);
pfring_zc_ipc_detach_buffer_pool(zp);
}
return 0;
}