static int sock_mmap_open(odp_pktio_t id ODP_UNUSED,
pktio_entry_t *pktio_entry,
const char *netdev, odp_pool_t pool)
{
int if_idx;
int ret = 0;
odp_pktio_stats_t cur_stats;
if (disable_pktio)
return -1;
pkt_sock_mmap_t *const pkt_sock = &pktio_entry->s.pkt_sock_mmap;
int fanout = 1;
/* Init pktio entry */
memset(pkt_sock, 0, sizeof(*pkt_sock));
/* set sockfd to -1, because a valid socked might be initialized to 0 */
pkt_sock->sockfd = -1;
if (pool == ODP_POOL_INVALID)
return -1;
/* Store eth buffer offset for pkt buffers from this pool */
pkt_sock->frame_offset = 0;
pkt_sock->pool = pool;
pkt_sock->sockfd = mmap_pkt_socket();
if (pkt_sock->sockfd == -1)
goto error;
ret = mmap_bind_sock(pkt_sock, netdev);
if (ret != 0)
goto error;
ret = mmap_setup_ring(pkt_sock->sockfd, &pkt_sock->tx_ring,
PACKET_TX_RING, pool, fanout);
if (ret != 0)
goto error;
ret = mmap_setup_ring(pkt_sock->sockfd, &pkt_sock->rx_ring,
PACKET_RX_RING, pool, fanout);
if (ret != 0)
goto error;
ret = mmap_sock(pkt_sock);
if (ret != 0)
goto error;
ret = mac_addr_get_fd(pkt_sock->sockfd, netdev, pkt_sock->if_mac);
if (ret != 0)
goto error;
if_idx = if_nametoindex(netdev);
if (if_idx == 0) {
__odp_errno = errno;
ODP_ERR("if_nametoindex(): %s\n", strerror(errno));
goto error;
}
pkt_sock->fanout = fanout;
if (fanout) {
ret = set_pkt_sock_fanout_mmap(pkt_sock, if_idx);
if (ret != 0)
goto error;
}
ret = ethtool_stats_get_fd(pktio_entry->s.pkt_sock_mmap.sockfd,
pktio_entry->s.name,
&cur_stats);
if (ret != 0) {
ret = sysfs_stats(pktio_entry, &cur_stats);
if (ret != 0) {
pktio_entry->s.stats_type = STATS_UNSUPPORTED;
ODP_DBG("pktio: %s unsupported stats\n",
pktio_entry->s.name);
} else {
pktio_entry->s.stats_type = STATS_SYSFS;
}
} else {
pktio_entry->s.stats_type = STATS_ETHTOOL;
}
ret = sock_stats_reset_fd(pktio_entry,
pktio_entry->s.pkt_sock_mmap.sockfd);
if (ret != 0)
goto error;
return 0;
error:
sock_mmap_close(pktio_entry);
return -1;
}
static int netmap_open(odp_pktio_t id ODP_UNUSED, pktio_entry_t *pktio_entry,
const char *netdev, odp_pool_t pool)
{
int i;
int err;
int sockfd;
int mtu;
uint32_t buf_size;
pkt_netmap_t *pkt_nm = &pktio_entry->s.pkt_nm;
struct nm_desc *desc;
struct netmap_ring *ring;
odp_pktin_hash_proto_t hash_proto;
odp_pktio_stats_t cur_stats;
if (getenv("ODP_PKTIO_DISABLE_NETMAP"))
return -1;
if (pool == ODP_POOL_INVALID)
return -1;
/* Init pktio entry */
memset(pkt_nm, 0, sizeof(*pkt_nm));
pkt_nm->sockfd = -1;
pkt_nm->pool = pool;
/* max frame len taking into account the l2-offset */
pkt_nm->max_frame_len = ODP_CONFIG_PACKET_BUF_LEN_MAX -
odp_buffer_pool_headroom(pool) -
odp_buffer_pool_tailroom(pool);
snprintf(pktio_entry->s.name, sizeof(pktio_entry->s.name), "%s",
netdev);
snprintf(pkt_nm->nm_name, sizeof(pkt_nm->nm_name), "netmap:%s",
netdev);
/* Dummy open here to check if netmap module is available and to read
* capability info. */
desc = nm_open(pkt_nm->nm_name, NULL, 0, NULL);
if (desc == NULL) {
ODP_ERR("nm_open(%s) failed\n", pkt_nm->nm_name);
goto error;
}
if (desc->nifp->ni_rx_rings > NM_MAX_DESC) {
ODP_ERR("Unable to store all rx rings\n");
nm_close(desc);
goto error;
}
pkt_nm->num_rx_rings = desc->nifp->ni_rx_rings;
pkt_nm->capa.max_input_queues = PKTIO_MAX_QUEUES;
if (desc->nifp->ni_rx_rings < PKTIO_MAX_QUEUES)
pkt_nm->capa.max_input_queues = desc->nifp->ni_rx_rings;
if (desc->nifp->ni_tx_rings > NM_MAX_DESC) {
ODP_ERR("Unable to store all tx rings\n");
nm_close(desc);
goto error;
}
pkt_nm->num_tx_rings = desc->nifp->ni_tx_rings;
pkt_nm->capa.max_output_queues = PKTIO_MAX_QUEUES;
if (desc->nifp->ni_tx_rings < PKTIO_MAX_QUEUES)
pkt_nm->capa.max_output_queues = desc->nifp->ni_tx_rings;
ring = NETMAP_RXRING(desc->nifp, desc->cur_rx_ring);
buf_size = ring->nr_buf_size;
nm_close(desc);
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1) {
ODP_ERR("Cannot get device control socket\n");
goto error;
}
pkt_nm->sockfd = sockfd;
/* Use either interface MTU (+ ethernet header length) or netmap buffer
* size as MTU, whichever is smaller. */
mtu = mtu_get_fd(pktio_entry->s.pkt_nm.sockfd, pktio_entry->s.name) +
ODPH_ETHHDR_LEN;
if (mtu < 0) {
ODP_ERR("Unable to read interface MTU\n");
goto error;
}
pkt_nm->mtu = ((uint32_t)mtu < buf_size) ? (uint32_t)mtu : buf_size;
/* Check if RSS is supported. If not, set 'max_input_queues' to 1. */
if (rss_conf_get_supported_fd(sockfd, netdev, &hash_proto) == 0) {
ODP_DBG("RSS not supported\n");
pkt_nm->capa.max_input_queues = 1;
}
err = netmap_do_ioctl(pktio_entry, SIOCGIFFLAGS, 0);
if (err)
goto error;
if ((pkt_nm->if_flags & IFF_UP) == 0)
ODP_DBG("%s is down\n", pktio_entry->s.name);
err = mac_addr_get_fd(sockfd, netdev, pkt_nm->if_mac);
if (err)
goto error;
for (i = 0; i < PKTIO_MAX_QUEUES; i++) {
odp_ticketlock_init(&pkt_nm->rx_desc_ring[i].s.lock);
odp_ticketlock_init(&pkt_nm->tx_desc_ring[i].s.lock);
}
/* netmap uses only ethtool to get statistics counters */
err = ethtool_stats_get_fd(pktio_entry->s.pkt_nm.sockfd,
pktio_entry->s.name,
&cur_stats);
if (err) {
ODP_ERR(
"netmap pktio %s does not support statistics counters\n",
pktio_entry->s.name);
pktio_entry->s.stats_type = STATS_UNSUPPORTED;
} else {
pktio_entry->s.stats_type = STATS_ETHTOOL;
}
(void)netmap_stats_reset(pktio_entry);
return 0;
error:
netmap_close(pktio_entry);
return -1;
}