#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
#include <string.h>
#include <sys/queue.h>
#include <stdarg.h>
#include <errno.h>
#include <getopt.h>
#define RTE_LOGTYPE_IPv4_MULTICAST RTE_LOGTYPE_USER1
#define MAX_PORTS 16
#define MCAST_CLONE_PORTS 2
#define MCAST_CLONE_SEGS 2
#define PKT_MBUF_DATA_SIZE RTE_MBUF_DEFAULT_BUF_SIZE
#define NB_PKT_MBUF 8192
#define HDR_MBUF_DATA_SIZE (2 * RTE_PKTMBUF_HEADROOM)
#define NB_HDR_MBUF (NB_PKT_MBUF * MAX_PORTS)
#define NB_CLONE_MBUF (NB_PKT_MBUF * MCAST_CLONE_PORTS * MCAST_CLONE_SEGS * 2)
#define JUMBO_FRAME_MAX_SIZE 0x2600
#define MAX_PKT_BURST 32
#define BURST_TX_DRAIN_US 100
#define PREFETCH_OFFSET 3
#define ETHER_ADDR_FOR_IPV4_MCAST(x) \
(rte_cpu_to_be_64(0x01005e000000ULL | ((x) & 0x7fffff)) >> 16)
#define RX_DESC_DEFAULT 1024
#define TX_DESC_DEFAULT 1024
static uint16_t nb_rxd = RX_DESC_DEFAULT;
static uint16_t nb_txd = TX_DESC_DEFAULT;
static struct rte_ether_addr ports_eth_addr[MAX_PORTS];
static uint32_t enabled_port_mask = 0;
static uint16_t nb_ports;
static int rx_queue_per_lcore = 1;
struct mbuf_table {
uint16_t len;
struct rte_mbuf *m_table[MAX_PKT_BURST];
};
#define MAX_RX_QUEUE_PER_LCORE 16
#define MAX_TX_QUEUE_PER_PORT 16
uint64_t tx_tsc;
uint16_t n_rx_queue;
uint8_t rx_queue_list[MAX_RX_QUEUE_PER_LCORE];
uint16_t tx_queue_id[MAX_PORTS];
struct mbuf_table tx_mbufs[MAX_PORTS];
};
static struct lcore_queue_conf lcore_queue_conf[RTE_MAX_LCORE];
},
.txmode = {
},
};
static struct rte_mempool *packet_pool, *header_pool, *clone_pool;
.entries = 1024,
.entries_per_bucket = 4,
.socket_id = 0,
.hash_func = NULL,
.init_val = 0,
};
struct mcast_group_params {
uint32_t ip;
uint16_t port_mask;
};
static struct mcast_group_params mcast_group_table[] = {
};
static void
send_burst(struct lcore_queue_conf *qconf, uint16_t port)
{
uint16_t n, queueid;
int ret;
queueid = qconf->tx_queue_id[
port];
m_table = (
struct rte_mbuf **)qconf->tx_mbufs[port].m_table;
n = qconf->tx_mbufs[port].len;
ret++;
}
qconf->tx_mbufs[
port].len = 0;
}
static inline uint32_t
bitcnt(uint32_t v)
{
uint32_t n;
for (n = 0; v != 0; v &= v - 1, n++)
;
return n;
}
mcast_out_pkt(
struct rte_mbuf *pkt,
int use_clone)
{
return NULL;
if (use_clone != 0 &&
return NULL;
}
return hdr;
}
static inline void
mcast_send_pkt(
struct rte_mbuf *pkt,
struct rte_ether_addr *dest_addr,
struct lcore_queue_conf *qconf, uint16_t port)
{
struct rte_ether_hdr *ethdr;
uint16_t len;
ethdr = (struct rte_ether_hdr *)
RTE_ASSERT(ethdr != NULL);
len = qconf->tx_mbufs[port].len;
qconf->tx_mbufs[port].m_table[len] = pkt;
qconf->tx_mbufs[port].len = ++len;
send_burst(qconf, port);
}
static inline void
mcast_forward(
struct rte_mbuf *m,
struct lcore_queue_conf *qconf)
{
uint32_t dest_addr, port_mask, port_num, use_clone;
int32_t hash;
uint16_t port;
union {
uint64_t as_int;
struct rte_ether_addr as_addr;
} dst_eth_addr;
RTE_ASSERT(iphdr != NULL);
(port_mask = hash & enabled_port_mask) == 0) {
return;
}
port_num = bitcnt(port_mask);
use_clone = (port_num <= MCAST_CLONE_PORTS &&
if (use_clone == 0)
dst_eth_addr.as_int = ETHER_ADDR_FOR_IPV4_MCAST(dest_addr);
for (port = 0; use_clone != port_mask; port_mask >>= 1, port++) {
if ((port_mask & 1) != 0) {
if (
likely ((mc = mcast_out_pkt(m, use_clone)) != NULL))
mcast_send_pkt(mc, &dst_eth_addr.as_addr,
qconf, port);
else if (use_clone == 0)
}
}
if (use_clone != 0)
mcast_send_pkt(m, &dst_eth_addr.as_addr, qconf, port);
else
}
static inline void
send_timeout_burst(struct lcore_queue_conf *qconf)
{
uint64_t cur_tsc;
uint16_t portid;
const uint64_t drain_tsc = (
rte_get_tsc_hz() + US_PER_S - 1) / US_PER_S * BURST_TX_DRAIN_US;
cur_tsc = rte_rdtsc();
if (
likely (cur_tsc < qconf->tx_tsc + drain_tsc))
return;
for (portid = 0; portid < MAX_PORTS; portid++) {
if (qconf->tx_mbufs[portid].len != 0)
send_burst(qconf, portid);
}
qconf->tx_tsc = cur_tsc;
}
static int
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
int i, j, nb_rx;
uint16_t portid;
struct lcore_queue_conf *qconf;
qconf = &lcore_queue_conf[lcore_id];
if (qconf->n_rx_queue == 0) {
RTE_LOG(INFO, IPv4_MULTICAST,
"lcore %u has nothing to do\n",
lcore_id);
return 0;
}
RTE_LOG(INFO, IPv4_MULTICAST,
"entering main loop on lcore %u\n",
lcore_id);
for (i = 0; i < qconf->n_rx_queue; i++) {
portid = qconf->rx_queue_list[i];
RTE_LOG(INFO, IPv4_MULTICAST,
" -- lcoreid=%u portid=%d\n",
lcore_id, portid);
}
while (1) {
for (i = 0; i < qconf->n_rx_queue; i++) {
portid = qconf->rx_queue_list[i];
MAX_PKT_BURST);
for (j = 0; j < PREFETCH_OFFSET && j < nb_rx; j++) {
pkts_burst[j], void *));
}
for (j = 0; j < (nb_rx - PREFETCH_OFFSET); j++) {
j + PREFETCH_OFFSET], void *));
mcast_forward(pkts_burst[j], qconf);
}
for (; j < nb_rx; j++) {
mcast_forward(pkts_burst[j], qconf);
}
}
send_timeout_burst(qconf);
}
}
static void
print_usage(const char *prgname)
{
printf("%s [EAL options] -- -p PORTMASK [-q NQ]\n"
" -p PORTMASK: hexadecimal bitmask of ports to configure\n"
" -q NQ: number of queue (=ports) per lcore (default is 1)\n",
prgname);
}
static uint32_t
parse_portmask(const char *portmask)
{
char *end = NULL;
unsigned long pm;
pm = strtoul(portmask, &end, 16);
if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
return 0;
return (uint32_t)pm;
}
static int
parse_nqueue(const char *q_arg)
{
char *end = NULL;
unsigned long n;
errno = 0;
n = strtoul(q_arg, &end, 0);
if (errno != 0 || end == NULL || *end != '\0' ||
n == 0 || n >= MAX_RX_QUEUE_PER_LCORE)
return -1;
return n;
}
static int
parse_args(int argc, char **argv)
{
int opt, ret;
char **argvopt;
int option_index;
char *prgname = argv[0];
static struct option lgopts[] = {
{NULL, 0, 0, 0}
};
argvopt = argv;
while ((opt = getopt_long(argc, argvopt, "p:q:",
lgopts, &option_index)) != EOF) {
switch (opt) {
case 'p':
enabled_port_mask = parse_portmask(optarg);
if (enabled_port_mask == 0) {
printf("invalid portmask\n");
print_usage(prgname);
return -1;
}
break;
case 'q':
rx_queue_per_lcore = parse_nqueue(optarg);
if (rx_queue_per_lcore < 0) {
printf("invalid queue number\n");
print_usage(prgname);
return -1;
}
break;
default:
print_usage(prgname);
return -1;
}
}
if (optind >= 0)
argv[optind-1] = prgname;
ret = optind-1;
optind = 1;
return ret;
}
static void
print_ethaddr(const char *name, struct rte_ether_addr *eth_addr)
{
char buf[RTE_ETHER_ADDR_FMT_SIZE];
printf("%s%s", name, buf);
}
static int
init_mcast_hash(void)
{
uint32_t i;
if (mcast_hash == NULL){
return -1;
}
for (i = 0; i <
RTE_DIM(mcast_group_table); i++) {
mcast_group_table[i].ip,
mcast_group_table[i].port_mask) < 0) {
return -1;
}
}
return 0;
}
static void
check_all_ports_link_status(uint32_t port_mask)
{
#define CHECK_INTERVAL 100
#define MAX_CHECK_TIME 90
uint16_t portid;
uint8_t count, all_ports_up, print_flag = 0;
int ret;
printf("\nChecking link status");
fflush(stdout);
for (count = 0; count <= MAX_CHECK_TIME; count++) {
all_ports_up = 1;
if ((port_mask & (1 << portid)) == 0)
continue;
memset(&link, 0, sizeof(link));
if (ret < 0) {
all_ports_up = 0;
if (print_flag == 1)
printf("Port %u link get failed: %s\n",
continue;
}
if (print_flag == 1) {
sizeof(link_status_text),
&link);
printf("Port %d %s\n", portid,
link_status_text);
continue;
}
all_ports_up = 0;
break;
}
}
if (print_flag == 1)
break;
if (all_ports_up == 0) {
printf(".");
fflush(stdout);
}
if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) {
print_flag = 1;
printf("done\n");
}
}
}
int
main(int argc, char **argv)
{
struct lcore_queue_conf *qconf;
int ret;
uint16_t queueid;
unsigned lcore_id = 0, rx_lcore_id = 0;
uint32_t n_tx_queue, nb_lcores;
uint16_t portid;
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Invalid EAL parameters\n");
argc -= ret;
argv += ret;
ret = parse_args(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Invalid IPV4_MULTICAST parameters\n");
if (packet_pool == NULL)
rte_exit(EXIT_FAILURE,
"Cannot init packet mbuf pool\n");
if (header_pool == NULL)
rte_exit(EXIT_FAILURE,
"Cannot init header mbuf pool\n");
if (clone_pool == NULL)
rte_exit(EXIT_FAILURE,
"Cannot init clone mbuf pool\n");
if (nb_ports == 0)
rte_exit(EXIT_FAILURE,
"No physical ports!\n");
if (nb_ports > MAX_PORTS)
nb_ports = MAX_PORTS;
if ((enabled_port_mask & (1 << portid)) == 0) {
printf("Skipping disabled port %d\n", portid);
continue;
}
qconf = &lcore_queue_conf[rx_lcore_id];
if (ret != 0)
"Error during getting device (port %u) info: %s\n",
portid, strerror(-ret));
dev_info.max_mtu,
qconf->n_rx_queue == (unsigned)rx_queue_per_lcore) {
rx_lcore_id ++;
qconf = &lcore_queue_conf[rx_lcore_id];
if (rx_lcore_id >= RTE_MAX_LCORE)
rte_exit(EXIT_FAILURE,
"Not enough cores\n");
}
qconf->rx_queue_list[qconf->n_rx_queue] = portid;
qconf->n_rx_queue++;
printf("Initializing port %d on lcore %u... ", portid,
rx_lcore_id);
fflush(stdout);
n_tx_queue = nb_lcores;
if (n_tx_queue > MAX_TX_QUEUE_PER_PORT)
n_tx_queue = MAX_TX_QUEUE_PER_PORT;
&local_port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Cannot configure device: err=%d, port=%d\n",
ret, portid);
&nb_txd);
if (ret < 0)
"Cannot adjust number of descriptors: err=%d, port=%d\n",
ret, portid);
if (ret < 0)
"Cannot get MAC address: err=%d, port=%d\n",
ret, portid);
print_ethaddr(" Address:", &ports_eth_addr[portid]);
printf(", ");
queueid = 0;
printf("rxq=%hu ", queueid);
fflush(stdout);
rxq_conf = dev_info.default_rxconf;
&rxq_conf,
packet_pool);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_tx_queue_setup: err=%d, port=%d\n",
ret, portid);
queueid = 0;
continue;
printf("txq=%u,%hu ", lcore_id, queueid);
fflush(stdout);
txconf = &dev_info.default_txconf;
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_tx_queue_setup: err=%d, " "port=%d\n", ret, portid);
qconf = &lcore_queue_conf[lcore_id];
qconf->tx_queue_id[portid] = queueid;
queueid++;
}
if (ret < 0)
"rte_eth_allmulticast_enable: err=%d, port=%d\n",
ret, portid);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"rte_eth_dev_start: err=%d, port=%d\n",
ret, portid);
printf("done:\n");
}
check_all_ports_link_status(enabled_port_mask);
int retval = init_mcast_hash();
if (retval != 0)
rte_exit(EXIT_FAILURE,
"Cannot build the multicast hash\n");
return -1;
}
return 0;
}