int main(int argc, char* argv[]) { char *device = NULL, *dev, c; long i; int cluster_id = -1; char *bind_mask = NULL; pthread_t *threads; char *id; u_int numCPU = sysconf( _SC_NPROCESSORS_ONLN ); int hash_mode = 0; startTime.tv_sec = 0; while((c = getopt(argc,argv,"ac:g:hi:r:m:")) != '?') { 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 'm': hash_mode = atoi(optarg); break; case 'i': device = strdup(optarg); break; case 'g': bind_mask = strdup(optarg); break; case 'r': bind_worker_core = atoi(optarg); break; } } if (device == NULL) printHelp(); if (cluster_id < 0) printHelp(); if (bind_mask == NULL) printHelp(); id = strtok(bind_mask, ":"); while(id != NULL) { bind_core = realloc(bind_core, sizeof(int) * (num_threads+1)); bind_core[num_threads] = atoi(id) % numCPU; num_threads++; id = strtok(NULL, ":"); } if (num_threads < 1) printHelp(); dev = strtok(device, ","); while(dev != NULL) { devices = realloc(devices, sizeof(char *) * (num_devices+1)); devices[num_devices] = strdup(dev); num_devices++; dev = strtok(NULL, ","); } zc = pfring_zc_create_cluster( cluster_id, max_packet_len(devices[0]), 0, (num_devices * MAX_CARD_SLOTS) + (num_threads * QUEUE_LEN) + num_threads + PREFETCH_BUFFERS, numa_node_of_cpu(bind_worker_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; } threads = calloc(num_threads, sizeof(pthread_t)); buffers = calloc(num_threads, sizeof(pfring_zc_pkt_buff *)); inzq = calloc(num_devices, sizeof(pfring_zc_queue *)); outzq = calloc(num_threads, sizeof(pfring_zc_queue *)); consumers_stats = calloc(num_threads, sizeof(struct stats)); for (i = 0; i < num_threads; i++) { buffers[i] = pfring_zc_get_packet_handle(zc); if (buffers[i] == NULL) { fprintf(stderr, "pfring_zc_get_packet_handle error\n"); return -1; } } for (i = 0; i < num_devices; i++) { inzq[i] = pfring_zc_open_device(zc, devices[i], rx_only, 0); if(inzq[i] == NULL) { fprintf(stderr, "pfring_zc_open_device error [%s] Please check that %s is up and not already used\n", strerror(errno), devices[i]); return -1; } //printf("Created device with ID=%u, INDEX=%u\n", pfring_zc_get_queue_id(inzq[i]), QUEUEID_TO_IFINDEX(pfring_zc_get_queue_id(inzq[i]))); } for (i = 0; i < num_threads; i++) { outzq[i] = pfring_zc_create_queue(zc, QUEUE_LEN); if(outzq[i] == NULL) { fprintf(stderr, "pfring_zc_create_queue error [%s]\n", strerror(errno)); return -1; } //printf("Created queue with ID=%u\n", pfring_zc_get_queue_id(outzq[i])); } wsp = pfring_zc_create_buffer_pool(zc, PREFETCH_BUFFERS); if (wsp == NULL) { fprintf(stderr, "pfring_zc_create_buffer_pool error\n"); return -1; } signal(SIGINT, sigproc); signal(SIGTERM, sigproc); signal(SIGINT, sigproc); printf("Starting balancer with %d consumer threads..\n", num_threads); if (hash_mode < 2) { /* balancer */ pfring_zc_distribution_func func; if(strcmp(device, "sysdig") == 0) func = (hash_mode == 0) ? rr_distribution_func : sysdig_distribution_func; else func = (hash_mode == 0) ? rr_distribution_func : NULL /* built-in IP-based */; zw = pfring_zc_run_balancer( inzq, outzq, num_devices, num_threads, wsp, round_robin_bursts_policy, NULL /* idle callback */, func, (void *) ((long) num_threads), !wait_for_packet, bind_worker_core ); } else { outzmq = pfring_zc_create_multi_queue(outzq, num_threads); if(outzmq == NULL) { fprintf(stderr, "pfring_zc_create_multi_queue error [%s]\n", strerror(errno)); return -1; } zw = pfring_zc_run_fanout( inzq, outzmq, num_devices, wsp, round_robin_bursts_policy, NULL /* idle callback */, NULL /* built-in send-to-all */, (void *) ((long) num_threads), !wait_for_packet, bind_worker_core ); } if(zw == NULL) { fprintf(stderr, "pfring_zc_run_balancer error [%s]\n", strerror(errno)); return -1; } for (i = 0; i < num_threads; i++) pthread_create(&threads[i], NULL, consumer_thread, (void*) i); while (!do_shutdown) { sleep(ALARM_SLEEP); print_stats(); } for (i = 0; i < num_threads; i++) pthread_join(threads[i], NULL); pfring_zc_kill_worker(zw); pfring_zc_destroy_cluster(zc); return 0; }
static int pfring_zc_daq_initialize(const DAQ_Config_t *config, void **ctxt_ptr, char *errbuf, size_t len) { Pfring_Context_t *context; DAQ_Dict* entry; u_int numCPU = get_nprocs(); int i, max_buffer_len = 0, card_buffers; int num_buffers; int ipc_cluster_id; context = calloc(1, sizeof(Pfring_Context_t)); if (context == NULL) { snprintf(errbuf, len, "%s: Couldn't allocate memory for context!", __FUNCTION__); return DAQ_ERROR_NOMEM; } context->mode = config->mode; context->snaplen = config->snaplen; context->promisc_flag =(config->flags & DAQ_CFG_PROMISC); context->timeout = (config->timeout > 0) ? (int) config->timeout : -1; context->devices[DAQ_PF_RING_PASSIVE_DEV_IDX] = strdup(config->name); context->num_devices = 1; context->ids_bridge = 0; context->cluster_id = -1; context->max_buffer_len = 0; context->bindcpu = 0; context->ipc_attach = 0; if (!context->devices[DAQ_PF_RING_PASSIVE_DEV_IDX]) { snprintf(errbuf, len, "%s: Couldn't allocate memory for the device string!", __FUNCTION__); free(context); return DAQ_ERROR_NOMEM; } for (entry = config->values; entry; entry = entry->next) { if (!entry->value || !*entry->value) { snprintf(errbuf, len, "%s: variable needs value(%s)\n", __FUNCTION__, entry->key); return DAQ_ERROR; } else if (!strcmp(entry->key, "bindcpu")) { char *end = entry->value; context->bindcpu = (int) strtol(entry->value, &end, 0); if (*end || (context->bindcpu >= numCPU)) { snprintf(errbuf, len, "%s: bad bindcpu(%s)\n", __FUNCTION__, entry->value); return DAQ_ERROR; } else { cpu_set_t mask; CPU_ZERO(&mask); CPU_SET((int)context->bindcpu, &mask); if (sched_setaffinity(0, sizeof(mask), &mask) < 0) { snprintf(errbuf, len, "%s:failed to set bindcpu(%u) on pid %i\n", __FUNCTION__, context->bindcpu, getpid()); return DAQ_ERROR; } } } else if (!strcmp(entry->key, "timeout")) { char *end = entry->value; context->timeout = (int) strtol(entry->value, &end, 0); if (*end || (context->timeout < 0)) { snprintf(errbuf, len, "%s: bad timeout(%s)\n", __FUNCTION__, entry->value); return DAQ_ERROR; } } else if (!strcmp(entry->key, "idsbridge")) { if (context->mode == DAQ_MODE_PASSIVE) { char* end = entry->value; context->ids_bridge = (int) strtol(entry->value, &end, 0); if (*end || (context->ids_bridge < 0) || (context->ids_bridge > 2)) { snprintf(errbuf, len, "%s: bad ids bridge mode(%s)\n", __FUNCTION__, entry->value); return DAQ_ERROR; } } else { snprintf(errbuf, len, "%s: idsbridge is for passive mode only\n", __FUNCTION__); return DAQ_ERROR; } } else if (!strcmp(entry->key, "clusterid")) { char *end = entry->value; context->cluster_id = (int) strtol(entry->value, &end, 0); if (*end || (context->cluster_id < 0)) { snprintf(errbuf, len, "%s: bad clusterid(%s)\n", __FUNCTION__, entry->value); return DAQ_ERROR; } } else { snprintf(errbuf, len, "%s: unsupported variable(%s=%s)\n", __FUNCTION__, entry->key, entry->value); return DAQ_ERROR; } } if (context->mode == DAQ_MODE_READ_FILE) { snprintf(errbuf, len, "%s: function not supported on PF_RING", __FUNCTION__); free(context); return DAQ_ERROR; } else if (context->mode == DAQ_MODE_INLINE || (context->mode == DAQ_MODE_PASSIVE && context->ids_bridge)) { /* zc:ethX+zc:ethY,zc:ethZ+zc:ethJ */ char *twins, *twins_pos = NULL; context->num_devices = 0; twins = strtok_r(context->devices[DAQ_PF_RING_PASSIVE_DEV_IDX], ",", &twins_pos); while (twins != NULL) { char *dev, *dev_pos = NULL, *tx_dev; int last_twin = 0; dev = strtok_r(twins, "+", &dev_pos); while (dev != NULL) { if (context->num_devices >= DAQ_PF_RING_MAX_NUM_DEVICES) { snprintf(errbuf, len, "%s: Maximum num of devices reached (%d), you should increase " "DAQ_PF_RING_MAX_NUM_DEVICES.\n", __FUNCTION__, DAQ_PF_RING_MAX_NUM_DEVICES); free(context); return DAQ_ERROR; } last_twin = context->num_devices; context->devices[context->num_devices] = dev; tx_dev = strchr(dev, '-'); if (tx_dev != NULL) { /* use the specified device for tx */ tx_dev[0] = '\0'; tx_dev++; context->tx_devices[context->num_devices] = tx_dev; } else { context->tx_devices[context->num_devices] = dev; } context->num_devices++; dev = strtok_r(NULL, "+", &dev_pos); } if (context->num_devices & 0x1) { snprintf(errbuf, len, "%s: Wrong format: %s requires pairs of devices", __FUNCTION__, context->mode == DAQ_MODE_INLINE ? "inline mode" : "ids bridge"); free(context); return DAQ_ERROR; } if (last_twin > 0) /* new dev pair */ printf("%s <-> %s\n", context->devices[last_twin - 1], context->devices[last_twin]); twins = strtok_r(NULL, ",", &twins_pos); } } else if (context->mode == DAQ_MODE_PASSIVE) { /* zc:ethX,zc:ethY */ char *dev, *dev_pos = NULL; context->num_devices = 0; context->ipc_attach = 1; /* IPC queue attach supported in pure IDS only at the moment */ dev = strtok_r(context->devices[DAQ_PF_RING_PASSIVE_DEV_IDX], ",", &dev_pos); while (dev != NULL) { /* checking for IPC Queue */ if (!is_a_queue(dev, &ipc_cluster_id, &context->ipc_queues[context->num_devices])) { context->ipc_attach = 0; } else { if (context->cluster_id == -1) context->cluster_id = ipc_cluster_id; else if (ipc_cluster_id != context->cluster_id) context->ipc_attach = 0; } context->devices[context->num_devices++] = dev; dev = strtok_r(NULL, ",", &dev_pos); } } #ifdef SIG_RELOAD /* catching the SIGRELOAD signal, replacing the default snort handler */ if ((default_sig_reload_handler = signal(SIGHUP, pfring_zc_daq_sig_reload)) == SIG_ERR) default_sig_reload_handler = NULL; #endif if (!context->ipc_attach) { num_buffers = 2 /* buffer, buffer_inject */; #ifdef DAQ_PF_RING_BEST_EFFORT_BOOST if (context->mode == DAQ_MODE_PASSIVE && context->ids_bridge == 2) num_buffers += QUEUE_LEN; #endif for (i = 0; i < context->num_devices; i++) { max_buffer_len = max_packet_len(context, context->devices[i], i, &card_buffers); if (max_buffer_len > context->max_buffer_len) context->max_buffer_len = max_buffer_len; if (strstr(context->devices[i], "zc:") != NULL) num_buffers += card_buffers; if (context->tx_devices[i] != NULL) { max_buffer_len = max_packet_len(context, context->tx_devices[i], i, &card_buffers); if (max_buffer_len > context->max_buffer_len) context->max_buffer_len = max_buffer_len; if (strstr(context->tx_devices[i], "zc:") != NULL) num_buffers += card_buffers; } } context->cluster = pfring_zc_create_cluster(context->cluster_id, context->max_buffer_len, 0, num_buffers, context->bindcpu == 0 ? -1 : numa_node_of_cpu(context->bindcpu), NULL); if (context->cluster == NULL) { DPE(context->errbuf, "%s: Cluster failed: %s(%d)", __FUNCTION__, strerror(errno), errno); return DAQ_ERROR; } context->buffer = pfring_zc_get_packet_handle(context->cluster); if (context->buffer == NULL) { DPE(context->errbuf, "%s: Buffer allocation failed: %s(%d)", __FUNCTION__, strerror(errno), errno); return DAQ_ERROR; } context->buffer_inject = pfring_zc_get_packet_handle(context->cluster); if (context->buffer_inject == NULL) { DPE(context->errbuf, "%s: Buffer allocation failed: %s(%d)", __FUNCTION__, strerror(errno), errno); return DAQ_ERROR; } } else { context->ipc_pool = pfring_zc_ipc_attach_buffer_pool(context->cluster_id, context->ipc_queues[0]); if (context->ipc_pool == NULL) { snprintf(errbuf, len, "%s: pfring_zc_ipc_attach_buffer_pool error %s(%d), please check that cluster %d is running\n", __FUNCTION__, strerror(errno), errno, context->cluster_id); return -1; } context->buffer = pfring_zc_get_packet_handle_from_pool(context->ipc_pool); if (context->buffer == NULL) { DPE(context->errbuf, "%s: Buffer allocation failed: %s(%d)", __FUNCTION__, strerror(errno), errno); return DAQ_ERROR; } } for (i = 0; i < context->num_devices; i++) { if (pfring_zc_daq_open(context, i) == -1) return DAQ_ERROR; } if (!context->ipc_attach) { #ifdef DAQ_PF_RING_BEST_EFFORT_BOOST if (context->mode == DAQ_MODE_PASSIVE && context->ids_bridge == 2) { context->q = pfring_zc_create_queue(context->cluster, QUEUE_LEN); if (context->q == NULL) { snprintf(errbuf, len, "%s: Couldn't create queue: '%s'", __FUNCTION__, strerror(errno)); return DAQ_ERROR_NOMEM; } context->mq_queues[context->num_devices] = context->q; context->mq = pfring_zc_create_multi_queue(context->mq_queues, context->num_devices + 1); } #endif } context->state = DAQ_STATE_INITIALIZED; *ctxt_ptr = context; return DAQ_SUCCESS; }
int main(int argc, char* argv[]) { char c; char *ingress_devices = NULL, *egress_devices = NULL, *dev; long i; int wait_for_packet = 1; start_time.tv_sec = 0; while((c = getopt(argc,argv, "ac:g:hi:o:")) != '?') { 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': ingress_devices = strdup(optarg); break; case 'o': egress_devices = strdup(optarg); break; case 'g': bind_worker_core = atoi(optarg); break; } } if(cluster_id < 0) printHelp(); dev = strtok(ingress_devices, ","); while(dev != NULL) { in_devices = realloc(in_devices, sizeof(char *) * (num_in_devices+1)); in_devices[num_in_devices] = strdup(dev); num_in_devices++; dev = strtok(NULL, ","); } dev = strtok(egress_devices, ","); while(dev != NULL) { out_devices = realloc(out_devices, sizeof(char *) * (num_out_devices+1)); out_devices[num_out_devices] = strdup(dev); num_out_devices++; dev = strtok(NULL, ","); } if((num_in_devices == 0) || (num_out_devices == 0)) printHelp(); zc = pfring_zc_create_cluster(cluster_id, max_packet_len(in_devices[0]), metadata_len, ((num_in_devices + num_out_devices) * MAX_CARD_SLOTS) + PREFETCH_BUFFERS, numa_node_of_cpu(bind_worker_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; } inzqs = calloc(num_in_devices, sizeof(pfring_zc_queue *)); outzqs = calloc(num_out_devices, sizeof(pfring_zc_queue *)); for(i = 0; i < num_in_devices; i++) { inzqs[i] = pfring_zc_open_device(zc, in_devices[i], rx_only, 0); if(inzqs[i] == NULL) { fprintf(stderr, "[RX] pfring_zc_open_device error [%s] Please check that %s is up and not already used\n", strerror(errno), in_devices[i]); return -1; } } for(i = 0; i < num_out_devices; i++) { outzqs[i] = pfring_zc_open_device(zc, out_devices[i], tx_only, 0); if(outzqs[i] == NULL) { fprintf(stderr, "[TX] pfring_zc_open_device error [%s] Please check that %s is up and not already used\n", strerror(errno), out_devices[i]); return -1; } } signal(SIGINT, sigproc); signal(SIGTERM, sigproc); signal(SIGINT, sigproc); outzmq = pfring_zc_create_multi_queue(outzqs, num_out_devices); if(outzmq == NULL) { fprintf(stderr, "pfring_zc_create_multi_queue error [%s]\n", strerror(errno)); return -1; } wsp = pfring_zc_create_buffer_pool(zc, PREFETCH_BUFFERS); if(wsp == NULL) { fprintf(stderr, "pfring_zc_create_buffer_pool error\n"); return -1; } zw = pfring_zc_run_fanout(inzqs, outzmq, num_in_devices, wsp, round_robin_bursts_policy, NULL /* idle callback */, NULL /* fanout */, NULL, !wait_for_packet, bind_worker_core); if(zw == NULL) { fprintf(stderr, "pfring_zc_run_fanout error [%s]\n", strerror(errno)); return -1; } while(!do_shutdown) { sleep(ALARM_SLEEP); print_stats(); } pfring_zc_destroy_cluster(zc); return 0; }