标签：slave burst rx dev eth bond dpdk

bond_ethdev_mode_set(struct rte_eth_dev *eth_dev, int mode)
{
        struct bond_dev_private *internals;

        internals = eth_dev->data->dev_private;

        switch (mode) {
        case BONDING_MODE_ROUND_ROBIN:
                eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_round_robin;
                eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
                break;
        case BONDING_MODE_ACTIVE_BACKUP:
                eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_active_backup;
                eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_active_backup;
                break;
        case BONDING_MODE_BALANCE:
                eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_balance;
                eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
                break;
        case BONDING_MODE_BROADCAST:
                eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_broadcast;
                eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
                break;
        case BONDING_MODE_8023AD:
                if (bond_mode_8023ad_enable(eth_dev) != 0)
                        return -1;

                if (internals->mode4.dedicated_queues.enabled == 0) {
                        eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_8023ad;
                        eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_8023ad;
                        RTE_BOND_LOG(WARNING,
                                "Using mode 4, it is necessary to do TX burst "
                                "and RX burst at least every 100ms.");
                } else {
                        /* Use flow director's optimization */
                        eth_dev->rx_pkt_burst =
                                        bond_ethdev_rx_burst_8023ad_fast_queue;
                        eth_dev->tx_pkt_burst =
                                        bond_ethdev_tx_burst_8023ad_fast_queue;
                }
                break;
        case BONDING_MODE_TLB:
                eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_tlb;
                eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_active_backup;
                break;
        case BONDING_MODE_ALB:
                if (bond_mode_alb_enable(eth_dev) != 0)
                        return -1;

                eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_alb;
                eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_alb;
                break;
        default:
                return -1;
        }

        internals->mode = mode;

        return 0;
}

bond_ethdev_rx_burst

static uint16_t
bond_ethdev_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
{
        struct bond_dev_private *internals;

        uint16_t num_rx_total = 0;
        uint16_t slave_count;
        uint16_t active_slave;
        int i;

        /* Cast to structure, containing bonded device's port id and queue id */
        struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
        internals = bd_rx_q->dev_private;
        slave_count = internals->active_slave_count;
        active_slave = internals->active_slave;

        for (i = 0; i < slave_count && nb_pkts; i++) {
                uint16_t num_rx_slave;

                /* Offset of pointer to *bufs increases as packets are received
                 * from other slaves */
                num_rx_slave =
                        rte_eth_rx_burst(internals->active_slaves[active_slave],
                                         bd_rx_q->queue_id,
                                         bufs + num_rx_total, nb_pkts);
                num_rx_total += num_rx_slave;
                nb_pkts -= num_rx_slave;
                if (++active_slave == slave_count)
                        active_slave = 0;
        }

        if (++internals->active_slave >= slave_count)
                internals->active_slave = 0;
        return num_rx_total;
}

rte_eth_bond_slave_add

rte_eth_bond_slave_add(uint16_t bonded_port_id, uint16_t slave_port_id)
{
        struct rte_eth_dev *bonded_eth_dev;
        struct bond_dev_private *internals;

        int retval;

        /* Verify that port id's are valid bonded and slave ports */
        if (valid_bonded_port_id(bonded_port_id) != 0)
                return -1;

        bonded_eth_dev = &rte_eth_devices[bonded_port_id];
        internals = bonded_eth_dev->data->dev_private;

        rte_spinlock_lock(&internals->lock);

        retval = __eth_bond_slave_add_lock_free(bonded_port_id, slave_port_id);

        rte_spinlock_unlock(&internals->lock);

        return retval;
}

标签：slave,burst,rx,dev,eth,bond,dpdk
来源： https://www.cnblogs.com/dream397/p/14870529.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。