/*
* Should receive timeouts only
*/
static void *event_dispatcher(void *arg)
{
odp_event_t ev;
(void)arg;
ofp_init_local();
while (1) {
ev = odp_schedule(NULL, ODP_SCHED_WAIT);
if (ev == ODP_EVENT_INVALID)
continue;
if (odp_event_type(ev) == ODP_EVENT_TIMEOUT) {
ofp_timer_handle(ev);
continue;
}
OFP_ERR("Error: unexpected event type: %u\n",
odp_event_type(ev));
odp_buffer_free(odp_buffer_from_event(ev));
}
/* Never reached */
return NULL;
}
void *pp_thread(void *arg)
{
ALLOW_UNUSED_LOCAL(arg);
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return NULL;
}
while (odp_atomic_load_u32(&still_running)) {
odp_event_t event;
odp_queue_t source_queue;
event = odp_schedule(&source_queue, ODP_SCHED_WAIT);
if (odp_event_type(event) != ODP_EVENT_TIMEOUT) {
OFP_ERR("Unexpected event type %d",
odp_event_type(event));
continue;
}
ofp_timer_handle(event);
}
return NULL;
}
int default_event_dispatcher(void *arg)
{
odp_event_t ev;
odp_packet_t pkt;
odp_queue_t in_queue;
int event_idx = 0;
int event_cnt = 0;
ofp_pkt_processing_func pkt_func = (ofp_pkt_processing_func)arg;
odp_bool_t *is_running = NULL;
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return -1;
}
int rx_burst = global_param->evt_rx_burst_size;
odp_event_t events[rx_burst];
is_running = ofp_get_processing_state();
if (is_running == NULL) {
OFP_ERR("ofp_get_processing_state failed");
ofp_term_local();
return -1;
}
/* PER CORE DISPATCHER */
while (*is_running) {
event_cnt = odp_schedule_multi(&in_queue, ODP_SCHED_WAIT,
events, rx_burst);
for (event_idx = 0; event_idx < event_cnt; event_idx++) {
odp_event_type_t ev_type;
ev = events[event_idx];
if (ev == ODP_EVENT_INVALID)
continue;
ev_type = odp_event_type(ev);
if (odp_likely(ev_type == ODP_EVENT_PACKET)) {
pkt = odp_packet_from_event(ev);
#if 0
if (odp_unlikely(odp_packet_has_error(pkt))) {
OFP_DBG("Dropping packet with error");
odp_packet_free(pkt);
continue;
}
#endif
ofp_packet_input(pkt, in_queue, pkt_func);
continue;
}
if (ev_type == ODP_EVENT_TIMEOUT) {
ofp_timer_handle(ev);
continue;
}
OFP_ERR("Unexpected event type: %u", ev_type);
odp_event_free(ev);
}
ofp_send_pending_pkt();
}
if (ofp_term_local())
OFP_ERR("ofp_term_local failed");
return 0;
}
void *pp_thread(void *arg)
{
ALLOW_UNUSED_LOCAL(arg);
#if ODP_VERSION >= 102
if (odp_init_local(ODP_THREAD_WORKER)) {
#else
if (odp_init_local()) {
#endif
OFP_ERR("odp_init_local failed");
return NULL;
}
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return NULL;
}
while (odp_atomic_load_u32(&still_running)) {
odp_event_t event;
odp_queue_t source_queue;
event = odp_schedule(&source_queue, ODP_SCHED_WAIT);
if (odp_event_type(event) != ODP_EVENT_TIMEOUT) {
OFP_ERR("Unexpected event type %d",
odp_event_type(event));
continue;
}
ofp_timer_handle(event);
}
return NULL;
}
static void test_arp(void)
{
struct ofp_ifnet mock_ifnet;
struct in_addr ip;
uint8_t mac[OFP_ETHER_ADDR_LEN] = { 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, };
/* The buffer passed into ofp_ipv4_lookup_mac() must be 8 bytes since
* a 64-bit operation is currently being used to copy a MAC address.
*/
uint8_t mac_result[OFP_ETHER_ADDR_LEN + 2];
CU_ASSERT(0 == ofp_init_local());
memset(&mock_ifnet, 0, sizeof(mock_ifnet));
CU_ASSERT(0 != inet_aton("1.1.1.1", &ip));
/* Test entry insert, lookup, and remove. */
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
CU_ASSERT(0 == ofp_arp_ipv4_insert(ip.s_addr, mac, &mock_ifnet));
memset(mac_result, 0xFF, OFP_ETHER_ADDR_LEN);
CU_ASSERT(0 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
CU_ASSERT(0 == memcmp(mac, mac_result, OFP_ETHER_ADDR_LEN));
CU_ASSERT(0 == ofp_arp_ipv4_remove(ip.s_addr, &mock_ifnet));
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
/* Test entry is aged out. */
CU_ASSERT(0 == ofp_arp_ipv4_insert(ip.s_addr, mac, &mock_ifnet));
OFP_INFO("Inserted ARP entry");
sleep(ARP_AGE_INTERVAL + ARP_ENTRY_TIMEOUT);
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
/* Test entry is aged out after a few hits. */
CU_ASSERT(0 == ofp_arp_ipv4_insert(ip.s_addr, mac, &mock_ifnet));
OFP_INFO("Inserted ARP entry");
sleep(ARP_AGE_INTERVAL);
CU_ASSERT(0 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
sleep(ARP_AGE_INTERVAL);
CU_ASSERT(0 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
sleep(ARP_AGE_INTERVAL + ARP_ENTRY_TIMEOUT);
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
}
int main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp errno", init_suite, end_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite, test_arp)) {
CU_cleanup_registry();
return CU_get_error();
}
#if defined(OFP_TESTMODE_AUTO)
CU_set_output_filename("CUnit-Util");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
static ngx_int_t
ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags)
{
odp_packet_t pkts[OFP_PKT_RX_BURST_SIZE];
odp_packet_t odp_pkt;
int pkt_cnt = 0;
int pkt_idx = 0;
pkt_cnt = odp_pktin_recv(in_queue, pkts, OFP_PKT_RX_BURST_SIZE);
for (pkt_idx = 0; pkt_idx < pkt_cnt; pkt_idx++) {
odp_pkt = pkts[pkt_idx];
ofp_packet_input(odp_pkt, ODP_QUEUE_INVALID, ofp_eth_vlan_processing);
}
if (pkt_cnt < 1) ofp_send_pending_pkt();
static uint32_t count = 0;
/*odp_queue_deq has a lock that impacts performance*/
if (count ++ > 50) {
count = 0;
odp_queue_t timer_queue = ofp_timer_queue_cpu(-1);
odp_event_t event = odp_queue_deq(timer_queue);
if (event != ODP_EVENT_INVALID) {
if (odp_event_type(event) == ODP_EVENT_TIMEOUT) {
ofp_timer_handle(event);
} else {
odp_buffer_free(odp_buffer_from_event(event));
}
}
}
#if OFP_NOTIFY
return NGX_OK;
#endif
int ready, nready;
ngx_err_t err;
ngx_uint_t i, found;
ngx_event_t *ev;
ngx_queue_t *queue;
struct timeval tv, *tp;
ngx_connection_t *c;
if (max_fd == -1) {
for (i = 0; i < nevents; i++) {
c = event_index[i]->data;
ngx_log_debug(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"change max_fd: %i, c->fd : %d", max_fd, c->fd);
if (max_fd < c->fd) {
max_fd = c->fd;
}
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"change max_fd: %i", max_fd);
}
#if (NGX_DEBUG)
if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
for (i = 0; i < nevents; i++) {
ev = event_index[i];
c = ev->data;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select event: fd:%d wr:%d", c->fd, ev->write);
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"max_fd: %i", max_fd);
}
#endif
if (timer == NGX_TIMER_INFINITE) {
tp = NULL;
} else {
tv.tv_sec = (long) (timer / 1000);
tv.tv_usec = (long) ((timer % 1000) * 1000);
tp = &tv;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select timer: %M", timer);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select max_fd %d, tp %p ", max_fd, tp);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
" master %p : work %p", (ofp_fd_set *)&master_read_fd_set,
(ofp_fd_set *)&work_read_fd_set);
ready = select(max_fd + 1, &master_read_fd_set, &master_write_fd_set, NULL, tp);
err = (ready == -1) ? ngx_errno : 0;
if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
ngx_time_update();
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select ready %d", ready);
if (err) {
ngx_uint_t level;
if (err == NGX_EINTR) {
if (ngx_event_timer_alarm) {
ngx_event_timer_alarm = 0;
return NGX_OK;
}
level = NGX_LOG_INFO;
} else {
level = NGX_LOG_ALERT;
}
ngx_log_error(level, cycle->log, err, "select() failed");
if (err == NGX_EBADF) {
/*ngx_select_repair_fd_sets(cycle);*/
}
return NGX_ERROR;
}
if (ready == 0) {
return NGX_OK;
if (timer != NGX_TIMER_INFINITE) {
return NGX_OK;
}
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"select() returned no events without timeout");
return NGX_ERROR;
}
nready = 0;
for (i = 0; i < nevents; i++) {
ev = event_index[i];
c = ev->data;
found = 0;
if (ev->write) {
if (FD_ISSET(c->fd, &master_write_fd_set)) {
found = 1;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select write %d", c->fd);
}
} else {
if (FD_ISSET(c->fd, &master_read_fd_set)) {
found = 1;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select read %d", c->fd);
}
}
if (found) {
ev->ready = 1;
queue = ev->accept ? &ngx_posted_accept_events
: &ngx_posted_events;
ngx_post_event(ev, queue);
nready++;
}
}
if (ready != nready) {
/*ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"select ready != events: %d:%d", ready, nready);
ngx_select_repair_fd_sets(cycle);*/
}
return NGX_OK;
}
void *default_event_dispatcher(void *arg)
{
odp_event_t ev;
odp_packet_t pkt;
odp_queue_t in_queue;
odp_event_t events[OFP_EVT_RX_BURST_SIZE];
int event_idx = 0;
int event_cnt = 0;
ofp_pkt_processing_func pkt_func = (ofp_pkt_processing_func)arg;
odp_bool_t *is_running = NULL;
#if ODP_VERSION < 106
if (odp_init_local(ODP_THREAD_WORKER)) {
OFP_ERR("odp_init_local failed");
return NULL;
}
#endif
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return NULL;
}
is_running = ofp_get_processing_state();
if (is_running == NULL) {
OFP_ERR("ofp_get_processing_state failed");
ofp_term_local();
return NULL;
}
/* PER CORE DISPATCHER */
while (*is_running) {
event_cnt = odp_schedule_multi(&in_queue, ODP_SCHED_WAIT,
events, OFP_EVT_RX_BURST_SIZE);
for (event_idx = 0; event_idx < event_cnt; event_idx++) {
ev = events[event_idx];
if (ev == ODP_EVENT_INVALID)
continue;
if (odp_event_type(ev) == ODP_EVENT_TIMEOUT) {
ofp_timer_handle(ev);
continue;
}
if (odp_event_type(ev) == ODP_EVENT_PACKET) {
pkt = odp_packet_from_event(ev);
#if 0
if (odp_unlikely(odp_packet_has_error(pkt))) {
OFP_DBG("Dropping packet with error");
odp_packet_free(pkt);
continue;
}
#endif
ofp_packet_input(pkt, in_queue, pkt_func);
continue;
}
OFP_ERR("Unexpected event type: %u", odp_event_type(ev));
/* Free events by type */
if (odp_event_type(ev) == ODP_EVENT_BUFFER) {
odp_buffer_free(odp_buffer_from_event(ev));
continue;
}
if (odp_event_type(ev) == ODP_EVENT_CRYPTO_COMPL) {
odp_crypto_compl_free(
odp_crypto_compl_from_event(ev));
continue;
}
}
ofp_send_pending_pkt();
}
if (ofp_term_local())
OFP_ERR("ofp_term_local failed");
return NULL;
}
