d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bond: new link bonding library

Browse Source 
Initial release with support for
 Mode 0 - Round Robin
 Mode 1 - Active Backup
 Mode 2 - Balance -> Supports 3 transmit polices (layer 2, layer 2+3, layer 3+4)
 Mode 3 - Broadcast

Signed-off-by: Declan Doherty <declan.doherty@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Reviewed-by: Robert Sanford <rsanford2@gmail.com>
This commit is contained in:
Declan Doherty 2014-06-25 21:07:43 +01:00 committed by Thomas Monjalon
parent 6e81eb5af1
commit 2efb58cbab
12 changed files with 2678 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
config/common_bsdapp
View File

@ -205,6 +205,11 @@ CONFIG_RTE_PMD_RING_MAX_TX_RINGS=16
#
CONFIG_RTE_LIBRTE_PMD_PCAP=y
#
# Compile link bonding PMD library
#
CONFIG_RTE_LIBRTE_PMD_BOND=y
#
# Do prefetch of packet data within PMD driver receive function
#

5
config/common_linuxapp
View File

@ -243,6 +243,11 @@ CONFIG_RTE_PMD_RING_MAX_TX_RINGS=16
#
CONFIG_RTE_LIBRTE_PMD_PCAP=n
#
# Compile link bonding PMD library
#
CONFIG_RTE_LIBRTE_PMD_BOND=y
#
# Compile Xen PMD
#

1
doc/doxy-api-index.md
View File

@ -38,6 +38,7 @@ There are many libraries, so their headers may be grouped by topics:
- **device**:
[ethdev] (@ref rte_ethdev.h),
[devargs] (@ref rte_devargs.h),
[bond] (@ref rte_eth_bond.h),
[KNI] (@ref rte_kni.h),
[PCI] (@ref rte_pci.h),
[PCI IDs] (@ref rte_pci_dev_ids.h)

1
doc/doxy-api.conf
View File

@ -47,6 +47,7 @@ INPUT = doc/doxy-api-index.md \
lib/librte_pipeline \
lib/librte_port \
lib/librte_power \
lib/librte_pmd_bond \
lib/librte_ring \
lib/librte_sched \
lib/librte_table \

1
lib/Makefile
View File

@ -44,6 +44,7 @@ DIRS-$(CONFIG_RTE_LIBRTE_ETHER) += librte_ether
DIRS-$(CONFIG_RTE_LIBRTE_E1000_PMD) += librte_pmd_e1000
DIRS-$(CONFIG_RTE_LIBRTE_IXGBE_PMD) += librte_pmd_ixgbe
DIRS-$(CONFIG_RTE_LIBRTE_I40E_PMD) += librte_pmd_i40e
DIRS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += librte_pmd_bond
DIRS-$(CONFIG_RTE_LIBRTE_PMD_RING) += librte_pmd_ring
DIRS-$(CONFIG_RTE_LIBRTE_PMD_PCAP) += librte_pmd_pcap
DIRS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += librte_pmd_virtio

61
lib/librte_pmd_bond/Makefile Normal file
View File

@ -0,0 +1,61 @@
# BSD LICENSE
#
# Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Intel Corporation nor the names of its
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
include $(RTE_SDK)/mk/rte.vars.mk
#
# library name
#
LIB = librte_pmd_bond.a
CFLAGS += -O3
CFLAGS += $(WERROR_FLAGS)
#
# all source are stored in SRCS-y
#
SRCS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += rte_eth_bond_api.c
SRCS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += rte_eth_bond_pmd.c
SRCS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += rte_eth_bond_args.c
#
# Export include files
#
SYMLINK-y-include += rte_eth_bond.h
# this lib depends upon:
DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += lib/librte_mbuf
DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += lib/librte_ether
DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += lib/librte_malloc
DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += lib/librte_eal
DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_BOND) += lib/librte_kvargs
include $(RTE_SDK)/mk/rte.lib.mk

255
lib/librte_pmd_bond/rte_eth_bond.h Normal file
View File

@ -0,0 +1,255 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _RTE_ETH_BOND_H_
#define _RTE_ETH_BOND_H_
/**
* @file rte_bond.h
*
* RTE Link Bonding Ethernet Device
* Link Bonding for 1GbE and 10GbE ports to allow the aggregation of multiple
* (slave) NICs into a single logical interface. The bonded device processes
* these interfaces based on the mode of operation specified and supported.
* This implementation supports 4 modes of operation round robin, active backup
* balance and broadcast. Providing redundant links, fault tolerance and/or
* load balancing of network ports
*/
#ifdef __cplusplus
extern "C" {
#endif
#include <rte_ether.h>
/* Supported modes of operation of link bonding library */
#define BONDING_MODE_ROUND_ROBIN (0)
/**< Round Robin (Mode 0).
* In this mode all transmitted packets will be balanced equally across all
* active slaves of the bonded in a round robin fashion. */
#define BONDING_MODE_ACTIVE_BACKUP (1)
/**< Active Backup (Mode 1).
* In this mode all packets transmitted will be transmitted on the primary
* slave until such point as the primary slave is no longer available and then
* transmitted packets will be sent on the next available slaves. The primary
* slave can be defined by the user but defaults to the first active slave
* available if not specified. */
#define BONDING_MODE_BALANCE (2)
/**< Balance (Mode 2).
* In this mode all packets transmitted will be balanced across the available
* slaves using one of three available transmit policies - l2, l2+3 or l3+4.
* See BALANCE_XMIT_POLICY macros definitions for further details on transmit
* policies. */
#define BONDING_MODE_BROADCAST (3)
/**< Broadcast (Mode 3).
* In this mode all transmitted packets will be transmitted on all available
* active slaves of the bonded. */
/* Balance Mode Transmit Policies */
#define BALANCE_XMIT_POLICY_LAYER2 (0)
/**< Layer 2 (Ethernet MAC) */
#define BALANCE_XMIT_POLICY_LAYER23 (1)
/**< Layer 2+3 (Ethernet MAC + IP Addresses) transmit load balancing */
#define BALANCE_XMIT_POLICY_LAYER34 (2)
/**< Layer 3+4 (IP Addresses + UDP Ports) transmit load balancing */
/**
* Create a bonded rte_eth_dev device
*
* @param name Name of new link bonding device.
* @param mode Mode to initialize bonding device in.
* @param socket_id Socket Id on which to allocate eth_dev resources.
*
* @return
* Port Id of created rte_eth_dev on success, negative value otherwise
*/
int
rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id);
/**
* Add a rte_eth_dev device as a slave to the bonded device
*
* @param bonded_port_id Port ID of bonded device.
* @param slave_port_id Port ID of slave device.
*
* @return
* 0 on success, negative value otherwise
*/
int
rte_eth_bond_slave_add(uint8_t bonded_port_id, uint8_t slave_port_id);
/**
* Remove a slave rte_eth_dev device from the bonded device
*
* @param bonded_port_id Port ID of bonded device.
* @param slave_port_id Port ID of slave device.
*
* @return
* 0 on success, negative value otherwise
*/
int
rte_eth_bond_slave_remove(uint8_t bonded_port_id, uint8_t slave_port_id);
/**
* Set link bonding mode of bonded device
*
* @param bonded_port_id Port ID of bonded device.
* @param mode Bonding mode to set
*
* @return
* 0 on success, negative value otherwise
*/
int
rte_eth_bond_mode_set(uint8_t bonded_port_id, uint8_t mode);
/**
* Get link bonding mode of bonded device
*
* @param bonded_port_id Port ID of bonded device.
*
* @return
* link bonding mode on success, negative value otherwise
*/
int
rte_eth_bond_mode_get(uint8_t bonded_port_id);
/**
* Set slave rte_eth_dev as primary slave of bonded device
*
* @param bonded_port_id Port ID of bonded device.
* @param slave_port_id Port ID of slave device.
*
* @return
* 0 on success, negative value otherwise
*/
int
rte_eth_bond_primary_set(uint8_t bonded_port_id, uint8_t slave_port_id);
/**
* Get primary slave of bonded device
*
* @param bonded_port_id Port ID of bonded device.
*
* @return
* Port Id of primary slave on success, -1 on failure
*/
int
rte_eth_bond_primary_get(uint8_t bonded_port_id);
/**
* Populate an array with list of the slaves port id's of the bonded device
*
* @param bonded_port_id Port ID of bonded eth_dev to interrogate
* @param slaves Array to be populated with the current active slaves
* @param len Length of slaves array
*
* @return
* Number of slaves associated with bonded device on success,
* negative value otherwise
*/
int
rte_eth_bond_slaves_get(uint8_t bonded_port_id, uint8_t slaves[], uint8_t len);
/**
* Populate an array with list of the active slaves port id's of the bonded
* device.
*
* @param bonded_port_id Port ID of bonded eth_dev to interrogate
* @param slaves Array to be populated with the current active slaves
* @param len Length of slaves array
*
* @return
* Number of active slaves associated with bonded device on success,
* negative value otherwise
*/
int
rte_eth_bond_active_slaves_get(uint8_t bonded_port_id, uint8_t slaves[],
uint8_t len);
/**
* Set explicit MAC address to use on bonded device and it's slaves.
*
* @param bonded_port_id Port ID of bonded device.
* @param mac_addr MAC Address to use on bonded device overriding
* slaves MAC addresses
*
* @return
* 0 on success, negative value otherwise
*/
int
rte_eth_bond_mac_address_set(uint8_t bonded_port_id,
struct ether_addr *mac_addr);
/**
* Reset bonded device to use MAC from primary slave on bonded device and it's
* slaves.
*
* @param bonded_port_id Port ID of bonded device.
*
* @return
* 0 on success, negative value otherwise
*/
int
rte_eth_bond_mac_address_reset(uint8_t bonded_port_id);
/**
* Set the transmit policy for bonded device to use when it is operating in
* balance mode, this parameter is otherwise ignored in other modes of
* operation.
*
* @param bonded_port_id Port ID of bonded device.
* @param policy Balance mode transmission policy.
*
* @return
* 0 on success, negative value otherwise.
*/
int
rte_eth_bond_xmit_policy_set(uint8_t bonded_port_id, uint8_t policy);
/**
* Get the transmit policy set on bonded device for balance mode operation
*
* @param bonded_port_id Port ID of bonded device.
*
* @return
* Balance transmit policy on success, negative value otherwise.
*/
int
rte_eth_bond_xmit_policy_get(uint8_t bonded_port_id);
#ifdef __cplusplus
}
#endif
#endif

662
lib/librte_pmd_bond/rte_eth_bond_api.c Normal file
View File

@ -0,0 +1,662 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/queue.h>
#include <linux/binfmts.h>
#include <rte_mbuf.h>
#include <rte_cycles.h>
#include <rte_dev.h>
#include <rte_devargs.h>
#include <rte_ethdev.h>
#include <rte_ip.h>
#include <rte_kvargs.h>
#include <rte_malloc.h>
#include <rte_memcpy.h>
#include <rte_memory.h>
#include <rte_udp.h>
#include "rte_eth_bond.h"
#include "rte_eth_bond_private.h"
int
valid_bonded_ethdev(struct rte_eth_dev *eth_dev)
{
size_t len;
/* Check valid pointer */
if (eth_dev->driver->pci_drv.name == NULL || driver_name == NULL)
return -1;
/* Check string lengths are equal */
len = strlen(driver_name);
if (strlen(eth_dev->driver->pci_drv.name) != len)
return -1;
/* Compare strings */
return strncmp(eth_dev->driver->pci_drv.name, driver_name, len);
}
int
valid_port_id(uint8_t port_id)
{
/* Verify that port id is valid */
int ethdev_count = rte_eth_dev_count();
if (port_id >= ethdev_count) {
RTE_LOG(ERR, PMD,
"%s: port Id %d is greater than rte_eth_dev_count %d\n",
__func__, port_id, ethdev_count);
return -1;
}
return 0;
}
int
valid_bonded_port_id(uint8_t port_id)
{
/* Verify that port id's are valid */
if (valid_port_id(port_id))
return -1;
/* Verify that bonded_port_id refers to a bonded port */
if (valid_bonded_ethdev(&rte_eth_devices[port_id])) {
RTE_LOG(ERR, PMD,
"%s: Specified port Id %d is not a bonded eth_dev device\n",
__func__, port_id);
return -1;
}
return 0;
}
int
valid_slave_port_id(uint8_t port_id)
{
/* Verify that port id's are valid */
if (valid_port_id(port_id))
return -1;
/* Verify that port_id refers to a non bonded port */
if (!valid_bonded_ethdev(&rte_eth_devices[port_id]))
return -1;
return 0;
}
uint8_t
number_of_sockets(void)
{
int sockets = 0;
int i;
const struct rte_memseg *ms = rte_eal_get_physmem_layout();
for (i = 0; ((i < RTE_MAX_MEMSEG) && (ms[i].addr != NULL)); i++) {
if (sockets < ms[i].socket_id)
sockets = ms[i].socket_id;
}
/* Number of sockets = maximum socket_id + 1 */
return ++sockets;
}
const char *driver_name = "Link Bonding PMD";
int
rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
{
struct rte_pci_device *pci_dev = NULL;
struct bond_dev_private *internals = NULL;
struct rte_eth_dev *eth_dev = NULL;
struct eth_driver *eth_drv = NULL;
struct rte_pci_driver *pci_drv = NULL;
struct rte_pci_id *pci_id_table = NULL;
/* now do all data allocation - for eth_dev structure, dummy pci driver
* and internal (private) data
*/
if (name == NULL) {
RTE_LOG(ERR, PMD, "Invalid name specified\n");
goto err;
}
if (socket_id >= number_of_sockets()) {
RTE_LOG(ERR, PMD,
"%s: invalid socket id specified to create bonded device on.\n",
__func__);
goto err;
}
pci_dev = rte_zmalloc_socket(name, sizeof(*pci_dev), 0, socket_id);
if (pci_dev == NULL) {
RTE_LOG(ERR, PMD, "Unable to malloc pci dev on socket\n");
goto err;
}
eth_drv = rte_zmalloc_socket(name, sizeof(*eth_drv), 0, socket_id);
if (eth_drv == NULL) {
RTE_LOG(ERR, PMD, "Unable to malloc eth_drv on socket\n");
goto err;
}
pci_drv = rte_zmalloc_socket(name, sizeof(*pci_drv), 0, socket_id);
if (pci_drv == NULL) {
RTE_LOG(ERR, PMD, "Unable to malloc pci_drv on socket\n");
goto err;
}
pci_id_table = rte_zmalloc_socket(name, sizeof(*pci_id_table), 0, socket_id);
if (pci_drv == NULL) {
RTE_LOG(ERR, PMD, "Unable to malloc pci_id_table on socket\n");
goto err;
}
pci_drv->id_table = pci_id_table;
pci_drv->id_table->device_id = PCI_ANY_ID;
pci_drv->id_table->subsystem_device_id = PCI_ANY_ID;
pci_drv->id_table->vendor_id = PCI_ANY_ID;
pci_drv->id_table->subsystem_vendor_id = PCI_ANY_ID;
internals = rte_zmalloc_socket(name, sizeof(*internals), 0, socket_id);
if (internals == NULL) {
RTE_LOG(ERR, PMD, "Unable to malloc internals on socket\n");
goto err;
}
/* reserve an ethdev entry */
eth_dev = rte_eth_dev_allocate(name);
if (eth_dev == NULL) {
RTE_LOG(ERR, PMD, "Unable to allocate rte_eth_dev\n");
goto err;
}
pci_dev->numa_node = socket_id;
pci_drv->name = driver_name;
eth_drv->pci_drv = (struct rte_pci_driver)(*pci_drv);
eth_dev->driver = eth_drv;
eth_dev->data->dev_private = internals;
eth_dev->data->nb_rx_queues = (uint16_t)1;
eth_dev->data->nb_tx_queues = (uint16_t)1;
eth_dev->data->dev_link.link_status = 0;
eth_dev->data->mac_addrs = rte_zmalloc_socket(name, ETHER_ADDR_LEN, 0,
socket_id);
eth_dev->data->dev_started = 0;
eth_dev->data->promiscuous = 0;
eth_dev->data->scattered_rx = 0;
eth_dev->data->all_multicast = 0;
eth_dev->dev_ops = &default_dev_ops;
eth_dev->pci_dev = pci_dev;
if (bond_ethdev_mode_set(eth_dev, mode)) {
RTE_LOG(ERR, PMD,
"%s: failed to set bonded device %d mode too %d\n",
__func__, eth_dev->data->port_id, mode);
goto err;
}
internals->current_primary_port = 0;
internals->balance_xmit_policy = BALANCE_XMIT_POLICY_LAYER2;
internals->user_defined_mac = 0;
internals->link_props_set = 0;
internals->slave_count = 0;
internals->active_slave_count = 0;
memset(internals->active_slaves, 0, sizeof(internals->active_slaves));
memset(internals->slaves, 0, sizeof(internals->slaves));
memset(internals->presisted_slaves_conf, 0,
sizeof(internals->presisted_slaves_conf));
return eth_dev->data->port_id;
err:
if (pci_dev)
rte_free(pci_dev);
if (pci_drv)
rte_free(pci_drv);
if (pci_id_table)
rte_free(pci_id_table);
if (eth_drv)
rte_free(eth_drv);
if (internals)
rte_free(internals);
return -1;
}
int
rte_eth_bond_slave_add(uint8_t bonded_port_id, uint8_t slave_port_id)
{
struct rte_eth_dev *bonded_eth_dev, *slave_eth_dev;
struct bond_dev_private *internals;
struct bond_dev_private *temp_internals;
struct rte_eth_link link_props;
int i, j;
/* Verify that port id's are valid bonded and slave ports */
if (valid_bonded_port_id(bonded_port_id) != 0)
goto err_add;
if (valid_slave_port_id(slave_port_id) != 0)
goto err_add;
/*
* Verify that new slave device is not already a slave of another bonded
* device */
for (i = rte_eth_dev_count()-1; i >= 0; i--) {
if (valid_bonded_ethdev(&rte_eth_devices[i]) == 0) {
temp_internals = rte_eth_devices[i].data->dev_private;
for (j = 0; j < temp_internals->slave_count; j++) {
/* Device already a slave of a bonded device */
if (temp_internals->slaves[j] == slave_port_id)
goto err_add;
}
}
}
bonded_eth_dev = &rte_eth_devices[bonded_port_id];
internals = bonded_eth_dev->data->dev_private;
slave_eth_dev = &rte_eth_devices[slave_port_id];
if (internals->slave_count > 0) {
/* Check that new slave device is the same type as the other slaves
* and not repetitive */
for (i = 0; i < internals->slave_count; i++) {
if (slave_eth_dev->pci_dev->driver->id_table->device_id !=
rte_eth_devices[internals->slaves[i]].pci_dev->driver->id_table->device_id ||
internals->slaves[i] == slave_port_id)
goto err_add;
}
}
/* Add slave details to bonded device */
internals->slaves[internals->slave_count] = slave_port_id;
slave_config_store(internals, slave_eth_dev);
if (internals->slave_count < 1) {
/* if MAC is not user defined then use MAC of first slave add to bonded
* device */
if (!internals->user_defined_mac)
mac_address_set(bonded_eth_dev, slave_eth_dev->data->mac_addrs);
/* Inherit eth dev link properties from first slave */
link_properties_set(bonded_eth_dev, &(slave_eth_dev->data->dev_link));
/* Make primary slave */
internals->primary_port = slave_port_id;
} else {
/* Check slave link properties are supported if props are set,
* all slaves must be the same */
if (internals->link_props_set) {
if (link_properties_valid(&(bonded_eth_dev->data->dev_link),
&(slave_eth_dev->data->dev_link))) {
RTE_LOG(ERR, PMD,
"%s: Slave port %d link speed/duplex not supported\n",
__func__, slave_port_id);
goto err_add;
}
} else {
link_properties_set(bonded_eth_dev,
&(slave_eth_dev->data->dev_link));
}
}
internals->slave_count++;
/* Update all slave devices MACs*/
mac_address_slaves_update(bonded_eth_dev);
if (bonded_eth_dev->data->dev_started) {
if (slave_configure(bonded_eth_dev, slave_eth_dev) != 0) {
RTE_LOG(ERR, PMD, "rte_bond_slaves_configure: port=%d\n",
slave_port_id);
goto err_add;
}
}
/* Register link status change callback with bonded device pointer as
* argument*/
rte_eth_dev_callback_register(slave_port_id, RTE_ETH_EVENT_INTR_LSC,
bond_ethdev_lsc_event_callback, &bonded_eth_dev->data->port_id);
/* If bonded device is started then we can add the slave to our active
* slave array */
if (bonded_eth_dev->data->dev_started) {
rte_eth_link_get_nowait(slave_port_id, &link_props);
if (link_props.link_status == 1) {
internals->active_slaves[internals->active_slave_count++] =
slave_port_id;
}
}
return 0;
err_add:
RTE_LOG(ERR, PMD, "Failed to add port %d as slave\n", slave_port_id);
return -1;
}
int
rte_eth_bond_slave_remove(uint8_t bonded_port_id, uint8_t slave_port_id)
{
struct bond_dev_private *internals;
struct slave_conf *slave_conf;
int i;
int pos = -1;
/* Verify that port id's are valid bonded and slave ports */
if (valid_bonded_port_id(bonded_port_id) != 0)
goto err_del;
if (valid_slave_port_id(slave_port_id) != 0)
goto err_del;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
/* first remove from active slave list */
for (i = 0; i < internals->active_slave_count; i++) {
if (internals->active_slaves[i] == slave_port_id)
pos = i;
/* shift active slaves up active array list */
if (pos >= 0 && i < (internals->active_slave_count - 1))
internals->active_slaves[i] = internals->active_slaves[i+1];
}
if (pos >= 0)
internals->active_slave_count--;
pos = -1;
/* now remove from slave list */
for (i = 0; i < internals->slave_count; i++) {
if (internals->slaves[i] == slave_port_id)
pos = i;
/* shift slaves up list */
if (pos >= 0 && i < internals->slave_count)
internals->slaves[i] = internals->slaves[i+1];
}
if (pos < 0)
goto err_del;
/* Un-register link status change callback with bonded device pointer as
* argument*/
rte_eth_dev_callback_unregister(slave_port_id, RTE_ETH_EVENT_INTR_LSC,
bond_ethdev_lsc_event_callback,
&rte_eth_devices[bonded_port_id].data->port_id);
/* Restore original MAC address of slave device */
slave_conf = slave_config_get(internals, slave_port_id);
mac_address_set(&rte_eth_devices[slave_port_id], &(slave_conf->mac_addr));
slave_config_clear(internals, &rte_eth_devices[slave_port_id]);
internals->slave_count--;
/* first slave in the active list will be the primary by default,
* otherwise use first device in list */
if (internals->current_primary_port == slave_port_id) {
if (internals->active_slave_count > 0)
internals->current_primary_port = internals->active_slaves[0];
else if (internals->slave_count > 0)
internals->current_primary_port = internals->slaves[0];
else
internals->primary_port = 0;
}
if (internals->active_slave_count < 1) {
/* reset device link properties as no slaves are active */
link_properties_reset(&rte_eth_devices[bonded_port_id]);
/* if no slaves are any longer attached to bonded device and MAC is not
* user defined then clear MAC of bonded device as it will be reset
* when a new slave is added */
if (internals->slave_count < 1 && !internals->user_defined_mac)
memset(rte_eth_devices[bonded_port_id].data->mac_addrs, 0,
sizeof(*(rte_eth_devices[bonded_port_id].data->mac_addrs)));
}
return 0;
err_del:
RTE_LOG(ERR, PMD,
"Cannot remove slave device (not present in bonded device)\n");
return -1;
}
int
rte_eth_bond_mode_set(uint8_t bonded_port_id, uint8_t mode)
{
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
return bond_ethdev_mode_set(&rte_eth_devices[bonded_port_id], mode);
}
int
rte_eth_bond_mode_get(uint8_t bonded_port_id)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
return internals->mode;
}
int
rte_eth_bond_primary_set(uint8_t bonded_port_id, uint8_t slave_port_id)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
if (valid_slave_port_id(slave_port_id) != 0)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
internals->user_defined_primary_port = 1;
internals->primary_port = slave_port_id;
bond_ethdev_primary_set(internals, slave_port_id);
return 0;
}
int
rte_eth_bond_primary_get(uint8_t bonded_port_id)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
if (internals->slave_count < 1)
return -1;
return internals->current_primary_port;
}
int
rte_eth_bond_slaves_get(uint8_t bonded_port_id, uint8_t slaves[], uint8_t len)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
if (slaves == NULL)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
if (internals->slave_count > len)
return -1;
memcpy(slaves, internals->slaves, internals->slave_count);
return internals->slave_count;
}
int
rte_eth_bond_active_slaves_get(uint8_t bonded_port_id, uint8_t slaves[],
uint8_t len)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
if (slaves == NULL)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
if (internals->active_slave_count > len)
return -1;
memcpy(slaves, internals->active_slaves, internals->active_slave_count);
return internals->active_slave_count;
}
int
rte_eth_bond_mac_address_set(uint8_t bonded_port_id,
struct ether_addr *mac_addr)
{
struct rte_eth_dev *bonded_eth_dev;
struct bond_dev_private *internals;
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;
/* Set MAC Address of Bonded Device */
if (mac_address_set(bonded_eth_dev, mac_addr))
return -1;
internals->user_defined_mac = 1;
/* Update all slave devices MACs*/
if (internals->slave_count > 0)
return mac_address_slaves_update(bonded_eth_dev);
return 0;
}
int
rte_eth_bond_mac_address_reset(uint8_t bonded_port_id)
{
struct rte_eth_dev *bonded_eth_dev;
struct bond_dev_private *internals;
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;
internals->user_defined_mac = 0;
if (internals->slave_count > 0) {
struct slave_conf *conf;
conf = slave_config_get(internals, internals->primary_port);
/* Set MAC Address of Bonded Device */
if (mac_address_set(bonded_eth_dev, &conf->mac_addr) != 0)
return -1;
/* Update all slave devices MAC addresses */
return mac_address_slaves_update(bonded_eth_dev);
}
/* No need to update anything as no slaves present */
return 0;
}
int
rte_eth_bond_xmit_policy_set(uint8_t bonded_port_id, uint8_t policy)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
switch (policy) {
case BALANCE_XMIT_POLICY_LAYER2:
case BALANCE_XMIT_POLICY_LAYER23:
case BALANCE_XMIT_POLICY_LAYER34:
internals->balance_xmit_policy = policy;
break;
default:
return -1;
}
return 0;
}
int
rte_eth_bond_xmit_policy_get(uint8_t bonded_port_id)
{
struct bond_dev_private *internals;
if (valid_bonded_port_id(bonded_port_id) != 0)
return -1;
internals = rte_eth_devices[bonded_port_id].data->dev_private;
return internals->balance_xmit_policy;
}

252
lib/librte_pmd_bond/rte_eth_bond_args.c Normal file
View File

@ -0,0 +1,252 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <rte_devargs.h>
#include <rte_kvargs.h>
#include <cmdline_parse.h>
#include <cmdline_parse_etheraddr.h>
#include "rte_eth_bond.h"
#include "rte_eth_bond_private.h"
const char *pmd_bond_init_valid_arguments[] = {
PMD_BOND_SLAVE_PORT_KVARG,
PMD_BOND_PRIMARY_SLAVE_KVARG,
PMD_BOND_MODE_KVARG,
PMD_BOND_XMIT_POLICY_KVARG,
PMD_BOND_SOCKET_ID_KVARG,
PMD_BOND_MAC_ADDR_KVARG,
NULL
};
static inline int
find_port_id_by_pci_addr(const struct rte_pci_addr *pci_addr)
{
struct rte_pci_addr *eth_pci_addr;
unsigned i;
for (i = 0; i < rte_eth_dev_count(); i++) {
if (rte_eth_devices[i].pci_dev == NULL)
continue;
eth_pci_addr = &(rte_eth_devices[i].pci_dev->addr);
if (pci_addr->bus == eth_pci_addr->bus &&
pci_addr->devid == eth_pci_addr->devid &&
pci_addr->domain == eth_pci_addr->domain &&
pci_addr->function == eth_pci_addr->function)
return i;
}
return -1;
}
static inline int
find_port_id_by_dev_name(const char *name)
{
unsigned i;
for (i = 0; i < rte_eth_dev_count(); i++) {
if (rte_eth_devices[i].data == NULL)
continue;
if (strcmp(rte_eth_devices[i].data->name, name) == 0)
return i;
}
return -1;
}
/**
* Parses a port identifier string to a port id by pci address, then by name,
* and finally port id.
*/
static inline int
parse_port_id(const char *port_str)
{
struct rte_pci_addr dev_addr;
int port_id;
/* try parsing as pci address, physical devices */
if (eal_parse_pci_DomBDF(port_str, &dev_addr) == 0) {
port_id = find_port_id_by_pci_addr(&dev_addr);
if (port_id < 0)
return -1;
} else {
/* try parsing as device name, virtual devices */
port_id = find_port_id_by_dev_name(port_str);
if (port_id < 0) {
char *end;
errno = 0;
/* try parsing as port id */
port_id = strtol(port_str, &end, 10);
if (*end != 0 || errno != 0)
return -1;
}
}
if (port_id < 0 || port_id > RTE_MAX_ETHPORTS) {
RTE_LOG(ERR, PMD, "Invalid slave port value (%s) specified.\n",
port_str);
return -1;
}
return port_id;
}
int
bond_ethdev_parse_slave_port_kvarg(const char *key __rte_unused,
const char *value, void *extra_args)
{
struct bond_ethdev_slave_ports *slave_ports;
if (value == NULL || extra_args == NULL)
return -1;
slave_ports = extra_args;
if (strcmp(key, PMD_BOND_SLAVE_PORT_KVARG) == 0) {
int port_id = parse_port_id(value);
if (port_id < 0)
return -1;
else
slave_ports->slaves[slave_ports->slave_count++] =
(uint8_t)port_id;
}
return 0;
}
int
bond_ethdev_parse_slave_mode_kvarg(const char *key __rte_unused,
const char *value, void *extra_args)
{
uint8_t *mode;
char *endptr;
if (value == NULL || extra_args == NULL)
return -1;
mode = extra_args;
errno = 0;
*mode = strtol(value, &endptr, 10);
if (*endptr != 0 || errno != 0)
return -1;
/* validate mode value */
switch (*mode) {
case BONDING_MODE_ROUND_ROBIN:
case BONDING_MODE_ACTIVE_BACKUP:
case BONDING_MODE_BALANCE:
case BONDING_MODE_BROADCAST:
return 0;
default:
return -1;
}
}
int
bond_ethdev_parse_socket_id_kvarg(const char *key __rte_unused,
const char *value, void *extra_args)
{
int socket_id;
char *endptr;
if (value == NULL || extra_args == NULL)
return -1;
errno = 0;
socket_id = (uint8_t)strtol(value, &endptr, 10);
if (*endptr != 0 || errno != 0)
return -1;
/* validate mode value */
if (socket_id >= 0 && socket_id < number_of_sockets()) {
*(uint8_t *)extra_args = (uint8_t)socket_id;
return 0;
}
return -1;
}
int
bond_ethdev_parse_primary_slave_port_id_kvarg(const char *key __rte_unused,
const char *value, void *extra_args)
{
int primary_slave_port_id;
if (value == NULL || extra_args == NULL)
return -1;
primary_slave_port_id = parse_port_id(value);
if (primary_slave_port_id < 0)
return -1;
*(uint8_t *)extra_args = (uint8_t)primary_slave_port_id;
return 0;
}
int
bond_ethdev_parse_balance_xmit_policy_kvarg(const char *key __rte_unused,
const char *value, void *extra_args)
{
uint8_t *xmit_policy;
if (value == NULL || extra_args == NULL)
return -1;
xmit_policy = extra_args;
if (strcmp(PMD_BOND_XMIT_POLICY_LAYER2_KVARG, value) == 0)
*xmit_policy = BALANCE_XMIT_POLICY_LAYER2;
else if (strcmp(PMD_BOND_XMIT_POLICY_LAYER23_KVARG, value) == 0)
*xmit_policy = BALANCE_XMIT_POLICY_LAYER23;
else if (strcmp(PMD_BOND_XMIT_POLICY_LAYER34_KVARG, value) == 0)
*xmit_policy = BALANCE_XMIT_POLICY_LAYER34;
else
return -1;
return 0;
}
int
bond_ethdev_parse_bond_mac_addr_kvarg(const char *key __rte_unused,
const char *value, void *extra_args)
{
if (value == NULL || extra_args == NULL)
return -1;
/* Parse MAC */
return cmdline_parse_etheraddr(NULL, value, extra_args);
}

1214
lib/librte_pmd_bond/rte_eth_bond_pmd.c Normal file
View File

File diff suppressed because it is too large Load Diff

215
lib/librte_pmd_bond/rte_eth_bond_private.h Normal file
View File

@ -0,0 +1,215 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _RTE_ETH_BOND_PRIVATE_H_
#define _RTE_ETH_BOND_PRIVATE_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <rte_ethdev.h>
#include "rte_eth_bond.h"
#define PMD_BOND_SLAVE_PORT_KVARG ("slave")
#define PMD_BOND_PRIMARY_SLAVE_KVARG ("primary")
#define PMD_BOND_MODE_KVARG ("mode")
#define PMD_BOND_XMIT_POLICY_KVARG ("xmit_policy")
#define PMD_BOND_SOCKET_ID_KVARG ("socket_id")
#define PMD_BOND_MAC_ADDR_KVARG ("mac")
#define PMD_BOND_XMIT_POLICY_LAYER2_KVARG ("l2")
#define PMD_BOND_XMIT_POLICY_LAYER23_KVARG ("l23")
#define PMD_BOND_XMIT_POLICY_LAYER34_KVARG ("l34")
extern const char *pmd_bond_init_valid_arguments[];
extern const char *driver_name;
/** Port Queue Mapping Structure */
struct bond_rx_queue {
int queue_id;
/**< Queue Id */
struct bond_dev_private *dev_private;
/**< Reference to eth_dev private structure */
uint16_t nb_rx_desc;
/**< Number of RX descriptors available for the queue */
struct rte_eth_rxconf rx_conf;
/**< Copy of RX configuration structure for queue */
struct rte_mempool *mb_pool;
/**< Reference to mbuf pool to use for RX queue */
};
struct bond_tx_queue {
int queue_id;
/**< Queue Id */
struct bond_dev_private *dev_private;
/**< Reference to dev private structure */
uint16_t nb_tx_desc;
/**< Number of TX descriptors available for the queue */
struct rte_eth_txconf tx_conf;
/**< Copy of TX configuration structure for queue */
};
/** Persisted Slave Configuration Structure */
struct slave_conf {
uint8_t port_id;
/**< Port Id of slave eth_dev */
struct ether_addr mac_addr;
/**< Slave eth_dev original MAC address */
};
/** Bonded slave devices structure */
struct bond_ethdev_slave_ports {
uint8_t slaves[RTE_MAX_ETHPORTS]; /**< Slave port id array */
uint8_t slave_count; /**< Number of slaves */
};
/** Link Bonding PMD device private configuration Structure */
struct bond_dev_private {
uint8_t mode; /**< Link Bonding Mode */
uint8_t primary_port; /**< Primary Slave Port */
uint8_t current_primary_port; /**< Primary Slave Port */
uint8_t user_defined_primary_port;
/**< Flag for whether primary port is user defined or not */
uint8_t balance_xmit_policy;
/**< Transmit policy - l2 / l23 / l34 for operation in balance mode */
uint8_t user_defined_mac;
/**< Flag for whether MAC address is user defined or not */
uint8_t promiscuous_en;
/**< Enabled/disable promiscuous mode on slave devices */
uint8_t link_props_set;
/**< Bonded eth_dev link properties set */
uint16_t nb_rx_queues; /**< Total number of rx queues */
uint16_t nb_tx_queues; /**< Total number of tx queues*/
uint8_t slave_count; /**< Number of active slaves */
uint8_t active_slave_count; /**< Number of slaves */
uint8_t active_slaves[RTE_MAX_ETHPORTS]; /**< Active slave list */
uint8_t slaves[RTE_MAX_ETHPORTS]; /**< Slave list */
/** Persisted configuration of slaves */
struct slave_conf presisted_slaves_conf[RTE_MAX_ETHPORTS];
};
extern struct eth_dev_ops default_dev_ops;
int
valid_bonded_ethdev(struct rte_eth_dev *eth_dev);
int
valid_port_id(uint8_t port_id);
int
valid_bonded_port_id(uint8_t port_id);
int
valid_slave_port_id(uint8_t port_id);
void
link_properties_set(struct rte_eth_dev *bonded_eth_dev,
struct rte_eth_link *slave_dev_link);
void
link_properties_reset(struct rte_eth_dev *bonded_eth_dev);
int
link_properties_valid(struct rte_eth_link *bonded_dev_link,
struct rte_eth_link *slave_dev_link);
int
mac_address_set(struct rte_eth_dev *eth_dev, struct ether_addr *new_mac_addr);
int
mac_address_slaves_update(struct rte_eth_dev *bonded_eth_dev);
uint8_t
number_of_sockets(void);
int
bond_ethdev_mode_set(struct rte_eth_dev *eth_dev, int mode);
int
slave_configure(struct rte_eth_dev *bonded_eth_dev,
struct rte_eth_dev *slave_eth_dev);
void
slave_config_clear(struct bond_dev_private *internals,
struct rte_eth_dev *slave_eth_dev);
void
slave_config_store(struct bond_dev_private *internals,
struct rte_eth_dev *slave_eth_dev);
struct slave_conf *
slave_config_get(struct bond_dev_private *internals, uint8_t slave_port_id);
void
bond_ethdev_primary_set(struct bond_dev_private *internals,
uint8_t slave_port_id);
void
bond_ethdev_lsc_event_callback(uint8_t port_id, enum rte_eth_event_type type,
void *param);
int
bond_ethdev_parse_slave_port_kvarg(const char *key __rte_unused,
const char *value, void *extra_args);
int
bond_ethdev_parse_slave_mode_kvarg(const char *key __rte_unused,
const char *value, void *extra_args);
int
bond_ethdev_parse_socket_id_kvarg(const char *key __rte_unused,
const char *value, void *extra_args);
int
bond_ethdev_parse_primary_slave_port_id_kvarg(const char *key __rte_unused,
const char *value, void *extra_args);
int
bond_ethdev_parse_balance_xmit_policy_kvarg(const char *key __rte_unused,
const char *value, void *extra_args);
int
bond_ethdev_parse_bond_mac_addr_kvarg(const char *key __rte_unused,
const char *value, void *extra_args);
#ifdef __cplusplus
}
#endif
#endif

7
mk/rte.app.mk
View File

@ -170,12 +170,17 @@ ifeq ($(CONFIG_RTE_LIBRTE_CFGFILE),y)
LDLIBS += -lrte_cfgfile
endif
ifeq ($(CONFIG_RTE_LIBRTE_PMD_BOND),y)
LDLIBS += -lrte_pmd_bond
endif
ifeq ($(CONFIG_RTE_LIBRTE_PMD_XENVIRT),y)
LDLIBS += -lrte_pmd_xenvirt
LDLIBS += -lxenstore
endif
ifeq ($(CONFIG_RTE_BUILD_SHARED_LIB),n)
# plugins (link only if static libraries)
ifeq ($(CONFIG_RTE_LIBRTE_VMXNET3_PMD),y)
LDLIBS += -lrte_pmd_vmxnet3_uio
@ -205,7 +210,7 @@ ifeq ($(CONFIG_RTE_LIBRTE_PMD_PCAP),y)
LDLIBS += -lrte_pmd_pcap -lpcap
endif
endif
endif # plugins
LDLIBS += $(EXECENV_LDLIBS)