void
app_init_mbuf_pools(void) {
unsigned socket, lcore;
/* Init the buffer pools */
for (socket = 0; socket < APP_MAX_SOCKETS; socket ++) {
char name[32];
if (app_is_socket_used(socket) == 0) {
continue;
}
snprintf(name, sizeof(name), "mbuf_pool_%u", socket);
lagopus_dprint("Creating the mbuf pool for socket %u ...\n", socket);
app.pools[socket] = rte_mempool_create(
name,
APP_DEFAULT_MEMPOOL_BUFFERS,
APP_DEFAULT_MBUF_SIZE,
APP_DEFAULT_MEMPOOL_CACHE_SIZE,
sizeof(struct rte_pktmbuf_pool_private),
rte_pktmbuf_pool_init, NULL,
rte_pktmbuf_init, NULL,
(int)socket,
0);
if (app.pools[socket] == NULL) {
rte_panic("Cannot create mbuf pool on socket %u\n", socket);
}
}
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
if (app.lcore_params[lcore].type == e_APP_LCORE_DISABLED) {
continue;
}
socket = rte_lcore_to_socket_id(lcore);
app.lcore_params[lcore].pool = app.pools[socket];
}
}
void
app_init_rings_tx(void) {
unsigned lcore;
/* Initialize the rings for the TX side */
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
struct app_lcore_params_worker *lp_worker = &app.lcore_params[lcore].worker;
unsigned port;
if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER &&
app.lcore_params[lcore].type != e_APP_LCORE_IO_WORKER) {
continue;
}
for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
char name[32];
struct app_lcore_params_io *lp_io = NULL;
struct rte_ring *ring;
uint32_t socket_io, lcore_io;
if (app.nic_tx_port_mask[port] == 0) {
continue;
}
if (app_get_lcore_for_nic_tx((uint8_t) port, &lcore_io) < 0) {
rte_panic("Algorithmic error (no I/O core to handle TX of port %u)\n",
port);
}
lp_io = &app.lcore_params[lcore_io].io;
socket_io = rte_lcore_to_socket_id(lcore_io);
lagopus_dprint("Creating ring to connect "
"worker lcore %u with "
"TX port %u (through I/O lcore %u)"
" (socket %u) ...\n",
lcore,
port,
(unsigned)lcore_io,
(unsigned)socket_io);
snprintf(name, sizeof(name),
"app_ring_tx_s%u_w%u_p%u",
socket_io, lcore, port);
ring = rte_ring_create(
name,
app.ring_tx_size,
(int)socket_io,
RING_F_SP_ENQ | RING_F_SC_DEQ);
if (ring == NULL) {
rte_panic("Cannot create ring to connect"
" worker core %u with TX port %u\n",
lcore,
port);
}
lp_worker->rings_out[port] = ring;
lp_io->tx.rings[port][lp_worker->worker_id] = ring;
}
}
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
struct app_lcore_params_io *lp_io = &app.lcore_params[lcore].io;
unsigned i;
if ((app.lcore_params[lcore].type != e_APP_LCORE_IO &&
app.lcore_params[lcore].type != e_APP_LCORE_IO_WORKER) ||
(lp_io->tx.n_nic_ports == 0)) {
continue;
}
for (i = 0; i < lp_io->tx.n_nic_ports; i ++) {
unsigned port, j;
port = lp_io->tx.nic_ports[i];
for (j = 0; j < app_get_lcores_worker(); j ++) {
if (lp_io->tx.rings[port][j] == NULL) {
rte_panic("Algorithmic error (I/O TX rings)\n");
}
}
}
}
}
void
app_init_rings_rx(void) {
unsigned lcore;
/* Initialize the rings for the RX side */
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
struct app_lcore_params_io *lp_io = &app.lcore_params[lcore].io;
unsigned socket_io, lcore_worker;
if ((app.lcore_params[lcore].type != e_APP_LCORE_IO &&
app.lcore_params[lcore].type != e_APP_LCORE_IO_WORKER) ||
(lp_io->rx.n_nic_queues == 0)) {
continue;
}
socket_io = rte_lcore_to_socket_id(lcore);
for (lcore_worker = 0; lcore_worker < APP_MAX_LCORES; lcore_worker ++) {
char name[32];
struct app_lcore_params_worker *lp_worker;
struct rte_ring *ring = NULL;
lp_worker = &app.lcore_params[lcore_worker].worker;
if (app.lcore_params[lcore_worker].type != e_APP_LCORE_WORKER &&
app.lcore_params[lcore_worker].type != e_APP_LCORE_IO_WORKER) {
continue;
}
lagopus_dprint(
"Creating ring to connect I/O "
"lcore %u (socket %u) with worker lcore %u ...\n",
lcore,
socket_io,
lcore_worker);
snprintf(name, sizeof(name),
"app_ring_rx_s%u_io%u_w%u",
socket_io,
lcore,
lcore_worker);
ring = rte_ring_create(
name,
app.ring_rx_size,
(int)socket_io,
RING_F_SP_ENQ | RING_F_SC_DEQ);
if (ring == NULL) {
rte_panic("Cannot create ring to connect I/O "
"core %u with worker core %u\n",
lcore,
lcore_worker);
}
lp_io->rx.rings[lp_io->rx.n_rings] = ring;
lp_io->rx.n_rings ++;
lp_worker->rings_in[lp_worker->n_rings_in] = ring;
lp_worker->n_rings_in ++;
}
}
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
struct app_lcore_params_io *lp_io = &app.lcore_params[lcore].io;
if ((app.lcore_params[lcore].type != e_APP_LCORE_IO &&
app.lcore_params[lcore].type != e_APP_LCORE_IO_WORKER) ||
(lp_io->rx.n_nic_queues == 0)) {
continue;
}
if (lp_io->rx.n_rings != app_get_lcores_worker()) {
rte_panic("Algorithmic error (I/O RX rings)\n");
}
}
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
struct app_lcore_params_worker *lp_worker;
lp_worker = &app.lcore_params[lcore].worker;
if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER &&
app.lcore_params[lcore].type != e_APP_LCORE_IO_WORKER) {
continue;
}
if (lp_worker->n_rings_in != app_get_lcores_io_rx()) {
rte_panic("Algorithmic error (worker input rings)\n");
}
}
}
int
main(int argc, const char *const argv[]) {
const char *nm = myname(argv[0]);
(void)argc;
lagopus_log_set_trace_flags(TRACE_OFPT_HELLO |
TRACE_OFPT_ERROR |
TRACE_OFPT_METER_MOD);
lagopus_msg("this should emitted to stderr.\n");
lagopus_msg_trace(TRACE_OFPT_HELLO, false, "hello test.\n");
lagopus_msg_trace(TRACE_OFPT_ERROR, false, "error test.\n");
lagopus_msg_trace(TRACE_OFPT_HELLO |
TRACE_OFPT_ERROR,
false, "hello|error test.\n");
/*
* log to stderr.
*/
if (IS_LAGOPUS_RESULT_OK(
lagopus_log_initialize(LAGOPUS_LOG_EMIT_TO_UNKNOWN, NULL,
false, true, 1)) == false) {
lagopus_msg_fatal("what's wrong??\n");
/* not reached. */
}
lagopus_dprint("debug to stderr.\n");
/*
* log to file.
*/
if (IS_LAGOPUS_RESULT_OK(
lagopus_log_initialize(LAGOPUS_LOG_EMIT_TO_FILE, "./testlog.txt",
false, true, 10)) == false) {
lagopus_msg_fatal("what's wrong??\n");
/* not reached. */
}
lagopus_dprint("debug to file.\n");
lagopus_msg_debug(5, "debug to file, again.\n");
lagopus_msg_trace(TRACE_OFPT_HELLO, false, "hello file test.\n");
lagopus_msg_trace(TRACE_OFPT_ERROR, false, "error file test.\n");
lagopus_msg_trace(TRACE_OFPT_HELLO |
TRACE_OFPT_ERROR,
false, "hello|error file test.\n");
if (IS_LAGOPUS_RESULT_OK(
lagopus_log_initialize(LAGOPUS_LOG_EMIT_TO_SYSLOG, nm,
false, false, 10)) == false) {
lagopus_msg_fatal("what's wrong??\n");
/* not reached. */
}
lagopus_msg_debug(5, "debug to syslog.\n");
lagopus_msg_trace(TRACE_OFPT_HELLO, false, "hello syslog test.\n");
lagopus_msg_trace(TRACE_OFPT_ERROR, false, "error syslog test.\n");
lagopus_msg_trace(TRACE_OFPT_HELLO |
TRACE_OFPT_ERROR,
false, "hello|error syslog test.\n");
/*
* log to stderr, again.
*/
if (IS_LAGOPUS_RESULT_OK(
lagopus_log_initialize(LAGOPUS_LOG_EMIT_TO_UNKNOWN, NULL,
false, true, 1)) == false) {
lagopus_msg_fatal("what's wrong??\n");
/* not reached. */
}
lagopus_dprint("will exit 1 ...\n");
lagopus_exit_error(1, "exit 1 on purpose.\n");
return 0;
}
