static struct rte_mempool *
pktgen_mbuf_pool_create(const char * type, uint8_t pid, uint8_t queue_id,
uint32_t nb_mbufs, int socket_id, int cache_size )
{
struct rte_mempool * mp;
char name[RTE_MEMZONE_NAMESIZE];
snprintf(name, sizeof(name), "%-12s%u:%u", type, pid, queue_id);
pktgen_log_info(" Create: %-*s - Memory used (MBUFs %4u x (size %u + Hdr %lu)) + %lu = %6lu KB",
16, name, nb_mbufs, MBUF_SIZE, sizeof(struct rte_mbuf), sizeof(struct rte_mempool),
(((nb_mbufs * (MBUF_SIZE + sizeof(struct rte_mbuf)) + sizeof(struct rte_mempool))) + 1023)/1024);
pktgen.mem_used += ((nb_mbufs * (MBUF_SIZE + sizeof(struct rte_mbuf)) + sizeof(struct rte_mempool)));
pktgen.total_mem_used += ((nb_mbufs * (MBUF_SIZE + sizeof(struct rte_mbuf)) + sizeof(struct rte_mempool)));
/* create the mbuf pool */
mp = rte_mempool_create(name, nb_mbufs, MBUF_SIZE, cache_size,
sizeof(struct rte_pktmbuf_pool_private),
rte_pktmbuf_pool_init, NULL,
rte_pktmbuf_init, NULL,
socket_id, MEMPOOL_F_DMA);
if (mp == NULL)
pktgen_log_panic("Cannot create mbuf pool (%s) port %d, queue %d, nb_mbufs %d, socket_id %d: %s",
name, pid, queue_id, nb_mbufs, socket_id, rte_strerror(errno));
return mp;
}
void pktgen_config_ports(void)
{
uint32_t lid, pid, i, s, q, sid;
rxtx_t rt;
pkt_seq_t * pkt;
port_info_t * info;
char buff[RTE_MEMZONE_NAMESIZE];
int32_t ret, cache_size;
char output_buff[256] = { 0 };
// Find out the total number of ports in the system.
// We have already blacklisted the ones we needed to in main routine.
pktgen.nb_ports = rte_eth_dev_count();
if (pktgen.nb_ports > RTE_MAX_ETHPORTS)
pktgen.nb_ports = RTE_MAX_ETHPORTS;
if ( pktgen.nb_ports == 0 )
pktgen_log_panic("*** Did not find any ports to use ***");
pktgen.starting_port = 0;
// Setup the number of ports to display at a time
if ( pktgen.nb_ports > pktgen.nb_ports_per_page )
pktgen.ending_port = pktgen.starting_port + pktgen.nb_ports_per_page;
else
pktgen.ending_port = pktgen.starting_port + pktgen.nb_ports;
wr_port_matrix_dump(pktgen.l2p);
pktgen_log_info("Configuring %d ports, MBUF Size %d, MBUF Cache Size %d",
pktgen.nb_ports, MBUF_SIZE, MBUF_CACHE_SIZE);
// For each lcore setup each port that is handled by that lcore.
for(lid = 0; lid < RTE_MAX_LCORE; lid++) {
if ( wr_get_map(pktgen.l2p, RTE_MAX_ETHPORTS, lid) == 0 )
continue;
// For each port attached or handled by the lcore
for(pid = 0; pid < pktgen.nb_ports; pid++) {
// If non-zero then this port is handled by this lcore.
if ( wr_get_map(pktgen.l2p, pid, lid) == 0 )
continue;
wr_set_port_private(pktgen.l2p, pid, &pktgen.info[pid]);
pktgen.info[pid].pid = pid;
}
}
wr_dump_l2p(pktgen.l2p);
pktgen.total_mem_used = 0;
for(pid = 0; pid < pktgen.nb_ports; pid++) {
// Skip if we do not have any lcores attached to a port.
if ( (rt.rxtx = wr_get_map(pktgen.l2p, pid, RTE_MAX_LCORE)) == 0 )
continue;
pktgen.port_cnt++;
snprintf(output_buff, sizeof(output_buff),
"Initialize Port %d -- TxQ %d, RxQ %d", pid, rt.tx, rt.rx);
info = wr_get_port_private(pktgen.l2p, pid);
// Create the pkt header structures for transmitting sequence of packets.
snprintf(buff, sizeof(buff), "seq_hdr_%d", pid);
info->seq_pkt = (pkt_seq_t *)rte_zmalloc(buff, (sizeof(pkt_seq_t) * NUM_TOTAL_PKTS), RTE_CACHE_LINE_SIZE);
if ( info->seq_pkt == NULL )
pktgen_log_panic("Unable to allocate %d pkt_seq_t headers", NUM_TOTAL_PKTS);
info->seqIdx = 0;
info->seqCnt = 0;
info->nb_mbufs = MAX_MBUFS_PER_PORT;
cache_size = (info->nb_mbufs > RTE_MEMPOOL_CACHE_MAX_SIZE)?
RTE_MEMPOOL_CACHE_MAX_SIZE : info->nb_mbufs;
pktgen_port_conf_setup(pid, &rt, &default_port_conf);
if ( (ret = rte_eth_dev_configure(pid, rt.rx, rt.tx, &info->port_conf)) < 0)
pktgen_log_panic("Cannot configure device: port=%d, Num queues %d,%d (%d)%s",
pid, rt.rx, rt.tx, errno, rte_strerror(-ret));
pkt = &info->seq_pkt[SINGLE_PKT];
// Grab the source MAC addresses */
rte_eth_macaddr_get(pid, &pkt->eth_src_addr);
pktgen_log_info("%s, Src MAC %02x:%02x:%02x:%02x:%02x:%02x", output_buff,
pkt->eth_src_addr.addr_bytes[0],
pkt->eth_src_addr.addr_bytes[1],
pkt->eth_src_addr.addr_bytes[2],
pkt->eth_src_addr.addr_bytes[3],
pkt->eth_src_addr.addr_bytes[4],
pkt->eth_src_addr.addr_bytes[5]);
// Copy the first Src MAC address in SINGLE_PKT to the rest of the sequence packets.
for (i = 0; i < NUM_SEQ_PKTS; i++)
ethAddrCopy( &info->seq_pkt[i].eth_src_addr, &pkt->eth_src_addr );
pktgen.mem_used = 0;
for(q = 0; q < rt.rx; q++) {
// grab the socket id value based on the lcore being used.
sid = rte_lcore_to_socket_id(wr_get_port_lid(pktgen.l2p, pid, q));
// Create and initialize the default Receive buffers.
info->q[q].rx_mp = pktgen_mbuf_pool_create("Default RX", pid, q, info->nb_mbufs, sid, cache_size);
if ( info->q[q].rx_mp == NULL )
pktgen_log_panic("Cannot init port %d for Default RX mbufs", pid);
ret = rte_eth_rx_queue_setup(pid, q, pktgen.nb_rxd, sid, &info->rx_conf, pktgen.info[pid].q[q].rx_mp);
if (ret < 0)
pktgen_log_panic("rte_eth_rx_queue_setup: err=%d, port=%d, %s", ret, pid, rte_strerror(-ret));
}
pktgen_log_info("");
for(q = 0; q < rt.tx; q++) {
// grab the socket id value based on the lcore being used.
sid = rte_lcore_to_socket_id(wr_get_port_lid(pktgen.l2p, pid, q));
// Create and initialize the default Transmit buffers.
info->q[q].tx_mp = pktgen_mbuf_pool_create("Default TX", pid, q, MAX_MBUFS_PER_PORT, sid, cache_size);
if ( info->q[q].tx_mp == NULL )
pktgen_log_panic("Cannot init port %d for Default TX mbufs", pid);
// Create and initialize the range Transmit buffers.
info->q[q].range_mp = pktgen_mbuf_pool_create("Range TX", pid, q, MAX_MBUFS_PER_PORT, sid, 0);
if ( info->q[q].range_mp == NULL )
pktgen_log_panic("Cannot init port %d for Range TX mbufs", pid);
// Create and initialize the sequence Transmit buffers.
info->q[q].seq_mp = pktgen_mbuf_pool_create("Sequence TX", pid, q, MAX_MBUFS_PER_PORT, sid, cache_size);
if ( info->q[q].seq_mp == NULL )
pktgen_log_panic("Cannot init port %d for Sequence TX mbufs", pid);
// Used for sending special packets like ARP requests
info->q[q].special_mp = pktgen_mbuf_pool_create("Special TX", pid, q, MAX_SPECIAL_MBUFS, sid, cache_size);
if (info->q[q].special_mp == NULL)
pktgen_log_panic("Cannot init port %d for Special TX mbufs", pid);
// Setup the PCAP file for each port
if ( pktgen.info[pid].pcap != NULL ) {
if ( pktgen_pcap_parse(pktgen.info[pid].pcap, info, q) == -1 )
pktgen_log_panic("Cannot load PCAP file for port %d", pid);
}
// Find out the link speed to program the WTHRESH value correctly.
pktgen_get_link_status(info, pid, 0);
//info->tx_conf.tx_thresh.wthresh = (info->link.link_speed == 1000)? TX_WTHRESH_1GB : TX_WTHRESH;
ret = rte_eth_tx_queue_setup(pid, q, pktgen.nb_txd, sid, &info->tx_conf);
if (ret < 0)
pktgen_log_panic("rte_eth_tx_queue_setup: err=%d, port=%d, %s", ret, pid, rte_strerror(-ret));
#if 0
ret = rte_eth_dev_flow_ctrl_set(pid, &fc_conf);
if (ret < 0)
pktgen_log_panic("rte_eth_dev_flow_ctrl_set: err=%d, port=%d, %s", ret, pid, rte_strerror(-ret));
#endif
pktgen_log_info("");
}
pktgen_log_info("%*sPort memory used = %6lu KB", 71, " ", (pktgen.mem_used + 1023)/1024);
}
pktgen_log_info("%*sTotal memory used = %6lu KB", 70, " ", (pktgen.total_mem_used + 1023)/1024);
// Start up the ports and display the port Link status
for(pid = 0; pid < pktgen.nb_ports; pid++) {
if ( wr_get_map(pktgen.l2p, pid, RTE_MAX_LCORE) == 0 )
continue;
info = wr_get_port_private(pktgen.l2p, pid);
/* Start device */
if ( (ret = rte_eth_dev_start(pid)) < 0 )
pktgen_log_panic("rte_eth_dev_start: port=%d, %s", pid, rte_strerror(-ret));
pktgen_get_link_status(info, pid, 1);
if (info->link.link_status) {
snprintf(output_buff, sizeof(output_buff), "Port %2d: Link Up - speed %u Mbps - %s", pid,
(uint32_t) info->link.link_speed,
(info->link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
("full-duplex") : ("half-duplex"));
} else
snprintf(output_buff, sizeof(output_buff), "Port %2d: Link Down", pid);
// If enabled, put device in promiscuous mode.
if (pktgen.flags & PROMISCUOUS_ON_FLAG) {
strncatf(output_buff, " <Enable promiscuous mode>");
rte_eth_promiscuous_enable(pid);
}
pktgen_log_info("%s", output_buff);
pktgen.info[pid].seq_pkt[SINGLE_PKT].pktSize = MIN_PKT_SIZE;
// Setup the port and packet defaults. (must be after link speed is found)
for (s = 0; s < NUM_TOTAL_PKTS; s++)
pktgen_port_defaults(pid, s);
pktgen_range_setup(info);
pktgen_rnd_bits_init(&pktgen.info[pid].rnd_bitfields);
}
pktgen_log_info("");
for (sid = 0; sid < wr_coremap_cnt(pktgen.core_info, pktgen.core_cnt, 0); sid++)
pktgen_packet_capture_init(&pktgen.capture[sid], sid);
}
int
main(int argc, char **argv)
{
uint32_t i;
int32_t ret;
printf("\n%s %s\n", wr_copyright_msg(), wr_powered_by()); fflush(stdout);
wr_scrn_setw(1);/* Reset the window size */
/* call before the rte_eal_init() */
(void)rte_set_application_usage_hook(pktgen_usage);
memset(&pktgen, 0, sizeof(pktgen));
pktgen.flags = PRINT_LABELS_FLAG;
pktgen.ident = 0x1234;
pktgen.nb_rxd = DEFAULT_RX_DESC;
pktgen.nb_txd = DEFAULT_TX_DESC;
pktgen.nb_ports_per_page = DEFAULT_PORTS_PER_PAGE;
if ( (pktgen.l2p = wr_l2p_create()) == NULL)
pktgen_log_panic("Unable to create l2p");
pktgen.portdesc_cnt = wr_get_portdesc(pktgen.portlist, pktgen.portdesc, RTE_MAX_ETHPORTS, 0);
/* Initialize the screen and logging */
pktgen_init_log();
pktgen_cpu_init();
/* initialize EAL */
ret = rte_eal_init(argc, argv);
if (ret < 0)
return -1;
argc -= ret;
argv += ret;
pktgen.hz = rte_get_timer_hz(); /* Get the starting HZ value. */
/* parse application arguments (after the EAL ones) */
ret = pktgen_parse_args(argc, argv);
if (ret < 0)
return -1;
pktgen_init_screen((pktgen.flags & ENABLE_THEME_FLAG) ? THEME_ON : THEME_OFF);
rte_delay_ms(100); /* Wait a bit for things to settle. */
wr_print_copyright(PKTGEN_APP_NAME, PKTGEN_CREATED_BY);
lua_newlib_add(_lua_openlib);
/* Open the Lua script handler. */
if ( (pktgen.L = lua_create_instance()) == NULL) {
pktgen_log_error("Failed to open Lua pktgen support library");
return -1;
}
pktgen_log_info(">>> Packet Burst %d, RX Desc %d, TX Desc %d, mbufs/port %d, mbuf cache %d",
DEFAULT_PKT_BURST, DEFAULT_RX_DESC, DEFAULT_TX_DESC, MAX_MBUFS_PER_PORT, MBUF_CACHE_SIZE);
/* Configure and initialize the ports */
pktgen_config_ports();
pktgen_log_info("");
pktgen_log_info("=== Display processing on lcore %d", rte_lcore_id());
/* launch per-lcore init on every lcore except master and master + 1 lcores */
for (i = 0; i < RTE_MAX_LCORE; i++) {
if ( (i == rte_get_master_lcore()) || !rte_lcore_is_enabled(i) )
continue;
ret = rte_eal_remote_launch(pktgen_launch_one_lcore, NULL, i);
if (ret != 0)
pktgen_log_error("Failed to start lcore %d, return %d", i, ret);
}
rte_delay_ms(1000); /* Wait for the lcores to start up. */
/* Disable printing log messages of level info and below to screen, */
/* erase the screen and start updating the screen again. */
pktgen_log_set_screen_level(LOG_LEVEL_WARNING);
wr_scrn_erase(pktgen.scrn->nrows);
wr_logo(3, 16, PKTGEN_APP_NAME);
wr_splash_screen(3, 16, PKTGEN_APP_NAME, PKTGEN_CREATED_BY);
wr_scrn_resume();
pktgen_redisplay(1);
rte_timer_setup();
if (pktgen.flags & ENABLE_GUI_FLAG) {
if (!wr_scrn_is_paused() ) {
wr_scrn_pause();
wr_scrn_cls();
wr_scrn_setw(1);
wr_scrn_pos(pktgen.scrn->nrows, 1);
}
lua_init_socket(pktgen.L, &pktgen.thread, pktgen.hostname, pktgen.socket_port);
}
pktgen_cmdline_start();
execute_lua_close(pktgen.L);
pktgen_stop_running();
wr_scrn_pause();
wr_scrn_setw(1);
wr_scrn_printf(100, 1, "\n"); /* Put the cursor on the last row and do a newline. */
/* Wait for all of the cores to stop running and exit. */
rte_eal_mp_wait_lcore();
return 0;
}
void
pktgen_print_packet_dump(void)
{
port_info_t *info;
unsigned int pid;
unsigned int i, j;
unsigned char *pdata;
uint32_t plen;
char buff[4096];
for (pid = 0; pid < RTE_MAX_ETHPORTS; pid++) {
if (wr_get_map(pktgen.l2p, pid, RTE_MAX_LCORE) == 0)
continue;
info = &pktgen.info[pid];
for (; info->dump_head < info->dump_tail; ++info->dump_head) {
pdata =
(unsigned char *)info->dump_list[info->
dump_head
].data;
plen = info->dump_list[info->dump_head].len;
snprintf(buff, sizeof(buff),
"Port %d, packet with length %d:", pid, plen);
for (i = 0; i < plen; i += 16) {
strncatf(buff, "\n\t");
/* Byte counter */
strncatf(buff, "%06x: ", i);
for (j = 0; j < 16; ++j) {
/* Hex. value of character */
if (i + j < plen)
strncatf(buff, "%02x ",
pdata[i + j]);
else
strncatf(buff, " ");
/* Extra padding after 8 hex values for readability */
if ((j + 1) % 8 == 0)
strncatf(buff, " ");
}
/* Separate hex. values and raw characters */
strncatf(buff, "\t");
for (j = 0; j < 16; ++j)
if (i + j < plen)
strncatf(buff, "%c",
isprint(pdata[i +
j]) ?
pdata[
i + j] : '.');
}
pktgen_log_info("%s", buff);
rte_free(info->dump_list[info->dump_head].data);
info->dump_list[info->dump_head].data = NULL;
}
}
}
static int
pktgen_parse_args(int argc, char **argv)
{
int opt, ret, port;
char **argvopt;
int option_index;
char *prgname = argv[0], *p;
static struct option lgopts[] = {
{NULL, 0, 0, 0}
};
argvopt = argv;
pktgen.hostname = (char *)strdupf(pktgen.hostname, "localhost");
pktgen.socket_port = 0x5606;
pktgen.argc = argc;
for (opt = 0; opt < argc; opt++)
pktgen.argv[opt] = strdup(argv[opt]);
while ((opt = getopt_long(argc, argvopt, "p:m:f:l:s:g:hPNGT",
lgopts, &option_index)) != EOF)
switch (opt) {
case 'p':
/* Port mask not used anymore */
break;
case 'f': /* Command file or Lua script. */
pktgen.cmd_filename = strdup(optarg);
break;
case 'l': /* Log file */
pktgen_log_set_file(optarg);
break;
case 'm': /* Matrix for port mapping. */
if (wr_parse_matrix(pktgen.l2p, optarg) == -1) {
pktgen_log_error("invalid matrix string (%s)", optarg);
pktgen_usage(prgname);
return -1;
}
break;
case 's': /* Read a PCAP packet capture file (stream) */
port = strtol(optarg, NULL, 10);
p = strchr(optarg, ':');
if ( (p == NULL) || (pktgen.info[port].pcap = wr_pcap_open(++p, port)) == NULL) {
pktgen_log_error("Invalid PCAP filename (%s) must include port number as P:filename", optarg);
pktgen_usage(prgname);
return -1;
}
break;
case 'P': /* Enable promiscuous mode on the ports */
pktgen.flags |= PROMISCUOUS_ON_FLAG;
break;
case 'N': /* Enable NUMA support. */
pktgen.flags |= NUMA_SUPPORT_FLAG;
break;
case 'G':
pktgen.flags |= (ENABLE_GUI_FLAG | IS_SERVER_FLAG);
break;
case 'g': /* Define the port number and IP address used for the socket connection. */
pktgen.flags |= (ENABLE_GUI_FLAG | IS_SERVER_FLAG);
p = strchr(optarg, ':');
if (p == NULL) /* No : symbol means pktgen is a server application. */
pktgen.hostname = (char *)strdupf(pktgen.hostname, optarg);
else {
char c = *p;
*p = '\0';
if (p != optarg)
pktgen.hostname = (char *)strdupf(pktgen.hostname, optarg);
pktgen.socket_port = strtol(++p, NULL, 0);
pktgen_log_info(">>> Socket GUI support %s%c0x%x", pktgen.hostname, c, pktgen.socket_port);
}
break;
case 'T':
pktgen.flags |= ENABLE_THEME_FLAG;
break;
case 'h': /* print out the help message */
pktgen_usage(prgname);
return -1;
case 0: /* Long options */
default:
pktgen_usage(prgname);
return -1;
}
/* Setup the program name */
if (optind >= 0)
argv[optind - 1] = prgname;
ret = optind - 1;
optind = 0; /* reset getopt lib */
return ret;
}