examples/netmap_compat/lib/compat_netmap.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */

#include <errno.h>
#include <inttypes.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <net/if.h>
#include <sys/types.h>
#include <sys/resource.h>
#include <sys/mman.h>

#include <rte_common.h>
#include <rte_errno.h>
#include <rte_ethdev.h>
#include <rte_log.h>
#include <rte_malloc.h>
#include <rte_mbuf.h>
#include <rte_spinlock.h>
#include <rte_string_fns.h>

#include "compat_netmap.h"

struct netmap_port {
    struct rte_mempool   *pool;
    struct netmap_if     *nmif;
    struct rte_eth_conf   eth_conf;
    struct rte_eth_txconf tx_conf;
    struct rte_eth_rxconf rx_conf;
    int32_t  socket_id;
    uint16_t nr_tx_rings;
    uint16_t nr_rx_rings;
    uint32_t nr_tx_slots;
    uint32_t nr_rx_slots;
    uint16_t tx_burst;
    uint16_t rx_burst;
    uint32_t fd;
};

struct fd_port {
    uint32_t port;
};

#ifndef POLLRDNORM
#define POLLRDNORM  0x0040
#endif

#ifndef POLLWRNORM
#define POLLWRNORM  0x0100
#endif

#define FD_PORT_FREE    UINT32_MAX
#define FD_PORT_RSRV    (FD_PORT_FREE - 1)

struct netmap_state {
    struct rte_netmap_conf conf;
    uintptr_t buf_start;
    void     *mem;
    uint32_t  mem_sz;
    uint32_t  netif_memsz;
};


#define COMPAT_NETMAP_MAX_NOFILE    (2 * RTE_MAX_ETHPORTS)
#define COMPAT_NETMAP_MAX_BURST     64
#define COMPAT_NETMAP_MAX_PKT_PER_SYNC  (2 * COMPAT_NETMAP_MAX_BURST)

static struct netmap_port ports[RTE_MAX_ETHPORTS];
static struct netmap_state netmap;

static struct fd_port fd_port[COMPAT_NETMAP_MAX_NOFILE];
static const int next_fd_start = RLIMIT_NOFILE + 1;
static rte_spinlock_t netmap_lock;

#define IDX_TO_FD(x)    ((x) + next_fd_start)
#define FD_TO_IDX(x)    ((x) - next_fd_start)
#define FD_VALID(x) ((x) >= next_fd_start && \
    (x) < (typeof (x))(RTE_DIM(fd_port) + next_fd_start))

#define PORT_NUM_RINGS  (2 * netmap.conf.max_rings)
#define PORT_NUM_SLOTS  (PORT_NUM_RINGS * netmap.conf.max_slots)

#define BUF_IDX(port, ring, slot)            \
    (((port) * PORT_NUM_RINGS + (ring)) * netmap.conf.max_slots + \
    (slot))

#define NETMAP_IF_RING_OFS(rid, rings, slots)   ({\
    struct netmap_if *_if;                    \
    struct netmap_ring *_rg;                  \
    sizeof(*_if) +                            \
    (rings) * sizeof(_if->ring_ofs[0]) +      \
    (rid) * sizeof(*_rg) +                    \
    (slots) * sizeof(_rg->slot[0]);           \
    })

static void netmap_unregif(uint32_t idx, uint32_t port);


static int32_t
ifname_to_portid(const char *ifname, uint16_t *port)
{
    char *endptr;
    uint64_t portid;

    errno = 0;
    portid = strtoul(ifname, &endptr, 10);
    if (endptr == ifname || *endptr != '\0' ||
            portid >= RTE_DIM(ports) || errno != 0)
        return -EINVAL;

    *port = portid;
    return 0;
}

static void
mbuf_to_slot(struct rte_mbuf *mbuf, struct netmap_ring *r, uint32_t index)
{
    char *data;
    uint16_t length;

    data   = rte_pktmbuf_mtod(mbuf, char *);
    length = rte_pktmbuf_data_len(mbuf);

    if (length > r->nr_buf_size)
        length = 0;

    r->slot[index].len = length;
    rte_memcpy(NETMAP_BUF(r, r->slot[index].buf_idx), data, length);
}

static void
slot_to_mbuf(struct netmap_ring *r, uint32_t index, struct rte_mbuf *mbuf)
{
    char *data;
    uint16_t length;

    rte_pktmbuf_reset(mbuf);
    length = r->slot[index].len;
    data = rte_pktmbuf_append(mbuf, length);

    if (data != NULL)
        rte_memcpy(data, NETMAP_BUF(r, r->slot[index].buf_idx), length);
}

static int32_t
fd_reserve(void)
{
    uint32_t i;

    for (i = 0; i != RTE_DIM(fd_port) && fd_port[i].port != FD_PORT_FREE;
            i++)
        ;

    if (i == RTE_DIM(fd_port))
        return -ENOMEM;

    fd_port[i].port = FD_PORT_RSRV;
    return IDX_TO_FD(i);
}

static int32_t
fd_release(int32_t fd)
{
    uint32_t idx, port;

    idx = FD_TO_IDX(fd);

    if (!FD_VALID(fd) || (port = fd_port[idx].port) == FD_PORT_FREE)
        return -EINVAL;

    /* if we still have a valid port attached, release the port */
    if (port < RTE_DIM(ports) && ports[port].fd == idx) {
        netmap_unregif(idx, port);
    }

    fd_port[idx].port = FD_PORT_FREE;
    return 0;
}

static int
check_nmreq(struct nmreq *req, uint16_t *port)
{
    int32_t rc;
    uint16_t portid;

    if (req == NULL)
        return -EINVAL;

    if (req->nr_version != NETMAP_API) {
        req->nr_version = NETMAP_API;
        return -EINVAL;
    }

    if ((rc = ifname_to_portid(req->nr_name, &portid)) != 0) {
            RTE_LOG(ERR, USER1, "Invalid interface name:\"%s\" "
            "in NIOCGINFO call\n", req->nr_name);
        return rc;
    }

    if (ports[portid].pool == NULL) {
        RTE_LOG(ERR, USER1, "Misconfigured portid %u\n", portid);
        return -EINVAL;
    }

    *port = portid;
    return 0;
}

static int
ioctl_niocginfo(__rte_unused int fd, void * param)
{
    uint16_t portid;
    struct nmreq *req;
    int32_t rc;

    req = (struct nmreq *)param;
    if ((rc = check_nmreq(req, &portid)) != 0)
        return rc;

    req->nr_tx_rings = (uint16_t)(ports[portid].nr_tx_rings - 1);
    req->nr_rx_rings = (uint16_t)(ports[portid].nr_rx_rings - 1);
    req->nr_tx_slots = ports[portid].nr_tx_slots;
    req->nr_rx_slots = ports[portid].nr_rx_slots;

    /* in current implementation we have all NETIFs shared aone region. */
    req->nr_memsize = netmap.mem_sz;
    req->nr_offset = 0;

    return 0;
}

static void
netmap_ring_setup(struct netmap_ring *ring, uint16_t port, uint32_t ringid,
    uint32_t num_slots)
{
    uint32_t j;

    ring->buf_ofs = netmap.buf_start - (uintptr_t)ring;
    ring->num_slots = num_slots;
    ring->cur = 0;
    ring->reserved = 0;
    ring->nr_buf_size = netmap.conf.max_bufsz;
    ring->flags = 0;
    ring->ts.tv_sec = 0;
    ring->ts.tv_usec = 0;

    for (j = 0; j < ring->num_slots; j++) {
        ring->slot[j].buf_idx = BUF_IDX(port, ringid, j);
        ring->slot[j].len = 0;
        ring->flags = 0;
    }
}

static int
netmap_regif(struct nmreq *req, uint32_t idx, uint16_t port)
{
    struct netmap_if *nmif;
    struct netmap_ring *ring;
    uint32_t i, slots, start_ring;
    int32_t rc;

    if (ports[port].fd < RTE_DIM(fd_port)) {
        RTE_LOG(ERR, USER1, "port %u already in use by fd: %u\n",
            port, IDX_TO_FD(ports[port].fd));
        return -EBUSY;
    }
    if (fd_port[idx].port != FD_PORT_RSRV) {
            RTE_LOG(ERR, USER1, "fd: %u is misconfigured\n",
            IDX_TO_FD(idx));
        return -EBUSY;
    }

    nmif = ports[port].nmif;

    /* setup netmap_if fields. */
    memset(nmif, 0, netmap.netif_memsz);

    /* only ALL rings supported right now. */
    if (req->nr_ringid != 0)
        return -EINVAL;

    snprintf(nmif->ni_name, sizeof(nmif->ni_name), "%s", req->nr_name);
    nmif->ni_version  = req->nr_version;

    /* Netmap uses ni_(r|t)x_rings + 1 */
    nmif->ni_rx_rings = ports[port].nr_rx_rings - 1;
    nmif->ni_tx_rings = ports[port].nr_tx_rings - 1;

    /*
     * Setup TX rings and slots.
     * Refer to the comments in netmap.h for details
     */

    slots = 0;
    for (i = 0; i < nmif->ni_tx_rings + 1; i++) {

        nmif->ring_ofs[i] = NETMAP_IF_RING_OFS(i,
            PORT_NUM_RINGS, slots);

        ring = NETMAP_TXRING(nmif, i);
        netmap_ring_setup(ring, port, i, ports[port].nr_tx_slots);
        ring->avail = ring->num_slots;

        slots += ports[port].nr_tx_slots;
    }

    /*
     * Setup  RX rings and slots.
     * Refer to the comments in netmap.h for details
     */

    start_ring = i;

    for (; i < nmif->ni_rx_rings + 1 + start_ring; i++) {

        nmif->ring_ofs[i] = NETMAP_IF_RING_OFS(i,
            PORT_NUM_RINGS, slots);

        ring = NETMAP_RXRING(nmif, (i - start_ring));
        netmap_ring_setup(ring, port, i, ports[port].nr_rx_slots);
        ring->avail = 0;

        slots += ports[port].nr_rx_slots;
    }

    if ((rc = rte_eth_dev_start(port)) < 0) {
        RTE_LOG(ERR, USER1,
            "Couldn't start ethernet device %s (error %d)\n",
            req->nr_name, rc);
        return rc;
    }

    /* setup fdi <--> port relationtip. */
    ports[port].fd = idx;
    fd_port[idx].port = port;

    req->nr_memsize = netmap.mem_sz;
    req->nr_offset = (uintptr_t)nmif - (uintptr_t)netmap.mem;

    return 0;
}

static int
ioctl_niocregif(int32_t fd, void * param)
{
    uint16_t portid;
    int32_t rc;
    uint32_t idx;
    struct nmreq *req;

    req = (struct nmreq *)param;
    if ((rc = check_nmreq(req, &portid)) != 0)
        return rc;

    idx = FD_TO_IDX(fd);

    rte_spinlock_lock(&netmap_lock);
    rc = netmap_regif(req, idx, portid);
    rte_spinlock_unlock(&netmap_lock);

    return rc;
}

static void
netmap_unregif(uint32_t idx, uint32_t port)
{
    fd_port[idx].port = FD_PORT_RSRV;
    ports[port].fd = UINT32_MAX;
    rte_eth_dev_stop(port);
}

static int
ioctl_niocunregif(int fd)
{
    uint32_t idx, port;
    int32_t rc;

    idx = FD_TO_IDX(fd);

    rte_spinlock_lock(&netmap_lock);

    port = fd_port[idx].port;
    if (port < RTE_DIM(ports) && ports[port].fd == idx) {
        netmap_unregif(idx, port);
        rc = 0;
    } else {
        RTE_LOG(ERR, USER1,
            "%s: %d is not associated with valid port\n",
            __func__, fd);
        rc = -EINVAL;
    }

    rte_spinlock_unlock(&netmap_lock);
    return rc;
}

static inline int
rx_sync_ring(struct netmap_ring *ring, uint16_t port, uint16_t ring_number,
    uint16_t max_burst)
{
    int32_t i, n_rx;
    uint16_t burst_size;
    uint32_t cur_slot, n_free_slots;
    struct rte_mbuf *rx_mbufs[COMPAT_NETMAP_MAX_BURST];

    n_free_slots = ring->num_slots - (ring->avail + ring->reserved);
    n_free_slots = RTE_MIN(n_free_slots, max_burst);
    cur_slot = (ring->cur + ring->avail) & (ring->num_slots - 1);

    while (n_free_slots) {
        burst_size = (uint16_t)RTE_MIN(n_free_slots, RTE_DIM(rx_mbufs));

        /* receive up to burst_size packets from the NIC's queue */
        n_rx = rte_eth_rx_burst(port, ring_number, rx_mbufs,
            burst_size);

        if (n_rx == 0)
            return 0;
        if (unlikely(n_rx < 0))
            return -1;

        /* Put those n_rx packets in the Netmap structures */
        for (i = 0; i < n_rx ; i++) {
            mbuf_to_slot(rx_mbufs[i], ring, cur_slot);
            rte_pktmbuf_free(rx_mbufs[i]);
            cur_slot = NETMAP_RING_NEXT(ring, cur_slot);
        }

        /* Update the Netmap ring structure to reflect the change */
        ring->avail += n_rx;
        n_free_slots -= n_rx;
    }

    return 0;
}

static inline int
rx_sync_if(uint32_t port)
{
    uint16_t burst;
    uint32_t i, rc;
    struct netmap_if *nifp;
    struct netmap_ring *r;

    nifp = ports[port].nmif;
    burst = ports[port].rx_burst;
    rc = 0;

    for (i = 0; i < nifp->ni_rx_rings + 1; i++) {
        r = NETMAP_RXRING(nifp, i);
        rx_sync_ring(r, port, (uint16_t)i, burst);
        rc += r->avail;
    }

    return rc;
}

static int
ioctl_niocrxsync(int fd)
{
    uint32_t idx, port;

    idx = FD_TO_IDX(fd);
    if ((port = fd_port[idx].port) < RTE_DIM(ports) &&
            ports[port].fd == idx) {
        return rx_sync_if(fd_port[idx].port);
    } else  {
        return -EINVAL;
    }
}

static int
tx_sync_ring(struct netmap_ring *ring, uint16_t port, uint16_t ring_number,
    struct rte_mempool *pool, uint16_t max_burst)
{
    uint32_t i, n_tx;
    uint16_t burst_size;
    uint32_t cur_slot, n_used_slots;
    struct rte_mbuf *tx_mbufs[COMPAT_NETMAP_MAX_BURST];

    n_used_slots = ring->num_slots - ring->avail;
    n_used_slots = RTE_MIN(n_used_slots, max_burst);
    cur_slot = (ring->cur + ring->avail) & (ring->num_slots - 1);

    while (n_used_slots) {
        burst_size = (uint16_t)RTE_MIN(n_used_slots, RTE_DIM(tx_mbufs));

        for (i = 0; i < burst_size; i++) {
            tx_mbufs[i] = rte_pktmbuf_alloc(pool);
            if (tx_mbufs[i] == NULL)
                goto err;

            slot_to_mbuf(ring, cur_slot, tx_mbufs[i]);
            cur_slot = NETMAP_RING_NEXT(ring, cur_slot);
        }

        n_tx = rte_eth_tx_burst(port, ring_number, tx_mbufs,
            burst_size);

        /* Update the Netmap ring structure to reflect the change */
        ring->avail += n_tx;
        n_used_slots -= n_tx;

        /* Return the mbufs that failed to transmit to their pool */
        if (unlikely(n_tx != burst_size)) {
            for (i = n_tx; i < burst_size; i++)
                rte_pktmbuf_free(tx_mbufs[i]);
                break;
        }
    }

    return 0;

err:
    for (; i == 0; --i)
        rte_pktmbuf_free(tx_mbufs[i]);

    RTE_LOG(ERR, USER1,
        "Couldn't get mbuf from mempool is the mempool too small?\n");
    return -1;
}

static int
tx_sync_if(uint32_t port)
{
    uint16_t burst;
    uint32_t i, rc;
    struct netmap_if *nifp;
    struct netmap_ring *r;
    struct rte_mempool *mp;

    nifp = ports[port].nmif;
    mp = ports[port].pool;
    burst = ports[port].tx_burst;
    rc = 0;

    for (i = 0; i < nifp->ni_tx_rings + 1; i++) {
        r = NETMAP_TXRING(nifp, i);
        tx_sync_ring(r, port, (uint16_t)i, mp, burst);
        rc += r->avail;
    }

    return rc;
}

static inline int
ioctl_nioctxsync(int fd)
{
    uint32_t idx, port;

    idx = FD_TO_IDX(fd);
    if ((port = fd_port[idx].port) < RTE_DIM(ports) &&
            ports[port].fd == idx) {
        return tx_sync_if(fd_port[idx].port);
    } else  {
        return -EINVAL;
    }
}

int
rte_netmap_init(const struct rte_netmap_conf *conf)
{
    size_t buf_ofs, nmif_sz, sz;
    size_t port_rings, port_slots, port_bufs;
    uint32_t i, port_num;

    port_num = RTE_MAX_ETHPORTS;
    port_rings = 2 * conf->max_rings;
    port_slots = port_rings * conf->max_slots;
    port_bufs = port_slots;

    nmif_sz = NETMAP_IF_RING_OFS(port_rings, port_rings, port_slots);
    sz = nmif_sz * port_num;

    buf_ofs = RTE_ALIGN_CEIL(sz, RTE_CACHE_LINE_SIZE);
    sz = buf_ofs + port_bufs * conf->max_bufsz * port_num;

    if (sz > UINT32_MAX ||
            (netmap.mem = rte_zmalloc_socket(__func__, sz,
            RTE_CACHE_LINE_SIZE, conf->socket_id)) == NULL) {
        RTE_LOG(ERR, USER1, "%s: failed to allocate %zu bytes\n",
            __func__, sz);
        return -ENOMEM;
    }

    netmap.mem_sz = sz;
    netmap.netif_memsz = nmif_sz;
    netmap.buf_start = (uintptr_t)netmap.mem + buf_ofs;
    netmap.conf = *conf;

    rte_spinlock_init(&netmap_lock);

    /* Mark all ports as unused and set NETIF pointer. */
    for (i = 0; i != RTE_DIM(ports); i++) {
        ports[i].fd = UINT32_MAX;
        ports[i].nmif = (struct netmap_if *)
            ((uintptr_t)netmap.mem + nmif_sz * i);
    }

    /* Mark all fd_ports as unused. */
    for (i = 0; i != RTE_DIM(fd_port); i++) {
        fd_port[i].port = FD_PORT_FREE;
    }

    return 0;
}


int
rte_netmap_init_port(uint16_t portid, const struct rte_netmap_port_conf *conf)
{
    int32_t ret;
    uint16_t i;
    uint16_t rx_slots, tx_slots;
    struct rte_eth_rxconf rxq_conf;
    struct rte_eth_txconf txq_conf;
    struct rte_eth_dev_info dev_info;

    if (conf == NULL ||
            portid >= RTE_DIM(ports) ||
            conf->nr_tx_rings > netmap.conf.max_rings ||
            conf->nr_rx_rings > netmap.conf.max_rings) {
        RTE_LOG(ERR, USER1, "%s(%u): invalid parameters\n",
            __func__, portid);
        return -EINVAL;
    }

    rx_slots = (uint16_t)rte_align32pow2(conf->nr_rx_slots);
    tx_slots = (uint16_t)rte_align32pow2(conf->nr_tx_slots);

    if (tx_slots > netmap.conf.max_slots ||
            rx_slots > netmap.conf.max_slots) {
        RTE_LOG(ERR, USER1, "%s(%u): invalid parameters\n",
            __func__, portid);
        return -EINVAL;
    }

    rte_eth_dev_info_get(portid, &dev_info);
    if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
        conf->eth_conf->txmode.offloads |=
            DEV_TX_OFFLOAD_MBUF_FAST_FREE;
    ret = rte_eth_dev_configure(portid, conf->nr_rx_rings,
        conf->nr_tx_rings, conf->eth_conf);

    if (ret < 0) {
        RTE_LOG(ERR, USER1, "Couldn't configure port %u\n", portid);
        return ret;
    }

    ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &rx_slots, &tx_slots);

    if (ret < 0) {
        RTE_LOG(ERR, USER1,
            "Couldn't ot adjust number of descriptors for port %u\n",
            portid);
        return ret;
    }

    rxq_conf = dev_info.default_rxconf;
    rxq_conf.offloads = conf->eth_conf->rxmode.offloads;
    txq_conf = dev_info.default_txconf;
    txq_conf.offloads = conf->eth_conf->txmode.offloads;
    for (i = 0; i < conf->nr_tx_rings; i++) {
        ret = rte_eth_tx_queue_setup(portid, i, tx_slots,
            conf->socket_id, &txq_conf);

        if (ret < 0) {
            RTE_LOG(ERR, USER1,
                "fail to configure TX queue %u of port %u\n",
                i, portid);
            return ret;
        }

        ret = rte_eth_rx_queue_setup(portid, i, rx_slots,
            conf->socket_id, &rxq_conf, conf->pool);

        if (ret < 0) {
            RTE_LOG(ERR, USER1,
                "fail to configure RX queue %u of port %u\n",
                i, portid);
            return ret;
        }
    }

    /* copy config to the private storage. */
    ports[portid].eth_conf = conf->eth_conf[0];
    ports[portid].pool = conf->pool;
    ports[portid].socket_id = conf->socket_id;
    ports[portid].nr_tx_rings = conf->nr_tx_rings;
    ports[portid].nr_rx_rings = conf->nr_rx_rings;
    ports[portid].nr_tx_slots = tx_slots;
    ports[portid].nr_rx_slots = rx_slots;
    ports[portid].tx_burst = conf->tx_burst;
    ports[portid].rx_burst = conf->rx_burst;

    return 0;
}

int
rte_netmap_close(__rte_unused int fd)
{
    int32_t rc;

    rte_spinlock_lock(&netmap_lock);
    rc = fd_release(fd);
    rte_spinlock_unlock(&netmap_lock);

    if (rc < 0) {
        errno =-rc;
        rc = -1;
    }
    return rc;
}

int rte_netmap_ioctl(int fd, uint32_t op, void *param)
{
    int ret;

    if (!FD_VALID(fd)) {
        errno = EBADF;
        return -1;
    }

    switch (op) {

        case NIOCGINFO:
            ret = ioctl_niocginfo(fd, param);
            break;

        case NIOCREGIF:
            ret = ioctl_niocregif(fd, param);
            break;

        case NIOCUNREGIF:
            ret = ioctl_niocunregif(fd);
            break;

        case NIOCRXSYNC:
            ret = ioctl_niocrxsync(fd);
            break;

        case NIOCTXSYNC:
            ret = ioctl_nioctxsync(fd);
            break;

        default:
            ret = -ENOTTY;
    }

    if (ret < 0) {
        errno = -ret;
        ret = -1;
    } else {
        ret = 0;
    }

    return ret;
}

void *
rte_netmap_mmap(void *addr, size_t length,
    int prot, int flags, int fd, off_t offset)
{
    static const int cprot = PROT_WRITE | PROT_READ;

    if (!FD_VALID(fd) || length + offset > netmap.mem_sz ||
            (prot & cprot) != cprot ||
            ((flags & MAP_FIXED) != 0 && addr != NULL)) {

        errno = EINVAL;
        return MAP_FAILED;
    }

    return (void *)((uintptr_t)netmap.mem + (uintptr_t)offset);
}

int
rte_netmap_open(__rte_unused const char *pathname, __rte_unused int flags)
{
    int fd;

    rte_spinlock_lock(&netmap_lock);
    fd = fd_reserve();
    rte_spinlock_unlock(&netmap_lock);

    if (fd < 0) {
        errno = -fd;
        fd = -1;
    }
    return fd;
}

int
rte_netmap_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
    int32_t count_it, ret;
    uint32_t i, idx, port;
    uint32_t want_rx, want_tx;

    if (timeout > 0)
        return -1;

    ret = 0;
    do {
        for (i = 0; i < nfds; i++) {

            count_it = 0;

            if (!FD_VALID(fds[i].fd) || fds[i].events == 0) {
                fds[i].revents = 0;
                continue;
            }

            idx = FD_TO_IDX(fds[i].fd);
            if ((port = fd_port[idx].port) >= RTE_DIM(ports) ||
        ports[port].fd != idx) {

                fds[i].revents |= POLLERR;
                ret++;
                continue;
            }

            want_rx = fds[i].events & (POLLIN  | POLLRDNORM);
            want_tx = fds[i].events & (POLLOUT | POLLWRNORM);

            if (want_rx && rx_sync_if(port) > 0) {
                fds[i].revents = (uint16_t)
                    (fds[i].revents | want_rx);
                count_it = 1;
            }
            if (want_tx && tx_sync_if(port) > 0) {
                fds[i].revents = (uint16_t)
                    (fds[i].revents | want_tx);
                count_it = 1;
            }

            ret += count_it;
        }
    }
    while ((ret == 0 && timeout < 0) || timeout);

    return ret;
}