uma_zone_t ofp_uma_pool_create(const char *name, int nitems, int size)
{
odp_pool_param_t pool_params;
odp_pool_t pool;
uma_zone_t zone;
pool_params.buf.size = size + sizeof(struct uma_pool_metadata);
pool_params.buf.align = 0;
pool_params.buf.num = nitems;
pool_params.type = ODP_POOL_BUFFER;
OFP_INFO("Creating pool '%s', nitems=%d size=%d total=%d",
name, pool_params.buf.num, pool_params.buf.size,
pool_params.buf.num * pool_params.buf.size);
if (shm->num_pools >= OFP_NUM_UMA_POOLS) {
OFP_ERR("Exceeded max number (%d) of pools",
OFP_NUM_UMA_POOLS);
return OFP_UMA_ZONE_INVALID;
}
pool = ofp_pool_create(name, &pool_params);
if (pool == ODP_POOL_INVALID) {
OFP_ERR("odp_pool_create failed");
return OFP_UMA_ZONE_INVALID;
}
zone = shm->num_pools++;
shm->pools[zone] = pool;
return zone;
}
int ofp_init_pre_global(const char *pool_name_unused,
odp_pool_param_t *pool_params_unused,
ofp_pkt_hook hooks[], odp_pool_t *pool_unused,
int arp_age_interval, int arp_entry_timeout)
{
(void)pool_name_unused;
(void)pool_params_unused;
(void)pool_unused;
/* Init shared memories */
HANDLE_ERROR(ofp_global_config_alloc_shared_memory());
memset(shm, 0, sizeof(*shm));
shm->is_running = 1;
#ifdef SP
shm->nl_thread_is_running = 0;
#endif /* SP */
shm->cli_thread_is_running = 0;
ofp_register_sysctls();
HANDLE_ERROR(ofp_avl_init_global());
HANDLE_ERROR(ofp_reassembly_init_global());
HANDLE_ERROR(ofp_pcap_init_global());
HANDLE_ERROR(ofp_stat_init_global());
HANDLE_ERROR(ofp_timer_init_global(OFP_TIMER_RESOLUTION_US,
OFP_TIMER_MIN_US,
OFP_TIMER_MAX_US,
OFP_TIMER_TMO_COUNT));
HANDLE_ERROR(ofp_hook_init_global(hooks));
HANDLE_ERROR(ofp_arp_init_global(arp_age_interval, arp_entry_timeout));
HANDLE_ERROR(ofp_route_init_global());
HANDLE_ERROR(ofp_portconf_init_global());
HANDLE_ERROR(ofp_vxlan_init_global());
odp_pool_param_t pool_params;
/* Define pkt.seg_len so that l2/l3/l4 offset fits in first segment */
pool_params.pkt.seg_len = SHM_PKT_POOL_BUFFER_SIZE;
pool_params.pkt.len = SHM_PKT_POOL_BUFFER_SIZE;
pool_params.pkt.num = SHM_PKT_POOL_SIZE / SHM_PKT_POOL_BUFFER_SIZE;
#if ODP_VERSION > 100
pool_params.pkt.uarea_size = SHM_PKT_POOL_USER_AREA_SIZE;
#endif /* ODP_VERSION > 100 */
pool_params.type = ODP_POOL_PACKET;
ofp_packet_pool = ofp_pool_create(SHM_PACKET_POOL_NAME, &pool_params);
if (ofp_packet_pool == ODP_POOL_INVALID) {
OFP_ERR("odp_pool_create failed");
return -1;
}
HANDLE_ERROR(ofp_socket_init_global(ofp_packet_pool));
HANDLE_ERROR(ofp_inet_init());
return 0;
}
int ofp_timer_init_global(int resolution_us,
int min_us, int max_us,
int tmo_count)
{
odp_queue_param_t param;
odp_pool_param_t pool_params;
odp_timer_pool_param_t timer_params;
/* For later tuning. */
(void)tmo_count;
HANDLE_ERROR(ofp_timer_alloc_shared_memory());
ofp_timer_shm_init();
/* Timout pool */
memset(&pool_params, 0, sizeof(pool_params));
pool_params.tmo.num = TIMER_NUM_TIMERS;
pool_params.type = ODP_POOL_TIMEOUT;
shm->pool = ofp_pool_create("TimeoutPool", &pool_params);
if (shm->pool == ODP_POOL_INVALID) {
OFP_ERR("odp_pool_create failed");
return -1;
}
/* Buffer pool */
memset(&pool_params, 0, sizeof(pool_params));
pool_params.buf.size = sizeof(struct ofp_timer_internal);
pool_params.buf.align = 0;
pool_params.buf.num = TIMER_NUM_TIMERS;
pool_params.type = ODP_POOL_BUFFER;
shm->buf_pool = ofp_pool_create("TimeoutBufferPool", &pool_params);
if (shm->buf_pool == ODP_POOL_INVALID) {
OFP_ERR("odp_pool_create failed");
return -1;
}
/* Timer pool */
memset(&timer_params, 0, sizeof(timer_params));
timer_params.res_ns = resolution_us*ODP_TIME_USEC_IN_NS;
timer_params.min_tmo = min_us*ODP_TIME_USEC_IN_NS;
timer_params.max_tmo = max_us*ODP_TIME_USEC_IN_NS;
timer_params.num_timers = TIMER_NUM_TIMERS;
timer_params.priv = 0; /* Shared */
timer_params.clk_src = ODP_CLOCK_CPU;
shm->socket_timer_pool = odp_timer_pool_create("TmrPool",
&timer_params);
if (shm->socket_timer_pool == ODP_TIMER_POOL_INVALID) {
OFP_ERR("odp_timer_pool_create");
return -1;
}
odp_timer_pool_start();
/*
* Create a queue
*/
odp_queue_param_init(¶m);
param.type = ODP_QUEUE_TYPE_SCHED;
param.sched.prio = ODP_SCHED_PRIO_DEFAULT;
param.sched.sync = ODP_SCHED_SYNC_PARALLEL;
param.sched.group = ODP_SCHED_GROUP_ALL;
shm->queue = odp_queue_create("TimerQueue", ¶m);
if (shm->queue == ODP_QUEUE_INVALID) {
OFP_ERR("odp_queue_create failed");
return -1;
}
odp_spinlock_init(&shm->lock);
/* Start one second timeouts */
shm->timer_1s = ofp_timer_start(1000000UL, one_sec, NULL, 0);
return 0;
}
