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

kni: identify device by name

Browse Source 
Some old API functions based on port_id are deprecated.

Signed-off-by: Intel
This commit is contained in:
Intel 2013-09-18 12:00:00 +02:00 committed by Thomas Monjalon
parent 0b44a857c8
commit fbf895d44c
6 changed files with 212 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/librte_eal/linuxapp/eal/include/exec-env/rte_kni_common.h
View File

@ -63,6 +63,11 @@
#include <linux/if.h>
#endif
/**
* KNI name is part of memzone name.
*/
#define RTE_KNI_NAMESIZE 32
/*
* Request id.
*/
@ -118,9 +123,8 @@ struct rte_kni_mbuf {
* Struct used to create a KNI device. Passed to the kernel in IOCTL call
*/
struct rte_kni_device_info
{
char name[IFNAMSIZ];
struct rte_kni_device_info {
char name[RTE_KNI_NAMESIZE]; /**< Network device name for KNI */
phys_addr_t tx_phys;
phys_addr_t rx_phys;
@ -143,7 +147,11 @@ struct rte_kni_device_info
uint8_t bus; /**< Device bus */
uint8_t devid; /**< Device ID */
uint8_t function; /**< Device function. */
uint8_t port_id; /**< Port ID */
uint16_t group_id; /**< Group ID */
uint32_t core_id; /**< core ID to bind for kernel thread */
uint8_t force_bind : 1; /**< Flag for kernel thread binding */
/* mbuf size */
unsigned mbuf_size;
@ -153,6 +161,6 @@ struct rte_kni_device_info
#define RTE_KNI_IOCTL_TEST _IOWR(0, 1, int)
#define RTE_KNI_IOCTL_CREATE _IOWR(0, 2, struct rte_kni_device_info)
#define RTE_KNI_IOCTL_RELEASE _IOWR(0, 3, uint8_t)
#define RTE_KNI_IOCTL_RELEASE _IOWR(0, 3, struct rte_kni_device_info)
#endif /* _RTE_KNI_COMMON_H_ */

4
lib/librte_eal/linuxapp/kni/kni_dev.h
View File

@ -32,6 +32,7 @@
#include <linux/spinlock.h>
#include <linux/list.h>
#include <exec-env/rte_kni_common.h>
#define KNI_KTHREAD_RESCHEDULE_INTERVAL 10 /* us */
/**
@ -44,7 +45,8 @@ struct kni_dev {
struct net_device_stats stats;
int status;
int port_id;
uint16_t group_id; /* Group ID of a group of KNI devices */
char name[RTE_KNI_NAMESIZE]; /* Network device name */
/* wait queue for req/resp */
wait_queue_head_t wq;

38
lib/librte_eal/linuxapp/kni/kni_misc.c
View File

@ -199,6 +199,21 @@ kni_thread(void *unused)
return 0;
}
static int
kni_check_param(struct kni_dev *kni, struct rte_kni_device_info *dev)
{
if (!kni || !dev)
return -1;
/* Check if network name has been used */
if (!strncmp(kni->name, dev->name, RTE_KNI_NAMESIZE)) {
KNI_ERR("KNI name %s duplicated\n", dev->name);
return -1;
}
return 0;
}
static int
kni_ioctl_create(unsigned int ioctl_num, unsigned long ioctl_param)
{
@ -225,10 +240,8 @@ kni_ioctl_create(unsigned int ioctl_num, unsigned long ioctl_param)
/* Check if it has been created */
down_read(&kni_list_lock);
list_for_each_entry_safe(dev, n, &kni_list_head, list) {
if (dev->port_id == dev_info.port_id) {
if (kni_check_param(dev, &dev_info) < 0) {
up_read(&kni_list_lock);
KNI_ERR("Port %d has already been created\n",
dev_info.port_id);
return -EINVAL;
}
}
@ -244,7 +257,8 @@ kni_ioctl_create(unsigned int ioctl_num, unsigned long ioctl_param)
kni = netdev_priv(net_dev);
kni->net_dev = net_dev;
kni->port_id = dev_info.port_id;
kni->group_id = dev_info.group_id;
strncpy(kni->name, dev_info.name, RTE_KNI_NAMESIZE);
/* Translate user space info into kernel space info */
kni->tx_q = phys_to_virt(dev_info.tx_phys);
@ -353,21 +367,25 @@ static int
kni_ioctl_release(unsigned int ioctl_num, unsigned long ioctl_param)
{
int ret = -EINVAL;
uint8_t port_id;
struct kni_dev *dev, *n;
struct rte_kni_device_info dev_info;
if (_IOC_SIZE(ioctl_num) > sizeof(port_id))
if (_IOC_SIZE(ioctl_num) > sizeof(dev_info))
return -EINVAL;
ret = copy_from_user(&port_id, (void *)ioctl_param, sizeof(port_id));
ret = copy_from_user(&dev_info, (void *)ioctl_param, sizeof(dev_info));
if (ret) {
KNI_ERR("copy_from_user in kni_ioctl_release");
return -EIO;
}
/* Release the network device according to its name */
if (strlen(dev_info.name) == 0)
return ret;
down_write(&kni_list_lock);
list_for_each_entry_safe(dev, n, &kni_list_head, list) {
if (dev->port_id != port_id)
if (strncmp(dev->name, dev_info.name, RTE_KNI_NAMESIZE) != 0)
continue;
switch (dev->device_id) {
@ -389,8 +407,8 @@ kni_ioctl_release(unsigned int ioctl_num, unsigned long ioctl_param)
break;
}
up_write(&kni_list_lock);
printk(KERN_INFO "KNI: %s release kni for port %d\n",
(ret == 0 ? "Successfully" : "Unsuccessfully"), port_id);
printk(KERN_INFO "KNI: %s release kni named %s\n",
(ret == 0 ? "Successfully" : "Unsuccessfully"), dev_info.name);
return ret;
}

4
lib/librte_eal/linuxapp/kni/kni_net.c
View File

@ -535,8 +535,8 @@ kni_net_tx_timeout (struct net_device *dev)
static int
kni_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct kni_dev *kni = netdev_priv(dev);
KNI_DBG("kni_net_ioctl %d\n", kni->port_id);
KNI_DBG("kni_net_ioctl %d\n",
((struct kni_dev *)netdev_priv(dev))->group_id);
return 0;
}

151
lib/librte_kni/rte_kni.c
View File

@ -39,8 +39,6 @@
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <linux/if.h>
#include <rte_string_fns.h>
#include <rte_ethdev.h>
@ -66,8 +64,8 @@
* KNI context
*/
struct rte_kni {
char name[IFNAMSIZ]; /**< KNI interface name */
uint8_t port_id; /**< Port id KNI associate with */
char name[RTE_KNI_NAMESIZE]; /**< KNI interface name */
uint16_t group_id; /**< Group ID of KNI devices */
struct rte_mempool *pktmbuf_pool; /**< pkt mbuf mempool */
unsigned mbuf_size; /**< mbuf size */
@ -82,7 +80,7 @@ struct rte_kni {
void * sync_addr; /**< Req/Resp Mem address */
struct rte_kni_ops ops; /**< operations for request */
uint8_t port_in_use : 1; /**< kni creation flag */
uint8_t in_use : 1; /**< kni in use */
};
enum kni_ops_status {
@ -107,23 +105,47 @@ kni_memzone_reserve(const char *name, size_t len, int socket_id,
return mz;
}
/* It is deprecated and just for backward compatibility */
struct rte_kni *
rte_kni_create(uint8_t port_id,
unsigned mbuf_size,
struct rte_mempool *pktmbuf_pool,
struct rte_kni_ops *ops)
unsigned mbuf_size,
struct rte_mempool *pktmbuf_pool,
struct rte_kni_ops *ops)
{
struct rte_kni_conf conf;
struct rte_eth_dev_info info;
memset(&info, 0, sizeof(info));
memset(&conf, 0, sizeof(conf));
rte_eth_dev_info_get(port_id, &info);
rte_snprintf(conf.name, sizeof(conf.name), "vEth%u", port_id);
conf.addr = info.pci_dev->addr;
conf.id = info.pci_dev->id;
conf.group_id = (uint16_t)port_id;
conf.mbuf_size = mbuf_size;
/* Save the port id for request handling */
ops->port_id = port_id;
return rte_kni_alloc(pktmbuf_pool, &conf, ops);
}
struct rte_kni *
rte_kni_alloc(struct rte_mempool *pktmbuf_pool,
const struct rte_kni_conf *conf,
struct rte_kni_ops *ops)
{
int ret;
struct rte_kni_device_info dev_info;
struct rte_eth_dev_info eth_dev_info;
struct rte_kni *ctx;
char itf_name[IFNAMSIZ];
char intf_name[RTE_KNI_NAMESIZE];
#define OBJNAMSIZ 32
char obj_name[OBJNAMSIZ];
char mz_name[RTE_MEMZONE_NAMESIZE];
const struct rte_memzone *mz;
if (port_id >= RTE_MAX_ETHPORTS || pktmbuf_pool == NULL)
if (!pktmbuf_pool || !conf || !conf->name[0])
return NULL;
/* Check FD and open once */
@ -136,40 +158,39 @@ rte_kni_create(uint8_t port_id,
}
}
rte_eth_dev_info_get(port_id, &eth_dev_info);
RTE_LOG(INFO, KNI, "pci: %02x:%02x:%02x \t %02x:%02x\n",
eth_dev_info.pci_dev->addr.bus,
eth_dev_info.pci_dev->addr.devid,
eth_dev_info.pci_dev->addr.function,
eth_dev_info.pci_dev->id.vendor_id,
eth_dev_info.pci_dev->id.device_id);
dev_info.bus = eth_dev_info.pci_dev->addr.bus;
dev_info.devid = eth_dev_info.pci_dev->addr.devid;
dev_info.function = eth_dev_info.pci_dev->addr.function;
dev_info.vendor_id = eth_dev_info.pci_dev->id.vendor_id;
dev_info.device_id = eth_dev_info.pci_dev->id.device_id;
dev_info.port_id = port_id;
rte_snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "KNI_INFO_%d", port_id);
rte_snprintf(intf_name, RTE_KNI_NAMESIZE, conf->name);
rte_snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "KNI_INFO_%s", intf_name);
mz = kni_memzone_reserve(mz_name, sizeof(struct rte_kni),
SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx = mz->addr;
if (ctx->port_in_use != 0) {
RTE_LOG(ERR, KNI, "Port %d has been used\n", port_id);
if (ctx->in_use) {
RTE_LOG(ERR, KNI, "KNI %s is in use\n", ctx->name);
goto fail;
}
memset(ctx, 0, sizeof(struct rte_kni));
if (ops)
memcpy(&ctx->ops, ops, sizeof(struct rte_kni_ops));
rte_snprintf(itf_name, IFNAMSIZ, "vEth%u", port_id);
rte_snprintf(ctx->name, IFNAMSIZ, itf_name);
rte_snprintf(dev_info.name, IFNAMSIZ, itf_name);
memset(&dev_info, 0, sizeof(dev_info));
dev_info.bus = conf->addr.bus;
dev_info.devid = conf->addr.devid;
dev_info.function = conf->addr.function;
dev_info.vendor_id = conf->id.vendor_id;
dev_info.device_id = conf->id.device_id;
dev_info.group_id = conf->group_id;
dev_info.mbuf_size = conf->mbuf_size;
rte_snprintf(ctx->name, RTE_KNI_NAMESIZE, intf_name);
rte_snprintf(dev_info.name, RTE_KNI_NAMESIZE, intf_name);
RTE_LOG(INFO, KNI, "pci: %02x:%02x:%02x \t %02x:%02x\n",
dev_info.bus, dev_info.devid, dev_info.function,
dev_info.vendor_id, dev_info.device_id);
/* TX RING */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_tx_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_tx_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->tx_q = mz->addr;
@ -177,7 +198,7 @@ rte_kni_create(uint8_t port_id,
dev_info.tx_phys = mz->phys_addr;
/* RX RING */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_rx_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_rx_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->rx_q = mz->addr;
@ -185,7 +206,7 @@ rte_kni_create(uint8_t port_id,
dev_info.rx_phys = mz->phys_addr;
/* ALLOC RING */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_alloc_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_alloc_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->alloc_q = mz->addr;
@ -193,7 +214,7 @@ rte_kni_create(uint8_t port_id,
dev_info.alloc_phys = mz->phys_addr;
/* FREE RING */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_free_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_free_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->free_q = mz->addr;
@ -201,7 +222,7 @@ rte_kni_create(uint8_t port_id,
dev_info.free_phys = mz->phys_addr;
/* Request RING */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_req_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_req_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->req_q = mz->addr;
@ -209,7 +230,7 @@ rte_kni_create(uint8_t port_id,
dev_info.req_phys = mz->phys_addr;
/* Response RING */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_resp_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_resp_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->resp_q = mz->addr;
@ -217,7 +238,7 @@ rte_kni_create(uint8_t port_id,
dev_info.resp_phys = mz->phys_addr;
/* Req/Resp sync mem area */
rte_snprintf(obj_name, OBJNAMSIZ, "kni_sync_%d", port_id);
rte_snprintf(obj_name, OBJNAMSIZ, "kni_sync_%s", intf_name);
mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE, SOCKET_ID_ANY, 0);
KNI_MZ_CHECK(mz == NULL);
ctx->sync_addr = mz->addr;
@ -231,16 +252,13 @@ rte_kni_create(uint8_t port_id,
dev_info.mbuf_va = mz->addr;
dev_info.mbuf_phys = mz->phys_addr;
ctx->pktmbuf_pool = pktmbuf_pool;
ctx->port_id = port_id;
ctx->mbuf_size = mbuf_size;
/* Configure the buffer size which will be checked in kernel module */
dev_info.mbuf_size = ctx->mbuf_size;
ctx->group_id = conf->group_id;
ctx->mbuf_size = conf->mbuf_size;
ret = ioctl(kni_fd, RTE_KNI_IOCTL_CREATE, &dev_info);
KNI_MZ_CHECK(ret < 0);
ctx->port_in_use = 1;
ctx->in_use = 1;
return ctx;
@ -265,10 +283,13 @@ kni_free_fifo(struct rte_kni_fifo *fifo)
int
rte_kni_release(struct rte_kni *kni)
{
if (!kni || kni->port_in_use == 0)
struct rte_kni_device_info dev_info;
if (!kni || !kni->in_use)
return -1;
if (ioctl(kni_fd, RTE_KNI_IOCTL_RELEASE, &kni->port_id) < 0) {
rte_snprintf(dev_info.name, sizeof(dev_info.name), kni->name);
if (ioctl(kni_fd, RTE_KNI_IOCTL_RELEASE, &dev_info) < 0) {
RTE_LOG(ERR, KNI, "Fail to release kni device\n");
return -1;
}
@ -305,13 +326,13 @@ rte_kni_handle_request(struct rte_kni *kni)
switch (req->req_id) {
case RTE_KNI_REQ_CHANGE_MTU: /* Change MTU */
if (kni->ops.change_mtu)
req->result = kni->ops.change_mtu(kni->port_id,
req->result = kni->ops.change_mtu(kni->ops.port_id,
req->new_mtu);
break;
case RTE_KNI_REQ_CFG_NETWORK_IF: /* Set network interface up/down */
if (kni->ops.config_network_if)
req->result = kni->ops.config_network_if(kni->port_id,
req->if_up);
req->result = kni->ops.config_network_if(\
kni->ops.port_id, req->if_up);
break;
default:
RTE_LOG(ERR, KNI, "Unknown request id %u\n", req->req_id);
@ -400,37 +421,54 @@ kni_allocate_mbufs(struct rte_kni *kni)
}
}
/* It is deprecated and just for backward compatibility */
uint8_t
rte_kni_get_port_id(struct rte_kni *kni)
{
if (!kni)
return ~0x0;
return kni->port_id;
return kni->ops.port_id;
}
struct rte_kni *
rte_kni_info_get(uint8_t port_id)
rte_kni_get(const char *name)
{
struct rte_kni *kni;
const struct rte_memzone *mz;
char mz_name[RTE_MEMZONE_NAMESIZE];
if(port_id >= RTE_MAX_ETHPORTS)
if (!name || !name[0])
return NULL;
rte_snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "KNI_INFO_%d", port_id);
rte_snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "KNI_INFO_%s", name);
mz = rte_memzone_lookup(mz_name);
if (!mz)
return NULL;
kni = mz->addr;
if (0 == kni->port_in_use)
if (!kni->in_use)
return NULL;
return kni;
}
/*
* It is deprecated and just for backward compatibility.
*/
struct rte_kni *
rte_kni_info_get(uint8_t port_id)
{
char name[RTE_MEMZONE_NAMESIZE];
if (port_id >= RTE_MAX_ETHPORTS)
return NULL;
rte_snprintf(name, RTE_MEMZONE_NAMESIZE, "vEth%u", port_id);
return rte_kni_get(name);
}
static enum kni_ops_status
kni_check_request_register(struct rte_kni_ops *ops)
{
@ -478,11 +516,6 @@ rte_kni_unregister_handlers(struct rte_kni *kni)
return -1;
}
if (NULL == &kni->ops) {
RTE_LOG(ERR, KNI, "The invalid KNI unregister operation.\n");
return -1;
}
kni->ops.change_mtu = NULL;
kni->ops.config_network_if = NULL;
return 0;

84
lib/librte_kni/rte_kni.h
View File

@ -46,8 +46,11 @@
* and burst transmit packets to KNI interfaces.
*/
#include <rte_pci.h>
#include <rte_mbuf.h>
#include <exec-env/rte_kni_common.h>
#ifdef __cplusplus
extern "C" {
#endif
@ -58,6 +61,8 @@ struct rte_kni;
* Structure which has the function pointers for KNI interface.
*/
struct rte_kni_ops {
uint8_t port_id; /* Port ID */
/* Pointer to function of changing MTU */
int (*change_mtu)(uint8_t port_id, unsigned new_mtu);
@ -66,24 +71,65 @@ struct rte_kni_ops {
};
/**
* Create kni interface according to the port id. It will create a paired KNI
* interface in the kernel space for each NIC port. The KNI interface created
* Structure for configuring KNI device.
*/
struct rte_kni_conf {
/*
* KNI name which will be used in relevant network device.
* Let the name as short as possible, as it will be part of
* memzone name.
*/
char name[RTE_KNI_NAMESIZE];
uint16_t group_id; /* Group ID */
unsigned mbuf_size; /* mbuf size */
struct rte_pci_addr addr;
struct rte_pci_id id;
};
/**
* Allocate KNI interface according to the port id, mbuf size, mbuf pool,
* configurations and callbacks for kernel requests.The KNI interface created
* in the kernel space is the net interface the traditional Linux application
* talking to.
*
* @param port_id
* The port id.
* @param pktmbuf_pool
* The mempool for allocting mbufs for packets.
* @param mbuf_size
* The mbuf size to store a packet.
* @param conf
* The pointer to the configurations of the KNI device.
* @param ops
* The pointer to the callbacks for the KNI kernel requests.
*
* @return
* - The pointer to the context of a KNI interface.
* - NULL indicate error.
*/
extern struct rte_kni *rte_kni_create(uint8_t port_id, unsigned mbuf_size,
struct rte_mempool *pktmbuf_pool, struct rte_kni_ops *ops);
extern struct rte_kni *rte_kni_alloc(struct rte_mempool *pktmbuf_pool,
const struct rte_kni_conf *conf,
struct rte_kni_ops *ops);
/**
* It create a KNI device for specific port.
*
* Note: It is deprecated and just for backward compatibility.
*
* @param port_id
* Port ID.
* @param mbuf_size
* mbuf size.
* @param pktmbuf_pool
* The mempool for allocting mbufs for packets.
* @param ops
* The pointer to the callbacks for the KNI kernel requests.
*
* @return
* - The pointer to the context of a KNI interface.
* - NULL indicate error.
*/
extern struct rte_kni *rte_kni_create(uint8_t port_id,
unsigned mbuf_size,
struct rte_mempool *pktmbuf_pool,
struct rte_kni_ops *ops) \
__attribute__ ((deprecated));
/**
* Release KNI interface according to the context. It will also release the
@ -154,6 +200,8 @@ extern unsigned rte_kni_tx_burst(struct rte_kni *kni,
/**
* Get the port id from KNI interface.
*
* Note: It is deprecated and just for backward compatibility.
*
* @param kni
* The KNI interface context.
*
@ -161,11 +209,26 @@ extern unsigned rte_kni_tx_burst(struct rte_kni *kni,
* On success: The port id.
* On failure: ~0x0
*/
extern uint8_t rte_kni_get_port_id(struct rte_kni *kni);
extern uint8_t rte_kni_get_port_id(struct rte_kni *kni) \
__attribute__ ((deprecated));
/**
* Get the KNI context of its name.
*
* @param name
* pointer to the KNI device name.
*
* @return
* On success: Pointer to KNI interface.
* On failure: NULL.
*/
extern struct rte_kni *rte_kni_get(const char *name);
/**
* Get the KNI context of the specific port.
*
* Note: It is deprecated and just for backward compatibility.
*
* @param port_id
* the port id.
*
@ -173,7 +236,8 @@ extern uint8_t rte_kni_get_port_id(struct rte_kni *kni);
* On success: Pointer to KNI interface.
* On failure: NULL
*/
extern struct rte_kni * rte_kni_info_get(uint8_t port_id);
extern struct rte_kni *rte_kni_info_get(uint8_t port_id) \
__attribute__ ((deprecated));
/**
* Register KNI request handling for a specified port,and it can