int
main(int argc, char **argv)
{
struct cmdline *cl;
int ret;
ret = rte_eal_init(argc, argv);
if (ret < 0)
return -1;
rte_timer_subsystem_init();
argc -= ret;
argv += ret;
prgname = argv[0];
#ifndef RTE_EXEC_ENV_BAREMETAL
if ((recursive_call = getenv(RECURSIVE_ENV_VAR)) != NULL)
return do_recursive_call();
#endif
cl = cmdline_stdin_new(main_ctx, "RTE>>");
if (cl == NULL) {
return -1;
}
cmdline_interact(cl);
cmdline_stdin_exit(cl);
return 0;
}
void tw_init_timer_vals(void)
{
one_sec = rte_get_timer_hz();
one_msec = (one_sec / 1000UL);
one_usec = (one_msec / 1000UL);
one_nsec = (one_usec / 1000UL);
#ifdef USE_PERIODIC_TIMERS
rte_timer_subsystem_init();
#endif
}
int
main(int argc, char **argv)
{
#ifdef RTE_LIBRTE_CMDLINE
struct cmdline *cl;
#endif
int ret;
ret = rte_eal_init(argc, argv);
if (ret < 0)
return -1;
#ifdef RTE_LIBRTE_TIMER
rte_timer_subsystem_init();
#endif
if (commands_init() < 0)
return -1;
argv += ret;
prgname = argv[0];
#ifndef RTE_EXEC_ENV_BAREMETAL
if ((recursive_call = getenv(RECURSIVE_ENV_VAR)) != NULL)
return do_recursive_call();
#endif
#ifdef RTE_LIBEAL_USE_HPET
if (rte_eal_hpet_init(1) < 0)
#endif
RTE_LOG(INFO, APP,
"HPET is not enabled, using TSC as default timer\n");
#ifdef RTE_LIBRTE_CMDLINE
cl = cmdline_stdin_new(main_ctx, "RTE>>");
if (cl == NULL) {
return -1;
}
cmdline_interact(cl);
cmdline_stdin_exit(cl);
#endif
return 0;
}
/**********************************************************************
*@description:
*
*
*@parameters:
* [in]:
* [in]:
*
*@return values:
*
**********************************************************************/
static void odp_init_timer()
{
/* init RTE timer library */
rte_timer_subsystem_init();
return;
}
/*
* 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 */
}
static int
paxos_rx_process(struct rte_mbuf *pkt, struct proposer* proposer)
{
int ret = 0;
uint8_t l4_proto = 0;
uint16_t outer_header_len;
union tunnel_offload_info info = { .data = 0 };
struct udp_hdr *udp_hdr;
struct paxos_hdr *paxos_hdr;
struct ether_hdr *phdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
parse_ethernet(phdr, &info, &l4_proto);
if (l4_proto != IPPROTO_UDP)
return -1;
udp_hdr = (struct udp_hdr *)((char *)phdr +
info.outer_l2_len + info.outer_l3_len);
/* if UDP dst port is not either PROPOSER or LEARNER port */
if (!(udp_hdr->dst_port == rte_cpu_to_be_16(PROPOSER_PORT) ||
udp_hdr->dst_port == rte_cpu_to_be_16(LEARNER_PORT)) &&
(pkt->packet_type & RTE_PTYPE_TUNNEL_MASK) == 0)
return -1;
paxos_hdr = (struct paxos_hdr *)((char *)udp_hdr + sizeof(struct udp_hdr));
if (rte_get_log_level() == RTE_LOG_DEBUG) {
//rte_hexdump(stdout, "udp", udp_hdr, sizeof(struct udp_hdr));
//rte_hexdump(stdout, "paxos", paxos_hdr, sizeof(struct paxos_hdr));
print_paxos_hdr(paxos_hdr);
}
int value_len = rte_be_to_cpu_16(paxos_hdr->value_len);
struct paxos_value *v = paxos_value_new((char *)paxos_hdr->paxosval, value_len);
switch(rte_be_to_cpu_16(paxos_hdr->msgtype)) {
case PAXOS_PROMISE: {
struct paxos_promise promise = {
.iid = rte_be_to_cpu_32(paxos_hdr->inst),
.ballot = rte_be_to_cpu_16(paxos_hdr->rnd),
.value_ballot = rte_be_to_cpu_16(paxos_hdr->vrnd),
.aid = rte_be_to_cpu_16(paxos_hdr->acptid),
.value = *v
};
proposer_handle_promise(proposer, &promise);
break;
}
case PAXOS_ACCEPT: {
if (first_time) {
proposer_preexecute(proposer);
first_time = false;
}
struct paxos_accept acpt = {
.iid = rte_be_to_cpu_32(paxos_hdr->inst),
.ballot = rte_be_to_cpu_16(paxos_hdr->rnd),
.value_ballot = rte_be_to_cpu_16(paxos_hdr->vrnd),
.aid = rte_be_to_cpu_16(paxos_hdr->acptid),
.value = *v
};
proposer_handle_accept(proposer, &acpt);
break;
}
case PAXOS_ACCEPTED: {
struct paxos_accepted ack = {
.iid = rte_be_to_cpu_32(paxos_hdr->inst),
.ballot = rte_be_to_cpu_16(paxos_hdr->rnd),
.value_ballot = rte_be_to_cpu_16(paxos_hdr->vrnd),
.aid = rte_be_to_cpu_16(paxos_hdr->acptid),
.value = *v
};
proposer_handle_accepted(proposer, &ack);
break;
}
default:
break;
}
outer_header_len = info.outer_l2_len + info.outer_l3_len
+ sizeof(struct udp_hdr) + sizeof(struct paxos_hdr);
rte_pktmbuf_adj(pkt, outer_header_len);
return ret;
}
static uint16_t
add_timestamps(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
struct rte_mbuf **pkts, uint16_t nb_pkts,
uint16_t max_pkts __rte_unused, void *user_param)
{
struct proposer* proposer = (struct proposer *)user_param;
unsigned i;
uint64_t now = rte_rdtsc();
for (i = 0; i < nb_pkts; i++) {
pkts[i]->udata64 = now;
paxos_rx_process(pkts[i], proposer);
}
return nb_pkts;
}
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool, struct proposer* proposer)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_txconf *txconf;
struct rte_eth_rxconf *rxconf;
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 1, tx_rings = 1;
int retval;
uint16_t q;
rte_eth_dev_info_get(port, &dev_info);
rxconf = &dev_info.default_rxconf;
txconf = &dev_info.default_txconf;
txconf->txq_flags &= PKT_TX_IPV4;
txconf->txq_flags &= PKT_TX_UDP_CKSUM;
if (port >= rte_eth_dev_count())
return -1;
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
rte_eth_dev_socket_id(port), rxconf, mbuf_pool);
if (retval < 0)
return retval;
}
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
rte_eth_dev_socket_id(port), txconf);
if (retval < 0)
return retval;
}
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
struct ether_addr addr;
rte_eth_macaddr_get(port, &addr);
rte_eth_promiscuous_enable(port);
rte_eth_add_rx_callback(port, 0, add_timestamps, proposer);
rte_eth_add_tx_callback(port, 0, calc_latency, NULL);
return 0;
}
static void
lcore_main(uint8_t port, __rte_unused struct proposer *p)
{
proposer_preexecute(p);
for (;;) {
// Check if signal is received
if (force_quit)
break;
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
uint16_t buf;
for (buf = 0; buf < nb_rx; buf++)
rte_pktmbuf_free(bufs[buf]);
}
}
static __attribute__((noreturn)) int
lcore_mainloop(__attribute__((unused)) void *arg)
{
uint64_t prev_tsc = 0, cur_tsc, diff_tsc;
unsigned lcore_id;
lcore_id = rte_lcore_id();
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_TIMER,
"Starting mainloop on core %u\n", lcore_id);
while(1) {
cur_tsc = rte_rdtsc();
diff_tsc = cur_tsc - prev_tsc;
if (diff_tsc > TIMER_RESOLUTION_CYCLES) {
rte_timer_manage();
prev_tsc = cur_tsc;
}
}
}
static void
report_stat(struct rte_timer *tim, __attribute((unused)) void *arg)
{
/* print stat */
uint32_t count = rte_atomic32_read(&stat);
rte_log(RTE_LOG_INFO, RTE_LOGTYPE_USER8,
"Throughput = %8u msg/s\n", count);
/* reset stat */
rte_atomic32_set(&stat, 0);
/* this timer is automatically reloaded until we decide to stop it */
if (force_quit)
rte_timer_stop(tim);
}
static void
check_timeout(struct rte_timer *tim, void *arg)
{
struct proposer* p = (struct proposer *) arg;
unsigned lcore_id = rte_lcore_id();
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8, "%s() on lcore_id %i\n", __func__, lcore_id);
struct paxos_message out;
out.type = PAXOS_PREPARE;
struct timeout_iterator* iter = proposer_timeout_iterator(p);
while(timeout_iterator_prepare(iter, &out.u.prepare)) {
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8,
"%s Send PREPARE inst %d ballot %d\n",
__func__, out.u.prepare.iid, out.u.prepare.ballot);
send_paxos_message(&out);
}
out.type = PAXOS_ACCEPT;
while(timeout_iterator_accept(iter, &out.u.accept)) {
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8,
"%s: Send ACCEPT inst %d ballot %d\n",
__func__, out.u.prepare.iid, out.u.prepare.ballot);
send_paxos_message(&out);
}
timeout_iterator_free(iter);
/* this timer is automatically reloaded until we decide to stop it */
if (force_quit)
rte_timer_stop(tim);
}
int
main(int argc, char *argv[])
{
uint8_t portid = 0;
unsigned master_core, lcore_id;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
force_quit = false;
int proposer_id = 0;
if (rte_get_log_level() == RTE_LOG_DEBUG) {
paxos_config.verbosity = PAXOS_LOG_DEBUG;
}
struct proposer *proposer = proposer_new(proposer_id, NUM_ACCEPTORS);
first_time = true;
/* init EAL */
int ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
/* init timer structure */
rte_timer_init(&timer);
rte_timer_init(&stat_timer);
/* load deliver_timer, every 1 s, on a slave lcore, reloaded automatically */
uint64_t hz = rte_get_timer_hz();
/* Call rte_timer_manage every 10ms */
TIMER_RESOLUTION_CYCLES = hz / 100;
rte_log(RTE_LOG_INFO, RTE_LOGTYPE_USER1, "Clock: %"PRIu64"\n", hz);
/* master core */
master_core = rte_lcore_id();
/* slave core */
lcore_id = rte_get_next_lcore(master_core, 0, 1);
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER1, "lcore_id: %d\n", lcore_id);
rte_timer_reset(&timer, hz, PERIODICAL, lcore_id, check_timeout, proposer);
/* reset timer */
rte_eal_remote_launch(lcore_mainloop, NULL, lcore_id);
/* stat core */
lcore_id = rte_get_next_lcore(lcore_id , 0, 1);
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER1, "lcore_id: %d\n", lcore_id);
rte_timer_reset(&stat_timer, hz, PERIODICAL, lcore_id,
report_stat, NULL);
/* init RTE timer library */
rte_timer_subsystem_init();
mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
NUM_MBUFS, MBUF_CACHE_SIZE, 0,
RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (mbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot create mbuf_pool\n");
/* reset timer */
rte_eal_remote_launch(lcore_mainloop, NULL, lcore_id);
if (port_init(portid, mbuf_pool, proposer) != 0)
rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8"\n", portid);
lcore_main(portid, proposer);
rte_log(RTE_LOG_DEBUG, RTE_LOGTYPE_USER8, "Free proposer\n");
proposer_free(proposer);
return 0;
}
/*****************************************************************************
* main()
****************************************************************************/
int main(int argc, char **argv)
{
global_config_t *cfg;
int ret;
/*
* Initialize DPDK infrastructure before we do anything else
*/
ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_panic("Cannot init EAL\n");
/*
* Initialize RTE timer library
*/
rte_timer_subsystem_init();
/*
* Precalculate the number of cycles per us so we don't do it everytime.
*/
cycles_per_us = (rte_get_timer_hz() / 1000000);
/*
* Return value above to be used to scan app specific options
*/
argc -= ret;
argv += ret;
/*
* General checks
*/
if (rte_lcore_count() < 3)
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s\n",
"WARP17 needs at least three cores!");
/* We only support at most 64 cores right now (to make parsing easier). */
if (rte_lcore_count() > (sizeof(uint64_t) * 8))
TPG_ERROR_EXIT(EXIT_FAILURE,
"ERROR: WARP17 supports at most %"PRIu32" cores!\n",
(uint32_t)sizeof(uint64_t) * 8);
if (rte_eth_dev_count() > TPG_ETH_DEV_MAX)
TPG_ERROR_EXIT(EXIT_FAILURE,
"ERROR: WARP17 works with at most %u ports!\n",
TPG_ETH_DEV_MAX);
/*
* Initialize various submodules
*/
if (!cli_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the command line interface");
if (!rpc_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the RPC server");
if (!cfg_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s\n",
"Failed initializing default configuration!\n");
if (!cfg_handle_command_line(argc, argv))
exit(EXIT_FAILURE); /* Error reporting is handled by the function itself */
if (!trace_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the tracing module");
if (!trace_filter_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the trace filter module");
if (!mem_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed allocating required mbufs");
/* WARNING: Careful when adding code above this point. Up until ports are
* initialized DPDK can't know that there might be ring interfaces that
* still need to be created. Therefore any call to rte_eth_dev_count()
* doesn't include them.
*/
if (!port_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the Ethernets ports");
if (!msg_sys_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the message queues");
if (!test_mgmt_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing test mgmt");
if (!test_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing tests");
if (!eth_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the Ethernets pkt handler");
if (!arp_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the ARP pkt handler");
if (!route_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the ROUTE module");
if (!ipv4_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the IPv4 pkt handler");
if (!tcp_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the TCP pkt handler");
if (!udp_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the UDP pkt handler");
if (!tlkp_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the Session lookup engine");
if (!tlkp_tcp_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the TCP lookup engine");
if (!tlkp_udp_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the UDP lookup engine");
if (!tsm_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the TSM module");
if (!timer_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the TCP timers module");
if (!pkt_loop_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the pkt loop");
if (!raw_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the RAW Application module");
if (!http_init())
TPG_ERROR_EXIT(EXIT_FAILURE, "ERROR: %s!\n",
"Failed initializing the RAW Application module");
start_cores();
/*
* Process startup command file, if any.
*/
cfg = cfg_get_config();
if (cfg != NULL && cfg->gcfg_cmd_file) {
if (!cli_run_input_file(cfg->gcfg_cmd_file))
TPG_ERROR_EXIT(EXIT_FAILURE, "Failed to run command file: %s!\n",
cfg->gcfg_cmd_file);
}
/*
* Process CLI commands, and other house keeping tasks...
*/
cli_interact();
tpg_exit = true;
/*
* Exit!!!
*/
rte_eal_mp_wait_lcore();
/*
* Destroy the CLI.
*/
cli_exit();
/*
* Destroy the mgmt RPC server.
*/
rpc_destroy();
return 0;
}
