void
pktj_lpm_stats_display(struct cmdline *cl, int is_ipv4, int option)
{
struct lpm_stats_t *stats;
stats = is_ipv4 ? &lpm4_stats[RTE_PER_LCORE(g_socket_id)]
: &lpm6_stats[RTE_PER_LCORE(g_socket_id)];
if (option == CMD_LPM_STATS_JSON) {
cmdline_printf(cl, "{\"current\": %lu, \"add\": {\"success\": "
"%lu, \"failure\": %lu}, \"del\": "
"{\"success\": %lu, \"failure\": %lu}}\n",
(stats->nb_add_ok - stats->nb_del_ok),
stats->nb_add_ok, stats->nb_add_ko,
stats->nb_del_ok, stats->nb_del_ko);
} else {
cmdline_printf(
cl, "\nLPM statistics ====================================="
"\nCurrent routes: %lu"
"\nTotal routes added successfully: %lu"
"\nTotal route add failures: %lu"
"\nTotal routes deleted successfully: %lu"
"\nTotal route delete failures: %lu",
(stats->nb_add_ok - stats->nb_del_ok), stats->nb_add_ok,
stats->nb_add_ko, stats->nb_del_ok, stats->nb_del_ko);
cmdline_printf(
cl,
"\n====================================================\n");
}
}
/*
* Generates a log message The message will be sent in the stream
* defined by the previous call to rte_openlog_stream().
*/
int
rte_vlog(uint32_t level, uint32_t logtype, const char *format, va_list ap)
{
int ret;
FILE *f = rte_logs.file;
if (f == NULL) {
f = default_log_stream;
if (f == NULL) {
/*
* Grab the current value of stderr here, rather than
* just initializing default_log_stream to stderr. This
* ensures that we will always use the current value
* of stderr, even if the application closes and
* reopens it.
*/
f = stderr;
}
}
if (level > rte_logs.level)
return 0;
if (logtype >= rte_logs.dynamic_types_len)
return -1;
if (level > rte_logs.dynamic_types[logtype].loglevel)
return 0;
/* save loglevel and logtype in a global per-lcore variable */
RTE_PER_LCORE(log_cur_msg).loglevel = level;
RTE_PER_LCORE(log_cur_msg).logtype = logtype;
ret = vfprintf(f, format, ap);
fflush(f);
return ret;
}
int
rte_thread_set_affinity(rte_cpuset_t *cpusetp)
{
int s;
unsigned lcore_id;
pthread_t tid;
tid = pthread_self();
s = pthread_setaffinity_np(tid, sizeof(rte_cpuset_t), cpusetp);
if (s != 0) {
RTE_LOG(ERR, EAL, "pthread_setaffinity_np failed\n");
return -1;
}
/* store socket_id in TLS for quick access */
RTE_PER_LCORE(_socket_id) =
eal_cpuset_socket_id(cpusetp);
/* store cpuset in TLS for quick access */
memmove(&RTE_PER_LCORE(_cpuset), cpusetp,
sizeof(rte_cpuset_t));
lcore_id = rte_lcore_id();
if (lcore_id != (unsigned)LCORE_ID_ANY) {
/* EAL thread will update lcore_config */
lcore_config[lcore_id].socket_id = RTE_PER_LCORE(_socket_id);
memmove(&lcore_config[lcore_id].cpuset, cpusetp,
sizeof(rte_cpuset_t));
}
return 0;
}
/*****************************************************************************
* tlkp_add_ucb()
****************************************************************************/
int tlkp_add_ucb(udp_control_block_t *ucb)
{
int error;
if (ucb == NULL)
return -EINVAL;
TRACE_FMT(TLK, DEBUG,
"[%s()]: phys_port %u l4_hash %08X ladd/radd %08X/%08X lp/rp %u/%u",
__func__,
ucb->ucb_l4.l4cb_interface,
ucb->ucb_l4.l4cb_rx_hash,
ucb->ucb_l4.l4cb_dst_addr.ip_v4,
ucb->ucb_l4.l4cb_src_addr.ip_v4,
ucb->ucb_l4.l4cb_dst_port,
ucb->ucb_l4.l4cb_src_port);
error = tlkp_add_cb(RTE_PER_LCORE(tlkp_ucb_hash_table), &ucb->ucb_l4);
if (error)
return error;
/*
* If we have UCB trace filters enabled and the new UCB matches then
* update the ucb_trace flag.
*/
if (unlikely(RTE_PER_LCORE(trace_filter).tf_enabled)) {
if (ucb_trace_filter_match(&RTE_PER_LCORE(trace_filter), ucb))
ucb->ucb_trace = true;
}
return 0;
}
/*****************************************************************************
* mem_lcore_init()
****************************************************************************/
void mem_lcore_init(uint32_t lcore_id)
{
RTE_PER_LCORE(mbuf_pool) = mbuf_pool[lcore_id];
RTE_PER_LCORE(mbuf_pool_tx_hdr) = mbuf_pool_tx_hdr[lcore_id];
RTE_PER_LCORE(mbuf_pool_clone) = mbuf_pool_clone[lcore_id];
RTE_PER_LCORE(tcb_pool) = tcb_pool[lcore_id];
RTE_PER_LCORE(ucb_pool) = ucb_pool[lcore_id];
}
/*****************************************************************************
* trace_get_uniq_id()
****************************************************************************/
static uint32_t trace_get_uniq_id(void)
{
static RTE_DEFINE_PER_LCORE(uint32_t, trace_id);
/* Reserv 0 as invalid-id. */
RTE_PER_LCORE(trace_id)++;
if (unlikely(RTE_PER_LCORE(trace_id) == 0))
RTE_PER_LCORE(trace_id)++;
return RTE_PER_LCORE(trace_id);
}
void
rte_thread_get_affinity(rte_cpuset_t *cpusetp)
{
assert(cpusetp);
memmove(cpusetp, &RTE_PER_LCORE(_cpuset),
sizeof(rte_cpuset_t));
}
void
dpdk_set_lcore_id(unsigned cpu)
{
/* NON_PMD_CORE_ID is reserved for use by non pmd threads. */
ovs_assert(cpu != NON_PMD_CORE_ID);
RTE_PER_LCORE(_lcore_id) = cpu;
}
void eal_thread_init_master(unsigned lcore_id)
{
/* set the lcore ID in per-lcore memory area */
RTE_PER_LCORE(_lcore_id) = lcore_id;
/* set CPU affinity */
if (eal_thread_set_affinity() < 0)
rte_panic("cannot set affinity\n");
}
/*****************************************************************************
* tlkp_find_v4_ucb()
****************************************************************************/
udp_control_block_t *tlkp_find_v4_ucb(uint32_t phys_port, uint32_t l4_hash,
uint32_t local_addr, uint32_t remote_addr,
uint16_t local_port, uint16_t remote_port)
{
l4_control_block_t *l4_cb;
udp_control_block_t *ucb;
TRACE_FMT(TLK, DEBUG,
"[%s()]: phys_port %u l4_hash %08X ladd/radd %08X/%08X lp/rp %u/%u",
__func__,
phys_port,
l4_hash,
local_addr,
remote_addr,
local_port,
remote_port);
l4_cb = tlkp_find_v4_cb(RTE_PER_LCORE(tlkp_ucb_hash_table),
phys_port,
l4_hash,
local_addr,
remote_addr,
local_port,
remote_port);
if (unlikely(l4_cb == NULL))
return NULL;
ucb = container_of(l4_cb, udp_control_block_t, ucb_l4);
/*
* If we found a UCB and we have UCB trace filters enabled then
* check if we should update the ucb_trace flag.
*/
if (unlikely(RTE_PER_LCORE(trace_filter).tf_enabled)) {
if (ucb_trace_filter_match(&RTE_PER_LCORE(trace_filter), ucb))
ucb->ucb_trace = true;
else
ucb->ucb_trace = false;
} else if (unlikely(ucb->ucb_trace == true))
ucb->ucb_trace = false;
return ucb;
}
/*****************************************************************************
* tlkp_udp_lcore_init()
****************************************************************************/
void tlkp_udp_lcore_init(uint32_t lcore_id)
{
unsigned int i;
RTE_PER_LCORE(tlkp_ucb_hash_table) =
rte_zmalloc_socket("udp_hash_table", rte_eth_dev_count() *
TPG_HASH_BUCKET_SIZE *
sizeof(tlkp_hash_bucket_t),
RTE_CACHE_LINE_SIZE,
rte_lcore_to_socket_id(lcore_id));
if (RTE_PER_LCORE(tlkp_ucb_hash_table) == NULL) {
TPG_ERROR_ABORT("[%d]: Failed to allocate per lcore udp htable!\n",
rte_lcore_index(lcore_id));
}
for (i = 0; i < (rte_eth_dev_count() * TPG_HASH_BUCKET_SIZE); i++) {
/*
* Initialize all list headers.
*/
LIST_INIT((&RTE_PER_LCORE(tlkp_ucb_hash_table)[i]));
}
}
const char *
rte_strerror(int errnum)
{
#define RETVAL_SZ 256
static RTE_DEFINE_PER_LCORE(char[RETVAL_SZ], retval);
/* since some implementations of strerror_r throw an error
* themselves if errnum is too big, we handle that case here */
if (errnum > RTE_MAX_ERRNO)
rte_snprintf(RTE_PER_LCORE(retval), RETVAL_SZ,
#ifdef RTE_EXEC_ENV_BSDAPP
"Unknown error: %d", errnum);
#else
"Unknown error %d", errnum);
#endif
else
switch (errnum){
int
rte_assign_lcore_id (void)
{
int ret = -1;
unsigned lcore_id;
struct rte_config *config = rte_eal_get_configuration();
rte_spinlock_lock(&lcore_sl);
/* See whether this already has an lcore ID */
lcore_id = rte_lcore_id();
if (lcore_id == (unsigned)-1)
{
/* Find the first available LCORE with a CPU detection state that
* indicates OFF
*/
for (lcore_id = 0;
(lcore_id < RTE_MAX_LCORE) && (config->lcore_role[lcore_id] == ROLE_OFF);
++lcore_id);
/* if we found one, assign it */
if (lcore_id < RTE_MAX_LCORE)
{
config->lcore_role[lcore_id] = ROLE_RTE;
/* These are floating lcores - no core id or socket id */
lcore_config[lcore_id].core_id = LCORE_ID_ANY;
lcore_config[lcore_id].socket_id = SOCKET_ID_ANY;
lcore_config[lcore_id].f = NULL;
lcore_config[lcore_id].thread_id = pthread_self();
lcore_config[lcore_id].detected = 0; /* Core was not detected */
lcore_config[lcore_id].state = RUNNING;
config->lcore_count++;
ret = lcore_id;
RTE_PER_LCORE(_lcore_id) = lcore_id;
}
}
rte_spinlock_unlock(&lcore_sl);
return ret;
}
static int
dpaa_mbuf_free_bulk(struct rte_mempool *pool,
void *const *obj_table,
unsigned int n)
{
struct dpaa_bp_info *bp_info = DPAA_MEMPOOL_TO_POOL_INFO(pool);
int ret;
unsigned int i = 0;
DPAA_MEMPOOL_DPDEBUG("Request to free %d buffers in bpid = %d",
n, bp_info->bpid);
if (unlikely(!RTE_PER_LCORE(dpaa_io))) {
ret = rte_dpaa_portal_init((void *)0);
if (ret) {
DPAA_MEMPOOL_ERR("rte_dpaa_portal_init failed with ret: %d",
ret);
return 0;
}
}
while (i < n) {
uint64_t phy = rte_mempool_virt2iova(obj_table[i]);
if (unlikely(!bp_info->ptov_off)) {
/* buffers are from single mem segment */
if (bp_info->flags & DPAA_MPOOL_SINGLE_SEGMENT) {
bp_info->ptov_off
= (uint64_t)obj_table[i] - phy;
rte_dpaa_bpid_info[bp_info->bpid].ptov_off
= bp_info->ptov_off;
}
}
dpaa_buf_free(bp_info,
(uint64_t)phy + bp_info->meta_data_size);
i = i + 1;
}
DPAA_MEMPOOL_DPDEBUG("freed %d buffers in bpid =%d",
n, bp_info->bpid);
return 0;
}
const char *
rte_strerror(int errnum)
{
#define RETVAL_SZ 256
static RTE_DEFINE_PER_LCORE(char[RETVAL_SZ], retval);
/* since some implementations of strerror_r throw an error
* themselves if errnum is too big, we handle that case here */
if (errnum > RTE_MAX_ERRNO) {
snprintf(RTE_PER_LCORE(retval), RETVAL_SZ,
#if defined(RTE_EXEC_ENV_BSDAPP)
"Unknown error: %d", errnum);
#elif defined(RTE_EXEC_ENV_LINUXAPP)
"Unknown error %d", errnum);
#elif defined(RTE_EXEC_ENV_OSVAPP)
"No error information");
(void)errnum;
#endif
} else {
void
setUp(void) {
#ifdef HYBRID
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
datastore_interp_state_t state = DATASTORE_INTERP_STATE_AUTO_COMMIT;
char *str = NULL;
#ifdef HAVE_DPDK
RTE_PER_LCORE(_lcore_id) = 0;
#endif /* HAVE DPDK */
/* create interp. */
INTERP_CREATE(ret, NULL, interp, tbl, ds);
/* bridge create cmd. */
TEST_BRIDGE_CREATE(ret, &interp, state, &tbl, &ds, str,
"br0", "1", "cha1", "c1",
"test_if01", "test_port01", "1");
#else /* HYBRID */
TEST_IGNORE_MESSAGE("HYBRID is not defined.");
#endif /* HYBRID */
}
static void
dpdk_init__(const struct smap *ovs_other_config)
{
char **argv = NULL, **argv_to_release = NULL;
int result;
int argc, argc_tmp;
bool auto_determine = true;
int err = 0;
cpu_set_t cpuset;
char *sock_dir_subcomponent;
if (process_vhost_flags("vhost-sock-dir", xstrdup(ovs_rundir()),
NAME_MAX, ovs_other_config,
&sock_dir_subcomponent)) {
struct stat s;
if (!strstr(sock_dir_subcomponent, "..")) {
vhost_sock_dir = xasprintf("%s/%s", ovs_rundir(),
sock_dir_subcomponent);
err = stat(vhost_sock_dir, &s);
if (err) {
VLOG_ERR("vhost-user sock directory '%s' does not exist.",
vhost_sock_dir);
}
} else {
vhost_sock_dir = xstrdup(ovs_rundir());
VLOG_ERR("vhost-user sock directory request '%s/%s' has invalid"
"characters '..' - using %s instead.",
ovs_rundir(), sock_dir_subcomponent, ovs_rundir());
}
free(sock_dir_subcomponent);
} else {
vhost_sock_dir = sock_dir_subcomponent;
}
argv = grow_argv(&argv, 0, 1);
argc = 1;
argv[0] = xstrdup(ovs_get_program_name());
argc_tmp = get_dpdk_args(ovs_other_config, &argv, argc);
while (argc_tmp != argc) {
if (!strcmp("-c", argv[argc]) || !strcmp("-l", argv[argc])) {
auto_determine = false;
break;
}
argc++;
}
argc = argc_tmp;
/**
* NOTE: This is an unsophisticated mechanism for determining the DPDK
* lcore for the DPDK Master.
*/
if (auto_determine) {
int i;
/* Get the main thread affinity */
CPU_ZERO(&cpuset);
err = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t),
&cpuset);
if (!err) {
for (i = 0; i < CPU_SETSIZE; i++) {
if (CPU_ISSET(i, &cpuset)) {
argv = grow_argv(&argv, argc, 2);
argv[argc++] = xstrdup("-c");
argv[argc++] = xasprintf("0x%08llX", (1ULL<<i));
i = CPU_SETSIZE;
}
}
} else {
VLOG_ERR("Thread getaffinity error %d. Using core 0x1", err);
/* User did not set dpdk-lcore-mask and unable to get current
* thread affintity - default to core 0x1 */
argv = grow_argv(&argv, argc, 2);
argv[argc++] = xstrdup("-c");
argv[argc++] = xasprintf("0x%X", 1);
}
}
argv = grow_argv(&argv, argc, 1);
argv[argc] = NULL;
optind = 1;
if (VLOG_IS_INFO_ENABLED()) {
struct ds eal_args;
int opt;
ds_init(&eal_args);
ds_put_cstr(&eal_args, "EAL ARGS:");
for (opt = 0; opt < argc; ++opt) {
ds_put_cstr(&eal_args, " ");
ds_put_cstr(&eal_args, argv[opt]);
}
VLOG_INFO("%s", ds_cstr_ro(&eal_args));
ds_destroy(&eal_args);
}
argv_to_release = grow_argv(&argv_to_release, 0, argc);
for (argc_tmp = 0; argc_tmp < argc; ++argc_tmp) {
argv_to_release[argc_tmp] = argv[argc_tmp];
}
/* Make sure things are initialized ... */
result = rte_eal_init(argc, argv);
if (result < 0) {
ovs_abort(result, "Cannot init EAL");
}
argv_release(argv, argv_to_release, argc);
/* Set the main thread affinity back to pre rte_eal_init() value */
if (auto_determine && !err) {
err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t),
&cpuset);
if (err) {
VLOG_ERR("Thread setaffinity error %d", err);
}
}
rte_memzone_dump(stdout);
/* We are called from the main thread here */
RTE_PER_LCORE(_lcore_id) = NON_PMD_CORE_ID;
#ifdef DPDK_PDUMP
VLOG_INFO("DPDK pdump packet capture enabled");
err = rte_pdump_init(ovs_rundir());
if (err) {
VLOG_INFO("Error initialising DPDK pdump");
rte_pdump_uninit();
} else {
char *server_socket_path;
server_socket_path = xasprintf("%s/%s", ovs_rundir(),
"pdump_server_socket");
fatal_signal_add_file_to_unlink(server_socket_path);
free(server_socket_path);
}
#endif
/* Finally, register the dpdk classes */
netdev_dpdk_register();
}
void
pktj_stats_display(struct cmdline *cl, int option, int delay)
{
uint64_t total_packets_dropped, total_packets_tx, total_packets_rx;
uint64_t total_packets_kni_tx, total_packets_kni_rx,
total_packets_kni_dropped;
uint64_t total_packets_ratel_dropped, total_packets_acl_dropped;
unsigned lcoreid;
time_t _time;
const char *fmt_pre, *fmt_lcore, *fmt_mid, *fmt_total;
total_packets_dropped = 0;
total_packets_tx = 0;
total_packets_rx = 0;
total_packets_kni_tx = 0;
total_packets_kni_rx = 0;
total_packets_kni_dropped = 0;
total_packets_acl_dropped = 0;
total_packets_ratel_dropped = 0;
if (option == CMD_STATS_JSON) { // json
fmt_pre = STATS_JSON_PRE;
fmt_lcore = STATS_JSON_LCORE;
fmt_mid = STATS_JSON_MID;
fmt_total = STATS_JSON_TOTAL;
} else if (option == CMD_STATS_CSV) { // csv
fmt_pre = STATS_CSV_PRE;
fmt_lcore = STATS_CSV_LCORE;
fmt_mid = STATS_CSV_MID;
fmt_total = STATS_CSV_TOTAL;
} else {
fmt_pre = STATS_HUM_PRE;
fmt_lcore = STATS_HUM_LCORE;
fmt_mid = STATS_HUM_MID;
fmt_total = STATS_HUM_TOTAL;
}
_time = time(NULL);
for (lcoreid = 0; lcoreid < CMDLINE_MAX_CLIENTS; lcoreid++) {
if (cmdline_clients[RTE_PER_LCORE(g_socket_id)][lcoreid].cl ==
cl) {
cmdline_clients[RTE_PER_LCORE(g_socket_id)][lcoreid]
.csv_delay = delay;
cmdline_clients[RTE_PER_LCORE(g_socket_id)][lcoreid]
.delay_timer = _time;
break;
}
}
cmdline_printf(cl, "%s", fmt_pre);
for (lcoreid = 0; lcoreid < RTE_MAX_LCORE; lcoreid++) {
if (!rte_lcore_is_enabled(lcoreid))
continue;
cmdline_printf(
cl, fmt_lcore, _time, lcoreid, stats[lcoreid].port_id,
stats[lcoreid].nb_iteration_looped, stats[lcoreid].nb_tx,
stats[lcoreid].nb_rx, stats[lcoreid].nb_kni_tx,
stats[lcoreid].nb_kni_rx, stats[lcoreid].nb_dropped,
stats[lcoreid].nb_kni_dropped,
stats[lcoreid].nb_acl_dropped,
stats[lcoreid].nb_ratel_dropped);
total_packets_dropped += stats[lcoreid].nb_dropped;
total_packets_tx += stats[lcoreid].nb_tx;
total_packets_rx += stats[lcoreid].nb_rx;
total_packets_kni_tx += stats[lcoreid].nb_kni_tx;
total_packets_kni_rx += stats[lcoreid].nb_kni_rx;
total_packets_kni_dropped += stats[lcoreid].nb_kni_dropped;
total_packets_acl_dropped += stats[lcoreid].nb_acl_dropped;
total_packets_ratel_dropped += stats[lcoreid].nb_ratel_dropped;
}
// add a null object to end the array
cmdline_printf(cl, "%s", fmt_mid);
cmdline_printf(cl, fmt_total, total_packets_tx, total_packets_rx,
total_packets_kni_tx, total_packets_kni_rx,
total_packets_dropped, total_packets_kni_dropped,
total_packets_acl_dropped, total_packets_ratel_dropped);
}
/* get the current loglevel for the message being processed */
int rte_log_cur_msg_loglevel(void)
{
return RTE_PER_LCORE(log_cur_msg).loglevel;
}
unsigned rte_socket_id(void)
{
return RTE_PER_LCORE(_socket_id);
}
/* get the current logtype for the message being processed */
int rte_log_cur_msg_logtype(void)
{
return RTE_PER_LCORE(log_cur_msg).logtype;
}
/*****************************************************************************
* tlkp_walk_ucb()
****************************************************************************/
void tlkp_walk_ucb(uint32_t phys_port, tlkp_walk_v4_cb_t callback, void *arg)
{
tlkp_walk_v4(RTE_PER_LCORE(tlkp_ucb_hash_table), phys_port, callback, arg);
}
/*****************************************************************************
* tlkp_delete_ucb()
****************************************************************************/
int tlkp_delete_ucb(udp_control_block_t *ucb)
{
return tlkp_delete_cb(RTE_PER_LCORE(tlkp_ucb_hash_table), &ucb->ucb_l4);
}
static int
dpaa_mbuf_alloc_bulk(struct rte_mempool *pool,
void **obj_table,
unsigned int count)
{
struct rte_mbuf **m = (struct rte_mbuf **)obj_table;
struct bm_buffer bufs[DPAA_MBUF_MAX_ACQ_REL];
struct dpaa_bp_info *bp_info;
void *bufaddr;
int i, ret;
unsigned int n = 0;
bp_info = DPAA_MEMPOOL_TO_POOL_INFO(pool);
DPAA_MEMPOOL_DPDEBUG("Request to alloc %d buffers in bpid = %d",
count, bp_info->bpid);
if (unlikely(count >= (RTE_MEMPOOL_CACHE_MAX_SIZE * 2))) {
DPAA_MEMPOOL_ERR("Unable to allocate requested (%u) buffers",
count);
return -1;
}
if (unlikely(!RTE_PER_LCORE(dpaa_io))) {
ret = rte_dpaa_portal_init((void *)0);
if (ret) {
DPAA_MEMPOOL_ERR("rte_dpaa_portal_init failed with ret: %d",
ret);
return -1;
}
}
while (n < count) {
/* Acquire is all-or-nothing, so we drain in 7s,
* then the remainder.
*/
if ((count - n) > DPAA_MBUF_MAX_ACQ_REL) {
ret = bman_acquire(bp_info->bp, bufs,
DPAA_MBUF_MAX_ACQ_REL, 0);
} else {
ret = bman_acquire(bp_info->bp, bufs, count - n, 0);
}
/* In case of less than requested number of buffers available
* in pool, qbman_swp_acquire returns 0
*/
if (ret <= 0) {
DPAA_MEMPOOL_DPDEBUG("Buffer acquire failed (%d)",
ret);
/* The API expect the exact number of requested
* buffers. Releasing all buffers allocated
*/
dpaa_mbuf_free_bulk(pool, obj_table, n);
return -ENOBUFS;
}
/* assigning mbuf from the acquired objects */
for (i = 0; (i < ret) && bufs[i].addr; i++) {
/* TODO-errata - objerved that bufs may be null
* i.e. first buffer is valid, remaining 6 buffers
* may be null.
*/
bufaddr = DPAA_MEMPOOL_PTOV(bp_info, bufs[i].addr);
m[n] = (struct rte_mbuf *)((char *)bufaddr
- bp_info->meta_data_size);
DPAA_MEMPOOL_DPDEBUG("Paddr (%p), FD (%p) from BMAN",
(void *)bufaddr, (void *)m[n]);
n++;
}
}
DPAA_MEMPOOL_DPDEBUG("Allocated %d buffers from bpid=%d",
n, bp_info->bpid);
return 0;
}
/*
* Initialize PIOT Module
*/
int
rw_piot_init(int argc, char **argv, void *instance_ptr, f_rw_piot_log_t log_fn)
{
int rc, ret;
int i, no_huge = 0, memory_req = 0;
struct rte_config *cfg = rte_eal_get_configuration();
/*
* TBD - thread safety
*/
if (piot_initialized) {
int num_arg;
for (num_arg = 0; num_arg < argc; num_arg ++) {
if (strcmp(argv[num_arg], "--") == 0) {
break;
}
}
return num_arg;
}
piot_initialized = 1;
memset(&rw_piot_global_config, 0, sizeof(rw_piot_global_config));
ASSERT(instance_ptr);
rw_piot_global_config.instance_ptr = instance_ptr;
rw_piot_global_config.log_fn = log_fn;
memset(&(rw_piot_lcore[0]), 0, sizeof(rw_piot_lcore));
for (i=0; i<argc; i++) {
if (strcmp("--no-huge", argv[i]) == 0) {
no_huge = 1;
RW_PIOT_LOG(RTE_LOG_INFO, "PIOT: Huge pages disabled by --no-huge cmdarg\n");
}
if (strcmp("-m", argv[i]) == 0) {
if ((i+1) <argc) {
memory_req = atoi(argv[i+1]);
RW_PIOT_LOG(RTE_LOG_INFO, "PIOT: -m cmdarg setting requested memory to %d mb\n", memory_req);
}
}
if (strcmp("--", argv[i]) == 0) {
break;
}
}
/*
* setup system environment for DPDK
*/
rc = dpdk_system_setup(no_huge, memory_req);
if (rc < 0) {
return rc;
}
rte_set_application_log_hook(rw_piot_log_handler);
/*
* Init DPDK EAL without doing thread related inits
*/
ret = rte_eal_init_no_thread(argc, argv);
if (ret < 0) {
return ret;
}
if (geteuid() == 0){
rte_kni_init(RWPIOT_MAX_KNI_DEVICES);
}
/*
* Assign master lcore-id. Should be passed in the init - TBD
*/
cfg->master_lcore = 0; /* This wil be fixed with RW.Sched integration - TBD */
/* set the lcore ID in per-lcore memory area */
RTE_PER_LCORE(_lcore_id) = cfg->master_lcore;
/* set CPU affinity for master thread ??? TBD*/
// if (eal_thread_set_affinity() < 0)
// rte_panic("cannot set affinity\n");
rte_timer_subsystem_init();
return ret; /* number of args consumed by rte_eal_init_no_thread */
}
